Line data    Source code

       1             : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarStaticDataManagingClassStorageClassHeader.macro" */
       2             : /* JH (01/01/2006) This file is generated using ROSETTA. It should never be 
       3             :    manipulated by hand. The generation is located in buildStorageClasses.C!
       4             : 
       5             :     This file contains all declarations for the StorageClasses used for the ast file IO.
       6             : */
       7             : 
       8             : #include "StorageClassMemoryManagement.h"
       9             : 
      10             : class SgSymbolTableStorageClass;
      11             : class AstSpecificDataManagingClass;
      12             : 
      13           5 : class AstSpecificDataManagingClassStorageClass
      14             :    {
      15             : 
      16             :     protected:
      17             :      unsigned long rootOfAst;
      18             :      unsigned long listOfAccumulatedPoolSizes [ 690 + 1 ];
      19             : 
      20             : 
      21             :      unsigned long storageOf_SgNode_globalFunctionTypeTable;
      22             :      unsigned long storageOf_SgNode_globalTypeTable;
      23             :      EasyStorage < std::map<SgNode*,std::string> > storageOf_SgNode_globalMangledNameMap;
      24             :      EasyStorage < std::map<std::string, int> > storageOf_SgNode_shortMangledNameCache;
      25             :      EasyStorage < std::map<SgNode*,std::string> > storageOf_SgNode_globalQualifiedNameMapForNames;
      26             :      EasyStorage < std::map<SgNode*,std::string> > storageOf_SgNode_globalQualifiedNameMapForTypes;
      27             :      EasyStorage < std::map<SgNode*,std::string> > storageOf_SgNode_globalQualifiedNameMapForTemplateHeaders;
      28             :      EasyStorage < std::map<SgNode*,std::string> > storageOf_SgNode_globalTypeNameMap;
      29             :      EasyStorage < std::map<SgNode*,std::map<SgNode*,std::string> > > storageOf_SgNode_globalQualifiedNameMapForMapsOfTypes;
      30             :      EasyStorage < SgNodeSet > storageOf_SgSymbolTable_aliasSymbolCausalNodeSet;
      31             :      bool storageOf_SgSymbolTable_force_search_of_base_classes;
      32             :      EasyStorage < std::map<int, std::string> > storageOf_Sg_File_Info_fileidtoname_map;
      33             :      EasyStorage < std::map<std::string, int> > storageOf_Sg_File_Info_nametofileid_map;
      34             :      bool storageOf_SgFile_skip_unparse_asm_commands;
      35             :      bool storageOf_SgFile_header_file_unparsing_optimization;
      36             :      EasyStorage < SgTypePtrList > storageOf_SgUnparse_Info_structureTagProcessingList;
      37             :      bool storageOf_SgUnparse_Info_forceDefaultConstructorToTriggerError;
      38             :      bool storageOf_SgUnparse_Info_extern_C_with_braces;
      39             :      int storageOf_SgGraph_index_counter;
      40             :      int storageOf_SgGraphNode_index_counter;
      41             :      int storageOf_SgGraphEdge_index_counter;
      42             :      unsigned long storageOf_SgTypeUnknown_builtin_type;
      43             :      unsigned long storageOf_SgTypeChar_builtin_type;
      44             :      unsigned long storageOf_SgTypeSignedChar_builtin_type;
      45             :      unsigned long storageOf_SgTypeUnsignedChar_builtin_type;
      46             :      unsigned long storageOf_SgTypeShort_builtin_type;
      47             :      unsigned long storageOf_SgTypeSignedShort_builtin_type;
      48             :      unsigned long storageOf_SgTypeUnsignedShort_builtin_type;
      49             :      unsigned long storageOf_SgTypeInt_builtin_type;
      50             :      unsigned long storageOf_SgTypeSignedInt_builtin_type;
      51             :      unsigned long storageOf_SgTypeUnsignedInt_builtin_type;
      52             :      unsigned long storageOf_SgTypeLong_builtin_type;
      53             :      unsigned long storageOf_SgTypeSignedLong_builtin_type;
      54             :      unsigned long storageOf_SgTypeUnsignedLong_builtin_type;
      55             :      unsigned long storageOf_SgTypeVoid_builtin_type;
      56             :      unsigned long storageOf_SgTypeGlobalVoid_builtin_type;
      57             :      unsigned long storageOf_SgTypeWchar_builtin_type;
      58             :      unsigned long storageOf_SgTypeFloat_builtin_type;
      59             :      unsigned long storageOf_SgTypeDouble_builtin_type;
      60             :      unsigned long storageOf_SgTypeLongLong_builtin_type;
      61             :      unsigned long storageOf_SgTypeSignedLongLong_builtin_type;
      62             :      unsigned long storageOf_SgTypeUnsignedLongLong_builtin_type;
      63             :      unsigned long storageOf_SgTypeSigned128bitInteger_builtin_type;
      64             :      unsigned long storageOf_SgTypeUnsigned128bitInteger_builtin_type;
      65             :      unsigned long storageOf_SgTypeFloat80_builtin_type;
      66             :      unsigned long storageOf_SgTypeLongDouble_builtin_type;
      67             :      unsigned long storageOf_SgTypeBool_builtin_type;
      68             :      unsigned long storageOf_SgNamedType_builtin_type;
      69             :      unsigned long storageOf_SgPartialFunctionModifierType_builtin_type;
      70             :      unsigned long storageOf_SgTypeEllipse_builtin_type;
      71             :      unsigned long storageOf_SgTypeDefault_builtin_type;
      72             :      unsigned long storageOf_SgTypeCAFTeam_builtin_type;
      73             :      unsigned long storageOf_SgTypeCrayPointer_builtin_type;
      74             :      unsigned long storageOf_SgTypeLabel_builtin_type;
      75             :      unsigned long storageOf_SgTypeNullptr_builtin_type;
      76             :      unsigned long storageOf_SgTypeMatrix_builtin_type;
      77             :      unsigned long storageOf_SgTypeTuple_builtin_type;
      78             :      unsigned long storageOf_SgTypeChar16_builtin_type;
      79             :      unsigned long storageOf_SgTypeChar32_builtin_type;
      80             :      unsigned long storageOf_SgTypeFloat128_builtin_type;
      81             : 
      82             : /* #line 21 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarStaticDataManagingClassStorageClassHeader.macro" */
      83             : 
      84             :     public:
      85             :       void pickOutIRNodeData ( AstSpecificDataManagingClass* source );
      86             :       static void arrangeStaticDataOfEasyStorageClassesInOneBlock ( );
      87             :       static void deleteStaticDataOfEasyStorageClasses ( );
      88             :       static void writeEasyStorageDataToFile (std::ostream& out);
      89             :       static void readEasyStorageDataFromFile (std::istream& in);
      90             :       friend class AstSpecificDataManagingClass;
      91             :    };
      92             : 
      93             : #if 0 // done in AST_FILE_IO.h
      94             : typedef AstSpecificDataManagingClass AstData;
      95             : #endif
      96             : typedef AstSpecificDataManagingClassStorageClass AstDataStorageClass;
      97             : 
      98             : /* #line 99 "../../../src/frontend/SageIII//StorageClasses.h" */
      99             : 
     100             : 
     101             : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarStorageClassDeclatationMacros.macro" */
     102             : /* 
     103             :    JH (01/01/2006) ROSETTA generated class declarations for SgNodeStorageClass 
     104             :    used for the ast file IO. Do not chance by hand! 
     105             : */
     106             : class SgNodeStorageClass  
     107             :    {
     108             : 
     109             :     protected: 
     110             : 
     111             : 
     112             : /* #line 113 "../../../src/frontend/SageIII//StorageClasses.h" */
     113             : 
     114             :      unsigned long storageOf_parent;
     115             :       bool storageOf_isModified;
     116             :       bool storageOf_containsTransformation;
     117             : 
     118             : 
     119             : /* #line 10 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarStorageClassDeclatationMacros.macro" */
     120             : 
     121             : 
     122             :     public:
     123             :       void pickOutIRNodeData ( SgNode* source );
     124             :       static void arrangeStaticDataOfEasyStorageClassesInOneBlock ( );
     125             :       static void deleteStaticDataOfEasyStorageClasses ( );
     126             :       static void pickOutStaticDataMembers ( );
     127             :       static void rebuildStaticDataMembers ( );
     128             :       static void writeEasyStorageDataToFile (std::ostream& out);
     129             :       static void readEasyStorageDataFromFile (std::istream& in);
     130             :       static void writeStaticDataToFile (std::ostream& out );
     131             :       static void readStaticDataFromFile (std::istream& in );
     132             :       friend class SgNode;
     133             :    };
     134             : /* #line 135 "../../../src/frontend/SageIII//StorageClasses.h" */
     135             : 
     136             : 
     137             : 
     138             : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarStorageClassDeclatationMacros.macro" */
     139             : /* 
     140             :    JH (01/01/2006) ROSETTA generated class declarations for SgSupportStorageClass 
     141             :    used for the ast file IO. Do not chance by hand! 
     142             : */
     143             : class SgSupportStorageClass  : public SgNodeStorageClass
     144             :    {
     145             : 
     146             :     protected: 
     147             : 
     148             : 
     149             : /* #line 150 "../../../src/frontend/SageIII//StorageClasses.h" */
     150             : 
     151             : 
     152             : 
     153             : /* #line 10 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarStorageClassDeclatationMacros.macro" */
     154             : 
     155             : 
     156             :     public:
     157             :       void pickOutIRNodeData ( SgSupport* source );
     158             :       static void arrangeStaticDataOfEasyStorageClassesInOneBlock ( );
     159             :       static void deleteStaticDataOfEasyStorageClasses ( );
     160             :       static void pickOutStaticDataMembers ( );
     161             :       static void rebuildStaticDataMembers ( );
     162             :       static void writeEasyStorageDataToFile (std::ostream& out);
     163             :       static void readEasyStorageDataFromFile (std::istream& in);
     164             :       static void writeStaticDataToFile (std::ostream& out );
     165             :       static void readStaticDataFromFile (std::istream& in );
     166             :       friend class SgSupport;
     167             :    };
     168             : /* #line 169 "../../../src/frontend/SageIII//StorageClasses.h" */
     169             : 
     170             : 
     171             : 
     172             : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarStorageClassDeclatationMacros.macro" */
     173             : /* 
     174             :    JH (01/01/2006) ROSETTA generated class declarations for SgModifierStorageClass 
     175             :    used for the ast file IO. Do not chance by hand! 
     176             : */
     177             : class SgModifierStorageClass  : public SgSupportStorageClass
     178             :    {
     179             : 
     180             :     protected: 
     181             : 
     182             : 
     183             : /* #line 184 "../../../src/frontend/SageIII//StorageClasses.h" */
     184             : 
     185             : 
     186             : 
     187             : /* #line 10 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarStorageClassDeclatationMacros.macro" */
     188             : 
     189             : 
     190             :     public:
     191             :       void pickOutIRNodeData ( SgModifier* source );
     192             :       static void arrangeStaticDataOfEasyStorageClassesInOneBlock ( );
     193             :       static void deleteStaticDataOfEasyStorageClasses ( );
     194             :       static void pickOutStaticDataMembers ( );
     195             :       static void rebuildStaticDataMembers ( );
     196             :       static void writeEasyStorageDataToFile (std::ostream& out);
     197             :       static void readEasyStorageDataFromFile (std::istream& in);
     198             :       static void writeStaticDataToFile (std::ostream& out );
     199             :       static void readStaticDataFromFile (std::istream& in );
     200             :       friend class SgModifier;
     201             :    };
     202             : /* #line 203 "../../../src/frontend/SageIII//StorageClasses.h" */
     203             : 
     204             : 
     205             : 
     206             : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarStorageClassDeclatationMacros.macro" */
     207             : /* 
     208             :    JH (01/01/2006) ROSETTA generated class declarations for SgModifierNodesStorageClass 
     209             :    used for the ast file IO. Do not chance by hand! 
     210             : */
     211           0 : class SgModifierNodesStorageClass  : public SgModifierStorageClass
     212             :    {
     213             : 
     214             :     protected: 
     215             : 
     216             : 
     217             : /* #line 218 "../../../src/frontend/SageIII//StorageClasses.h" */
     218             : 
     219             :        EasyStorage < SgModifierTypePtrVector > storageOf_nodes;
     220             :      unsigned long storageOf_next;
     221             : 
     222             : 
     223             : /* #line 10 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarStorageClassDeclatationMacros.macro" */
     224             : 
     225             : 
     226             :     public:
     227             :       void pickOutIRNodeData ( SgModifierNodes* source );
     228             :       static void arrangeStaticDataOfEasyStorageClassesInOneBlock ( );
     229             :       static void deleteStaticDataOfEasyStorageClasses ( );
     230             :       static void pickOutStaticDataMembers ( );
     231             :       static void rebuildStaticDataMembers ( );
     232             :       static void writeEasyStorageDataToFile (std::ostream& out);
     233             :       static void readEasyStorageDataFromFile (std::istream& in);
     234             :       static void writeStaticDataToFile (std::ostream& out );
     235             :       static void readStaticDataFromFile (std::istream& in );
     236             :       friend class SgModifierNodes;
     237             :    };
     238             : /* #line 239 "../../../src/frontend/SageIII//StorageClasses.h" */
     239             : 
     240             : 
     241             : 
     242             : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarStorageClassDeclatationMacros.macro" */
     243             : /* 
     244             :    JH (01/01/2006) ROSETTA generated class declarations for SgConstVolatileModifierStorageClass 
     245             :    used for the ast file IO. Do not chance by hand! 
     246             : */
     247             : class SgConstVolatileModifierStorageClass  : public SgModifierStorageClass
     248             :    {
     249             : 
     250             :     protected: 
     251             : 
     252             : 
     253             : /* #line 254 "../../../src/frontend/SageIII//StorageClasses.h" */
     254             : 
     255             :       SgConstVolatileModifier::cv_modifier_enum storageOf_modifier;
     256             : 
     257             : 
     258             : /* #line 10 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarStorageClassDeclatationMacros.macro" */
     259             : 
     260             : 
     261             :     public:
     262             :       void pickOutIRNodeData ( SgConstVolatileModifier* source );
     263             :       static void arrangeStaticDataOfEasyStorageClassesInOneBlock ( );
     264             :       static void deleteStaticDataOfEasyStorageClasses ( );
     265             :       static void pickOutStaticDataMembers ( );
     266             :       static void rebuildStaticDataMembers ( );
     267             :       static void writeEasyStorageDataToFile (std::ostream& out);
     268             :       static void readEasyStorageDataFromFile (std::istream& in);
     269             :       static void writeStaticDataToFile (std::ostream& out );
     270             :       static void readStaticDataFromFile (std::istream& in );
     271             :       friend class SgConstVolatileModifier;
     272             :    };
     273             : /* #line 274 "../../../src/frontend/SageIII//StorageClasses.h" */
     274             : 
     275             : 
     276             : 
     277             : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarStorageClassDeclatationMacros.macro" */
     278             : /* 
     279             :    JH (01/01/2006) ROSETTA generated class declarations for SgStorageModifierStorageClass 
     280             :    used for the ast file IO. Do not chance by hand! 
     281             : */
     282             : class SgStorageModifierStorageClass  : public SgModifierStorageClass
     283             :    {
     284             : 
     285             :     protected: 
     286             : 
     287             : 
     288             : /* #line 289 "../../../src/frontend/SageIII//StorageClasses.h" */
     289             : 
     290             :       SgStorageModifier::storage_modifier_enum storageOf_modifier;
     291             :       bool storageOf_thread_local_storage;
     292             : 
     293             : 
     294             : /* #line 10 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarStorageClassDeclatationMacros.macro" */
     295             : 
     296             : 
     297             :     public:
     298             :       void pickOutIRNodeData ( SgStorageModifier* source );
     299             :       static void arrangeStaticDataOfEasyStorageClassesInOneBlock ( );
     300             :       static void deleteStaticDataOfEasyStorageClasses ( );
     301             :       static void pickOutStaticDataMembers ( );
     302             :       static void rebuildStaticDataMembers ( );
     303             :       static void writeEasyStorageDataToFile (std::ostream& out);
     304             :       static void readEasyStorageDataFromFile (std::istream& in);
     305             :       static void writeStaticDataToFile (std::ostream& out );
     306             :       static void readStaticDataFromFile (std::istream& in );
     307             :       friend class SgStorageModifier;
     308             :    };
     309             : /* #line 310 "../../../src/frontend/SageIII//StorageClasses.h" */
     310             : 
     311             : 
     312             : 
     313             : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarStorageClassDeclatationMacros.macro" */
     314             : /* 
     315             :    JH (01/01/2006) ROSETTA generated class declarations for SgAccessModifierStorageClass 
     316             :    used for the ast file IO. Do not chance by hand! 
     317             : */
     318             : class SgAccessModifierStorageClass  : public SgModifierStorageClass
     319             :    {
     320             : 
     321             :     protected: 
     322             : 
     323             : 
     324             : /* #line 325 "../../../src/frontend/SageIII//StorageClasses.h" */
     325             : 
     326             :       SgAccessModifier::access_modifier_enum storageOf_modifier;
     327             : 
     328             : 
     329             : /* #line 10 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarStorageClassDeclatationMacros.macro" */
     330             : 
     331             : 
     332             :     public:
     333             :       void pickOutIRNodeData ( SgAccessModifier* source );
     334             :       static void arrangeStaticDataOfEasyStorageClassesInOneBlock ( );
     335             :       static void deleteStaticDataOfEasyStorageClasses ( );
     336             :       static void pickOutStaticDataMembers ( );
     337             :       static void rebuildStaticDataMembers ( );
     338             :       static void writeEasyStorageDataToFile (std::ostream& out);
     339             :       static void readEasyStorageDataFromFile (std::istream& in);
     340             :       static void writeStaticDataToFile (std::ostream& out );
     341             :       static void readStaticDataFromFile (std::istream& in );
     342             :       friend class SgAccessModifier;
     343             :    };
     344             : /* #line 345 "../../../src/frontend/SageIII//StorageClasses.h" */
     345             : 
     346             : 
     347             : 
     348             : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarStorageClassDeclatationMacros.macro" */
     349             : /* 
     350             :    JH (01/01/2006) ROSETTA generated class declarations for SgFunctionModifierStorageClass 
     351             :    used for the ast file IO. Do not chance by hand! 
     352             : */
     353           0 : class SgFunctionModifierStorageClass  : public SgModifierStorageClass
     354             :    {
     355             : 
     356             :     protected: 
     357             : 
     358             : 
     359             : /* #line 360 "../../../src/frontend/SageIII//StorageClasses.h" */
     360             : 
     361             :        EasyStorage < SgBitVector > storageOf_modifierVector;
     362             :       unsigned long int storageOf_gnu_attribute_constructor_destructor_priority;
     363             :        EasyStorage < std::string > storageOf_gnu_attribute_named_weak_reference;
     364             :        EasyStorage < std::string > storageOf_gnu_attribute_named_alias;
     365             :      unsigned long storageOf_opencl_vec_type;
     366             :       SgFunctionModifier::opencl_work_group_size_t storageOf_opencl_work_group_size;
     367             : 
     368             : 
     369             : /* #line 10 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarStorageClassDeclatationMacros.macro" */
     370             : 
     371             : 
     372             :     public:
     373             :       void pickOutIRNodeData ( SgFunctionModifier* source );
     374             :       static void arrangeStaticDataOfEasyStorageClassesInOneBlock ( );
     375             :       static void deleteStaticDataOfEasyStorageClasses ( );
     376             :       static void pickOutStaticDataMembers ( );
     377             :       static void rebuildStaticDataMembers ( );
     378             :       static void writeEasyStorageDataToFile (std::ostream& out);
     379             :       static void readEasyStorageDataFromFile (std::istream& in);
     380             :       static void writeStaticDataToFile (std::ostream& out );
     381             :       static void readStaticDataFromFile (std::istream& in );
     382             :       friend class SgFunctionModifier;
     383             :    };
     384             : /* #line 385 "../../../src/frontend/SageIII//StorageClasses.h" */
     385             : 
     386             : 
     387             : 
     388             : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarStorageClassDeclatationMacros.macro" */
     389             : /* 
     390             :    JH (01/01/2006) ROSETTA generated class declarations for SgUPC_AccessModifierStorageClass 
     391             :    used for the ast file IO. Do not chance by hand! 
     392             : */
     393             : class SgUPC_AccessModifierStorageClass  : public SgModifierStorageClass
     394             :    {
     395             : 
     396             :     protected: 
     397             : 
     398             : 
     399             : /* #line 400 "../../../src/frontend/SageIII//StorageClasses.h" */
     400             : 
     401             :       SgUPC_AccessModifier::upc_access_modifier_enum storageOf_modifier;
     402             :       bool storageOf_isShared;
     403             :       long storageOf_layout;
     404             : 
     405             : 
     406             : /* #line 10 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarStorageClassDeclatationMacros.macro" */
     407             : 
     408             : 
     409             :     public:
     410             :       void pickOutIRNodeData ( SgUPC_AccessModifier* source );
     411             :       static void arrangeStaticDataOfEasyStorageClassesInOneBlock ( );
     412             :       static void deleteStaticDataOfEasyStorageClasses ( );
     413             :       static void pickOutStaticDataMembers ( );
     414             :       static void rebuildStaticDataMembers ( );
     415             :       static void writeEasyStorageDataToFile (std::ostream& out);
     416             :       static void readEasyStorageDataFromFile (std::istream& in);
     417             :       static void writeStaticDataToFile (std::ostream& out );
     418             :       static void readStaticDataFromFile (std::istream& in );
     419             :       friend class SgUPC_AccessModifier;
     420             :    };
     421             : /* #line 422 "../../../src/frontend/SageIII//StorageClasses.h" */
     422             : 
     423             : 
     424             : 
     425             : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarStorageClassDeclatationMacros.macro" */
     426             : /* 
     427             :    JH (01/01/2006) ROSETTA generated class declarations for SgSpecialFunctionModifierStorageClass 
     428             :    used for the ast file IO. Do not chance by hand! 
     429             : */
     430           0 : class SgSpecialFunctionModifierStorageClass  : public SgModifierStorageClass
     431             :    {
     432             : 
     433             :     protected: 
     434             : 
     435             : 
     436             : /* #line 437 "../../../src/frontend/SageIII//StorageClasses.h" */
     437             : 
     438             :        EasyStorage < SgBitVector > storageOf_modifierVector;
     439             : 
     440             : 
     441             : /* #line 10 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarStorageClassDeclatationMacros.macro" */
     442             : 
     443             : 
     444             :     public:
     445             :       void pickOutIRNodeData ( SgSpecialFunctionModifier* source );
     446             :       static void arrangeStaticDataOfEasyStorageClassesInOneBlock ( );
     447             :       static void deleteStaticDataOfEasyStorageClasses ( );
     448             :       static void pickOutStaticDataMembers ( );
     449             :       static void rebuildStaticDataMembers ( );
     450             :       static void writeEasyStorageDataToFile (std::ostream& out);
     451             :       static void readEasyStorageDataFromFile (std::istream& in);
     452             :       static void writeStaticDataToFile (std::ostream& out );
     453             :       static void readStaticDataFromFile (std::istream& in );
     454             :       friend class SgSpecialFunctionModifier;
     455             :    };
     456             : /* #line 457 "../../../src/frontend/SageIII//StorageClasses.h" */
     457             : 
     458             : 
     459             : 
     460             : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarStorageClassDeclatationMacros.macro" */
     461             : /* 
     462             :    JH (01/01/2006) ROSETTA generated class declarations for SgElaboratedTypeModifierStorageClass 
     463             :    used for the ast file IO. Do not chance by hand! 
     464             : */
     465             : class SgElaboratedTypeModifierStorageClass  : public SgModifierStorageClass
     466             :    {
     467             : 
     468             :     protected: 
     469             : 
     470             : 
     471             : /* #line 472 "../../../src/frontend/SageIII//StorageClasses.h" */
     472             : 
     473             :       SgElaboratedTypeModifier::elaborated_type_modifier_enum storageOf_modifier;
     474             : 
     475             : 
     476             : /* #line 10 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarStorageClassDeclatationMacros.macro" */
     477             : 
     478             : 
     479             :     public:
     480             :       void pickOutIRNodeData ( SgElaboratedTypeModifier* source );
     481             :       static void arrangeStaticDataOfEasyStorageClassesInOneBlock ( );
     482             :       static void deleteStaticDataOfEasyStorageClasses ( );
     483             :       static void pickOutStaticDataMembers ( );
     484             :       static void rebuildStaticDataMembers ( );
     485             :       static void writeEasyStorageDataToFile (std::ostream& out);
     486             :       static void readEasyStorageDataFromFile (std::istream& in);
     487             :       static void writeStaticDataToFile (std::ostream& out );
     488             :       static void readStaticDataFromFile (std::istream& in );
     489             :       friend class SgElaboratedTypeModifier;
     490             :    };
     491             : /* #line 492 "../../../src/frontend/SageIII//StorageClasses.h" */
     492             : 
     493             : 
     494             : 
     495             : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarStorageClassDeclatationMacros.macro" */
     496             : /* 
     497             :    JH (01/01/2006) ROSETTA generated class declarations for SgLinkageModifierStorageClass 
     498             :    used for the ast file IO. Do not chance by hand! 
     499             : */
     500             : class SgLinkageModifierStorageClass  : public SgModifierStorageClass
     501             :    {
     502             : 
     503             :     protected: 
     504             : 
     505             : 
     506             : /* #line 507 "../../../src/frontend/SageIII//StorageClasses.h" */
     507             : 
     508             :       SgLinkageModifier::linkage_modifier_enum storageOf_modifier;
     509             : 
     510             : 
     511             : /* #line 10 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarStorageClassDeclatationMacros.macro" */
     512             : 
     513             : 
     514             :     public:
     515             :       void pickOutIRNodeData ( SgLinkageModifier* source );
     516             :       static void arrangeStaticDataOfEasyStorageClassesInOneBlock ( );
     517             :       static void deleteStaticDataOfEasyStorageClasses ( );
     518             :       static void pickOutStaticDataMembers ( );
     519             :       static void rebuildStaticDataMembers ( );
     520             :       static void writeEasyStorageDataToFile (std::ostream& out);
     521             :       static void readEasyStorageDataFromFile (std::istream& in);
     522             :       static void writeStaticDataToFile (std::ostream& out );
     523             :       static void readStaticDataFromFile (std::istream& in );
     524             :       friend class SgLinkageModifier;
     525             :    };
     526             : /* #line 527 "../../../src/frontend/SageIII//StorageClasses.h" */
     527             : 
     528             : 
     529             : 
     530             : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarStorageClassDeclatationMacros.macro" */
     531             : /* 
     532             :    JH (01/01/2006) ROSETTA generated class declarations for SgBaseClassModifierStorageClass 
     533             :    used for the ast file IO. Do not chance by hand! 
     534             : */
     535             : class SgBaseClassModifierStorageClass  : public SgModifierStorageClass
     536             :    {
     537             : 
     538             :     protected: 
     539             : 
     540             : 
     541             : /* #line 542 "../../../src/frontend/SageIII//StorageClasses.h" */
     542             : 
     543             :       SgBaseClassModifier::baseclass_modifier_enum storageOf_modifier;
     544             :       SgAccessModifierStorageClass storageOf_accessModifier;
     545             : 
     546             : 
     547             : /* #line 10 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarStorageClassDeclatationMacros.macro" */
     548             : 
     549             : 
     550             :     public:
     551             :       void pickOutIRNodeData ( SgBaseClassModifier* source );
     552             :       static void arrangeStaticDataOfEasyStorageClassesInOneBlock ( );
     553             :       static void deleteStaticDataOfEasyStorageClasses ( );
     554             :       static void pickOutStaticDataMembers ( );
     555             :       static void rebuildStaticDataMembers ( );
     556             :       static void writeEasyStorageDataToFile (std::ostream& out);
     557             :       static void readEasyStorageDataFromFile (std::istream& in);
     558             :       static void writeStaticDataToFile (std::ostream& out );
     559             :       static void readStaticDataFromFile (std::istream& in );
     560             :       friend class SgBaseClassModifier;
     561             :    };
     562             : /* #line 563 "../../../src/frontend/SageIII//StorageClasses.h" */
     563             : 
     564             : 
     565             : 
     566             : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarStorageClassDeclatationMacros.macro" */
     567             : /* 
     568             :    JH (01/01/2006) ROSETTA generated class declarations for SgStructureModifierStorageClass 
     569             :    used for the ast file IO. Do not chance by hand! 
     570             : */
     571             : class SgStructureModifierStorageClass  : public SgModifierStorageClass
     572             :    {
     573             : 
     574             :     protected: 
     575             : 
     576             : 
     577             : /* #line 578 "../../../src/frontend/SageIII//StorageClasses.h" */
     578             : 
     579             :       SgStructureModifier::jovial_structure_modifier_enum storageOf_modifier;
     580             :       int storageOf_bits_per_entry;
     581             : 
     582             : 
     583             : /* #line 10 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarStorageClassDeclatationMacros.macro" */
     584             : 
     585             : 
     586             :     public:
     587             :       void pickOutIRNodeData ( SgStructureModifier* source );
     588             :       static void arrangeStaticDataOfEasyStorageClassesInOneBlock ( );
     589             :       static void deleteStaticDataOfEasyStorageClasses ( );
     590             :       static void pickOutStaticDataMembers ( );
     591             :       static void rebuildStaticDataMembers ( );
     592             :       static void writeEasyStorageDataToFile (std::ostream& out);
     593             :       static void readEasyStorageDataFromFile (std::istream& in);
     594             :       static void writeStaticDataToFile (std::ostream& out );
     595             :       static void readStaticDataFromFile (std::istream& in );
     596             :       friend class SgStructureModifier;
     597             :    };
     598             : /* #line 599 "../../../src/frontend/SageIII//StorageClasses.h" */
     599             : 
     600             : 
     601             : 
     602             : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarStorageClassDeclatationMacros.macro" */
     603             : /* 
     604             :    JH (01/01/2006) ROSETTA generated class declarations for SgTypeModifierStorageClass 
     605             :    used for the ast file IO. Do not chance by hand! 
     606             : */
     607       82617 : class SgTypeModifierStorageClass  : public SgModifierStorageClass
     608             :    {
     609             : 
     610             :     protected: 
     611             : 
     612             : 
     613             : /* #line 614 "../../../src/frontend/SageIII//StorageClasses.h" */
     614             : 
     615             :        EasyStorage < SgBitVector > storageOf_modifierVector;
     616             :       SgUPC_AccessModifierStorageClass storageOf_upcModifier;
     617             :       SgStructureModifierStorageClass storageOf_structureModifier;
     618             :       SgConstVolatileModifierStorageClass storageOf_constVolatileModifier;
     619             :       SgElaboratedTypeModifierStorageClass storageOf_elaboratedTypeModifier;
     620             :       SgTypeModifier::gnu_extension_machine_mode_enum storageOf_gnu_extension_machine_mode;
     621             :       int storageOf_gnu_attribute_alignment;
     622             :       long storageOf_gnu_attribute_sentinel;
     623             :       unsigned storageOf_address_space_value;
     624             :       unsigned storageOf_vector_size;
     625             : 
     626             : 
     627             : /* #line 10 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarStorageClassDeclatationMacros.macro" */
     628             : 
     629             : 
     630             :     public:
     631             :       void pickOutIRNodeData ( SgTypeModifier* source );
     632             :       static void arrangeStaticDataOfEasyStorageClassesInOneBlock ( );
     633             :       static void deleteStaticDataOfEasyStorageClasses ( );
     634             :       static void pickOutStaticDataMembers ( );
     635             :       static void rebuildStaticDataMembers ( );
     636             :       static void writeEasyStorageDataToFile (std::ostream& out);
     637             :       static void readEasyStorageDataFromFile (std::istream& in);
     638             :       static void writeStaticDataToFile (std::ostream& out );
     639             :       static void readStaticDataFromFile (std::istream& in );
     640             :       friend class SgTypeModifier;
     641             :    };
     642             : /* #line 643 "../../../src/frontend/SageIII//StorageClasses.h" */
     643             : 
     644             : 
     645             : 
     646             : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarStorageClassDeclatationMacros.macro" */
     647             : /* 
     648             :    JH (01/01/2006) ROSETTA generated class declarations for SgDeclarationModifierStorageClass 
     649             :    used for the ast file IO. Do not chance by hand! 
     650             : */
     651       80865 : class SgDeclarationModifierStorageClass  : public SgModifierStorageClass
     652             :    {
     653             : 
     654             :     protected: 
     655             : 
     656             : 
     657             : /* #line 658 "../../../src/frontend/SageIII//StorageClasses.h" */
     658             : 
     659             :        EasyStorage < SgBitVector > storageOf_modifierVector;
     660             :       SgTypeModifierStorageClass storageOf_typeModifier;
     661             :       SgAccessModifierStorageClass storageOf_accessModifier;
     662             :       SgStorageModifierStorageClass storageOf_storageModifier;
     663             :        EasyStorage < std::string > storageOf_gnu_attribute_section_name;
     664             :       SgDeclarationModifier::gnu_declaration_visability_enum storageOf_gnu_attribute_visability;
     665             :        EasyStorage < std::string > storageOf_microsoft_uuid_string;
     666             :        EasyStorage < std::string > storageOf_microsoft_property_get_function_name;
     667             :        EasyStorage < std::string > storageOf_microsoft_property_put_function_name;
     668             : 
     669             : 
     670             : /* #line 10 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarStorageClassDeclatationMacros.macro" */
     671             : 
     672             : 
     673             :     public:
     674             :       void pickOutIRNodeData ( SgDeclarationModifier* source );
     675             :       static void arrangeStaticDataOfEasyStorageClassesInOneBlock ( );
     676             :       static void deleteStaticDataOfEasyStorageClasses ( );
     677             :       static void pickOutStaticDataMembers ( );
     678             :       static void rebuildStaticDataMembers ( );
     679             :       static void writeEasyStorageDataToFile (std::ostream& out);
     680             :       static void readEasyStorageDataFromFile (std::istream& in);
     681             :       static void writeStaticDataToFile (std::ostream& out );
     682             :       static void readStaticDataFromFile (std::istream& in );
     683             :       friend class SgDeclarationModifier;
     684             :    };
     685             : /* #line 686 "../../../src/frontend/SageIII//StorageClasses.h" */
     686             : 
     687             : 
     688             : 
     689             : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarStorageClassDeclatationMacros.macro" */
     690             : /* 
     691             :    JH (01/01/2006) ROSETTA generated class declarations for SgOpenclAccessModeModifierStorageClass 
     692             :    used for the ast file IO. Do not chance by hand! 
     693             : */
     694             : class SgOpenclAccessModeModifierStorageClass  : public SgModifierStorageClass
     695             :    {
     696             : 
     697             :     protected: 
     698             : 
     699             : 
     700             : /* #line 701 "../../../src/frontend/SageIII//StorageClasses.h" */
     701             : 
     702             :       SgOpenclAccessModeModifier::access_mode_modifier_enum storageOf_modifier;
     703             : 
     704             : 
     705             : /* #line 10 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarStorageClassDeclatationMacros.macro" */
     706             : 
     707             : 
     708             :     public:
     709             :       void pickOutIRNodeData ( SgOpenclAccessModeModifier* source );
     710             :       static void arrangeStaticDataOfEasyStorageClassesInOneBlock ( );
     711             :       static void deleteStaticDataOfEasyStorageClasses ( );
     712             :       static void pickOutStaticDataMembers ( );
     713             :       static void rebuildStaticDataMembers ( );
     714             :       static void writeEasyStorageDataToFile (std::ostream& out);
     715             :       static void readEasyStorageDataFromFile (std::istream& in);
     716             :       static void writeStaticDataToFile (std::ostream& out );
     717             :       static void readStaticDataFromFile (std::istream& in );
     718             :       friend class SgOpenclAccessModeModifier;
     719             :    };
     720             : /* #line 721 "../../../src/frontend/SageIII//StorageClasses.h" */
     721             : 
     722             : 
     723             : 
     724             : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarStorageClassDeclatationMacros.macro" */
     725             : /* 
     726             :    JH (01/01/2006) ROSETTA generated class declarations for SgNameStorageClass 
     727             :    used for the ast file IO. Do not chance by hand! 
     728             : */
     729      183265 : class SgNameStorageClass  : public SgSupportStorageClass
     730             :    {
     731             : 
     732             :     protected: 
     733             : 
     734             : 
     735             : /* #line 736 "../../../src/frontend/SageIII//StorageClasses.h" */
     736             : 
     737             :        EasyStorage < std::string > storageOf_char;
     738             : 
     739             : 
     740             : /* #line 10 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarStorageClassDeclatationMacros.macro" */
     741             : 
     742             : 
     743             :     public:
     744             :       void pickOutIRNodeData ( SgName* source );
     745             :       static void arrangeStaticDataOfEasyStorageClassesInOneBlock ( );
     746             :       static void deleteStaticDataOfEasyStorageClasses ( );
     747             :       static void pickOutStaticDataMembers ( );
     748             :       static void rebuildStaticDataMembers ( );
     749             :       static void writeEasyStorageDataToFile (std::ostream& out);
     750             :       static void readEasyStorageDataFromFile (std::istream& in);
     751             :       static void writeStaticDataToFile (std::ostream& out );
     752             :       static void readStaticDataFromFile (std::istream& in );
     753             :       friend class SgName;
     754             :    };
     755             : /* #line 756 "../../../src/frontend/SageIII//StorageClasses.h" */
     756             : 
     757             : 
     758             : 
     759             : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarStorageClassDeclatationMacros.macro" */
     760             : /* 
     761             :    JH (01/01/2006) ROSETTA generated class declarations for SgSymbolTableStorageClass 
     762             :    used for the ast file IO. Do not chance by hand! 
     763             : */
     764       53810 : class SgSymbolTableStorageClass  : public SgSupportStorageClass
     765             :    {
     766             : 
     767             :     protected: 
     768             : 
     769             : 
     770             : /* #line 771 "../../../src/frontend/SageIII//StorageClasses.h" */
     771             : 
     772             :       SgNameStorageClass storageOf_name;
     773             :       bool storageOf_no_name;
     774             :        EasyStorage <  rose_hash_multimap* > storageOf_table;
     775             :        EasyStorage < SgNodeSet > storageOf_symbolSet;
     776             :       bool storageOf_case_insensitive;
     777             : 
     778             : 
     779             : /* #line 10 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarStorageClassDeclatationMacros.macro" */
     780             : 
     781             : 
     782             :     public:
     783             :       void pickOutIRNodeData ( SgSymbolTable* source );
     784             :       static void arrangeStaticDataOfEasyStorageClassesInOneBlock ( );
     785             :       static void deleteStaticDataOfEasyStorageClasses ( );
     786             :       static void pickOutStaticDataMembers ( );
     787             :       static void rebuildStaticDataMembers ( );
     788             :       static void writeEasyStorageDataToFile (std::ostream& out);
     789             :       static void readEasyStorageDataFromFile (std::istream& in);
     790             :       static void writeStaticDataToFile (std::ostream& out );
     791             :       static void readStaticDataFromFile (std::istream& in );
     792             :       friend class SgSymbolTable;
     793             :    };
     794             : /* #line 795 "../../../src/frontend/SageIII//StorageClasses.h" */
     795             : 
     796             : 
     797             : 
     798             : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarStorageClassDeclatationMacros.macro" */
     799             : /* 
     800             :    JH (01/01/2006) ROSETTA generated class declarations for SgAttributeStorageClass 
     801             :    used for the ast file IO. Do not chance by hand! 
     802             : */
     803           0 : class SgAttributeStorageClass  : public SgSupportStorageClass
     804             :    {
     805             : 
     806             :     protected: 
     807             : 
     808             : 
     809             : /* #line 810 "../../../src/frontend/SageIII//StorageClasses.h" */
     810             : 
     811             :        EasyStorage < std::string > storageOf_name;
     812             : 
     813             : 
     814             : /* #line 10 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarStorageClassDeclatationMacros.macro" */
     815             : 
     816             : 
     817             :     public:
     818             :       void pickOutIRNodeData ( SgAttribute* source );
     819             :       static void arrangeStaticDataOfEasyStorageClassesInOneBlock ( );
     820             :       static void deleteStaticDataOfEasyStorageClasses ( );
     821             :       static void pickOutStaticDataMembers ( );
     822             :       static void rebuildStaticDataMembers ( );
     823             :       static void writeEasyStorageDataToFile (std::ostream& out);
     824             :       static void readEasyStorageDataFromFile (std::istream& in);
     825             :       static void writeStaticDataToFile (std::ostream& out );
     826             :       static void readStaticDataFromFile (std::istream& in );
     827             :       friend class SgAttribute;
     828             :    };
     829             : /* #line 830 "../../../src/frontend/SageIII//StorageClasses.h" */
     830             : 
     831             : 
     832             : 
     833             : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarStorageClassDeclatationMacros.macro" */
     834             : /* 
     835             :    JH (01/01/2006) ROSETTA generated class declarations for SgPragmaStorageClass 
     836             :    used for the ast file IO. Do not chance by hand! 
     837             : */
     838         194 : class SgPragmaStorageClass  : public SgAttributeStorageClass
     839             :    {
     840             : 
     841             :     protected: 
     842             : 
     843             : 
     844             : /* #line 845 "../../../src/frontend/SageIII//StorageClasses.h" */
     845             : 
     846             :      unsigned long storageOf_startOfConstruct;
     847             :      unsigned long storageOf_endOfConstruct;
     848             :       short storageOf_printed;
     849             :      unsigned long storageOf_args;
     850             :        EasyStorage < AstAttributeMechanism* > storageOf_attributeMechanism;
     851             : 
     852             : 
     853             : /* #line 10 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarStorageClassDeclatationMacros.macro" */
     854             : 
     855             : 
     856             :     public:
     857             :       void pickOutIRNodeData ( SgPragma* source );
     858             :       static void arrangeStaticDataOfEasyStorageClassesInOneBlock ( );
     859             :       static void deleteStaticDataOfEasyStorageClasses ( );
     860             :       static void pickOutStaticDataMembers ( );
     861             :       static void rebuildStaticDataMembers ( );
     862             :       static void writeEasyStorageDataToFile (std::ostream& out);
     863             :       static void readEasyStorageDataFromFile (std::istream& in);
     864             :       static void writeStaticDataToFile (std::ostream& out );
     865             :       static void readStaticDataFromFile (std::istream& in );
     866             :       friend class SgPragma;
     867             :    };
     868             : /* #line 869 "../../../src/frontend/SageIII//StorageClasses.h" */
     869             : 
     870             : 
     871             : 
     872             : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarStorageClassDeclatationMacros.macro" */
     873             : /* 
     874             :    JH (01/01/2006) ROSETTA generated class declarations for SgBitAttributeStorageClass 
     875             :    used for the ast file IO. Do not chance by hand! 
     876             : */
     877           0 : class SgBitAttributeStorageClass  : public SgAttributeStorageClass
     878             :    {
     879             : 
     880             :     protected: 
     881             : 
     882             : 
     883             : /* #line 884 "../../../src/frontend/SageIII//StorageClasses.h" */
     884             : 
     885             :       unsigned long int storageOf_bitflag;
     886             : 
     887             : 
     888             : /* #line 10 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarStorageClassDeclatationMacros.macro" */
     889             : 
     890             : 
     891             :     public:
     892             :       void pickOutIRNodeData ( SgBitAttribute* source );
     893             :       static void arrangeStaticDataOfEasyStorageClassesInOneBlock ( );
     894             :       static void deleteStaticDataOfEasyStorageClasses ( );
     895             :       static void pickOutStaticDataMembers ( );
     896             :       static void rebuildStaticDataMembers ( );
     897             :       static void writeEasyStorageDataToFile (std::ostream& out);
     898             :       static void readEasyStorageDataFromFile (std::istream& in);
     899             :       static void writeStaticDataToFile (std::ostream& out );
     900             :       static void readStaticDataFromFile (std::istream& in );
     901             :       friend class SgBitAttribute;
     902             :    };
     903             : /* #line 904 "../../../src/frontend/SageIII//StorageClasses.h" */
     904             : 
     905             : 
     906             : 
     907             : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarStorageClassDeclatationMacros.macro" */
     908             : /* 
     909             :    JH (01/01/2006) ROSETTA generated class declarations for SgFuncDecl_attrStorageClass 
     910             :    used for the ast file IO. Do not chance by hand! 
     911             : */
     912           0 : class SgFuncDecl_attrStorageClass  : public SgBitAttributeStorageClass
     913             :    {
     914             : 
     915             :     protected: 
     916             : 
     917             : 
     918             : /* #line 919 "../../../src/frontend/SageIII//StorageClasses.h" */
     919             : 
     920             : 
     921             : 
     922             : /* #line 10 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarStorageClassDeclatationMacros.macro" */
     923             : 
     924             : 
     925             :     public:
     926             :       void pickOutIRNodeData ( SgFuncDecl_attr* source );
     927             :       static void arrangeStaticDataOfEasyStorageClassesInOneBlock ( );
     928             :       static void deleteStaticDataOfEasyStorageClasses ( );
     929             :       static void pickOutStaticDataMembers ( );
     930             :       static void rebuildStaticDataMembers ( );
     931             :       static void writeEasyStorageDataToFile (std::ostream& out);
     932             :       static void readEasyStorageDataFromFile (std::istream& in);
     933             :       static void writeStaticDataToFile (std::ostream& out );
     934             :       static void readStaticDataFromFile (std::istream& in );
     935             :       friend class SgFuncDecl_attr;
     936             :    };
     937             : /* #line 938 "../../../src/frontend/SageIII//StorageClasses.h" */
     938             : 
     939             : 
     940             : 
     941             : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarStorageClassDeclatationMacros.macro" */
     942             : /* 
     943             :    JH (01/01/2006) ROSETTA generated class declarations for SgClassDecl_attrStorageClass 
     944             :    used for the ast file IO. Do not chance by hand! 
     945             : */
     946           0 : class SgClassDecl_attrStorageClass  : public SgBitAttributeStorageClass
     947             :    {
     948             : 
     949             :     protected: 
     950             : 
     951             : 
     952             : /* #line 953 "../../../src/frontend/SageIII//StorageClasses.h" */
     953             : 
     954             : 
     955             : 
     956             : /* #line 10 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarStorageClassDeclatationMacros.macro" */
     957             : 
     958             : 
     959             :     public:
     960             :       void pickOutIRNodeData ( SgClassDecl_attr* source );
     961             :       static void arrangeStaticDataOfEasyStorageClassesInOneBlock ( );
     962             :       static void deleteStaticDataOfEasyStorageClasses ( );
     963             :       static void pickOutStaticDataMembers ( );
     964             :       static void rebuildStaticDataMembers ( );
     965             :       static void writeEasyStorageDataToFile (std::ostream& out);
     966             :       static void readEasyStorageDataFromFile (std::istream& in);
     967             :       static void writeStaticDataToFile (std::ostream& out );
     968             :       static void readStaticDataFromFile (std::istream& in );
     969             :       friend class SgClassDecl_attr;
     970             :    };
     971             : /* #line 972 "../../../src/frontend/SageIII//StorageClasses.h" */
     972             : 
     973             : 
     974             : 
     975             : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarStorageClassDeclatationMacros.macro" */
     976             : /* 
     977             :    JH (01/01/2006) ROSETTA generated class declarations for Sg_File_InfoStorageClass 
     978             :    used for the ast file IO. Do not chance by hand! 
     979             : */
     980     1295990 : class Sg_File_InfoStorageClass  : public SgSupportStorageClass
     981             :    {
     982             : 
     983             :     protected: 
     984             : 
     985             : 
     986             : /* #line 987 "../../../src/frontend/SageIII//StorageClasses.h" */
     987             : 
     988             :       int storageOf_file_id;
     989             :       int storageOf_line;
     990             :       int storageOf_col;
     991             :       unsigned int storageOf_classificationBitField;
     992             :       int storageOf_physical_file_id;
     993             :       int storageOf_physical_line;
     994             :       unsigned int storageOf_source_sequence_number;
     995             :        EasyStorage < SgFileIdList > storageOf_fileIDsToUnparse;
     996             :        EasyStorage < SgFileLineNumberList > storageOf_fileLineNumbersToUnparse;
     997             : 
     998             : 
     999             : /* #line 10 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarStorageClassDeclatationMacros.macro" */
    1000             : 
    1001             : 
    1002             :     public:
    1003             :       void pickOutIRNodeData ( Sg_File_Info* source );
    1004             :       static void arrangeStaticDataOfEasyStorageClassesInOneBlock ( );
    1005             :       static void deleteStaticDataOfEasyStorageClasses ( );
    1006             :       static void pickOutStaticDataMembers ( );
    1007             :       static void rebuildStaticDataMembers ( );
    1008             :       static void writeEasyStorageDataToFile (std::ostream& out);
    1009             :       static void readEasyStorageDataFromFile (std::istream& in);
    1010             :       static void writeStaticDataToFile (std::ostream& out );
    1011             :       static void readStaticDataFromFile (std::istream& in );
    1012             :       friend class Sg_File_Info;
    1013             :    };
    1014             : /* #line 1015 "../../../src/frontend/SageIII//StorageClasses.h" */
    1015             : 
    1016             : 
    1017             : 
    1018             : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarStorageClassDeclatationMacros.macro" */
    1019             : /* 
    1020             :    JH (01/01/2006) ROSETTA generated class declarations for SgFileStorageClass 
    1021             :    used for the ast file IO. Do not chance by hand! 
    1022             : */
    1023           0 : class SgFileStorageClass  : public SgSupportStorageClass
    1024             :    {
    1025             : 
    1026             :     protected: 
    1027             : 
    1028             : 
    1029             : /* #line 1030 "../../../src/frontend/SageIII//StorageClasses.h" */
    1030             : 
    1031             :      unsigned long storageOf_startOfConstruct;
    1032             :        EasyStorage < SgStringList > storageOf_originalCommandLineArgumentList;
    1033             :       int storageOf_verbose;
    1034             :       bool storageOf_output_warnings;
    1035             :       bool storageOf_C_only;
    1036             :       bool storageOf_Cxx_only;
    1037             :       bool storageOf_Fortran_only;
    1038             :       bool storageOf_CoArrayFortran_only;
    1039             :       int storageOf_upc_threads;
    1040             :       bool storageOf_Cuda_only;
    1041             :       bool storageOf_OpenCL_only;
    1042             :       bool storageOf_requires_C_preprocessor;
    1043             :       SgFile::outputFormatOption_enum storageOf_inputFormat;
    1044             :       SgFile::outputFormatOption_enum storageOf_outputFormat;
    1045             :       SgFile::outputFormatOption_enum storageOf_backendCompileFormat;
    1046             :       bool storageOf_fortran_implicit_none;
    1047             :       bool storageOf_openmp;
    1048             :       bool storageOf_openmp_parse_only;
    1049             :       bool storageOf_openmp_ast_only;
    1050             :       bool storageOf_openmp_lowering;
    1051             :       bool storageOf_openmp_analyzing;
    1052             :       bool storageOf_cray_pointer_support;
    1053             :       bool storageOf_failsafe;
    1054             :       bool storageOf_output_parser_actions;
    1055             :       bool storageOf_exit_after_parser;
    1056             :       bool storageOf_skip_syntax_check;
    1057             :       bool storageOf_skip_parser;
    1058             :       bool storageOf_relax_syntax_check;
    1059             :       bool storageOf_skip_translation_from_edg_ast_to_rose_ast;
    1060             :       bool storageOf_skip_transformation;
    1061             :       bool storageOf_skip_unparse;
    1062             :       bool storageOf_skipfinalCompileStep;
    1063             :       bool storageOf_unparse_includes;
    1064             :       bool storageOf_unparse_line_directives;
    1065             :       bool storageOf_unparse_function_calls_using_operator_syntax;
    1066             :       bool storageOf_unparse_function_calls_using_operator_names;
    1067             :       bool storageOf_unparse_instruction_addresses;
    1068             :       bool storageOf_unparse_raw_memory_contents;
    1069             :       bool storageOf_unparse_binary_file_format;
    1070             :       SgFile::languageOption_enum storageOf_outputLanguage;
    1071             :       SgFile::languageOption_enum storageOf_inputLanguage;
    1072             :        EasyStorage < std::string > storageOf_sourceFileNameWithPath;
    1073             :        EasyStorage < std::string > storageOf_sourceFileNameWithoutPath;
    1074             :        EasyStorage < std::string > storageOf_unparse_output_filename;
    1075             :        EasyStorage < std::string > storageOf_objectFileNameWithPath;
    1076             :        EasyStorage < std::string > storageOf_objectFileNameWithoutPath;
    1077             :       bool storageOf_useBackendOnly;
    1078             :       bool storageOf_compileOnly;
    1079             :        EasyStorage < std::string > storageOf_savedFrontendCommandLine;
    1080             :       bool storageOf_no_implicit_templates;
    1081             :       bool storageOf_no_implicit_inline_templates;
    1082             :       bool storageOf_skip_commentsAndDirectives;
    1083             :       bool storageOf_collectAllCommentsAndDirectives;
    1084             :       bool storageOf_translateCommentsAndDirectivesIntoAST;
    1085             :       bool storageOf_unparseHeaderFiles;
    1086             :        EasyStorage < ROSEAttributesListContainerPtr > storageOf_preprocessorDirectivesAndCommentsList;
    1087             :        EasyStorage < AstAttributeMechanism* > storageOf_attributeMechanism;
    1088             :       bool storageOf_KCC_frontend;
    1089             :       bool storageOf_new_frontend;
    1090             :       bool storageOf_disable_edg_backend;
    1091             :       bool storageOf_disable_sage_backend;
    1092             :       int storageOf_testingLevel;
    1093             :       bool storageOf_preinit_il;
    1094             :       bool storageOf_enable_cp_backend;
    1095             :       bool storageOf_markGeneratedFiles;
    1096             :       bool storageOf_negative_test;
    1097             :       bool storageOf_strict_language_handling;
    1098             :       bool storageOf_wave;
    1099             :       int storageOf_embedColorCodesInGeneratedCode;
    1100             :       int storageOf_generateSourcePositionCodes;
    1101             :       bool storageOf_sourceFileUsesCppFileExtension;
    1102             :       bool storageOf_sourceFileUsesFortranFileExtension;
    1103             :       bool storageOf_sourceFileUsesFortran77FileExtension;
    1104             :       bool storageOf_sourceFileUsesFortran90FileExtension;
    1105             :       bool storageOf_sourceFileUsesFortran95FileExtension;
    1106             :       bool storageOf_sourceFileUsesFortran2003FileExtension;
    1107             :       bool storageOf_sourceFileUsesFortran2008FileExtension;
    1108             :       bool storageOf_sourceFileUsesCoArrayFortranFileExtension;
    1109             :       bool storageOf_sourceFileUsesPHPFileExtension;
    1110             :       bool storageOf_sourceFileUsesPythonFileExtension;
    1111             :       bool storageOf_sourceFileTypeIsUnknown;
    1112             :       int storageOf_detect_dangling_pointers;
    1113             :       bool storageOf_experimental_fortran_frontend;
    1114             :       bool storageOf_experimental_flang_frontend;
    1115             :       bool storageOf_experimental_cuda_fortran_frontend;
    1116             :       bool storageOf_experimental_fortran_frontend_OFP_test;
    1117             :       bool storageOf_read_executable_file_format_only;
    1118             :       bool storageOf_visualize_executable_file_format_skip_symbols;
    1119             :       bool storageOf_visualize_dwarf_only;
    1120             :       bool storageOf_read_instructions_only;
    1121             :        EasyStorage < SgStringList > storageOf_libraryArchiveObjectFileNameList;
    1122             :       bool storageOf_isLibraryArchive;
    1123             :       bool storageOf_isObjectFile;
    1124             :       bool storageOf_unparse_tokens;
    1125             :       int storageOf_unparse_tokens_testing;
    1126             :       bool storageOf_unparse_using_leading_and_trailing_token_mappings;
    1127             :       bool storageOf_unparse_template_ast;
    1128             :       bool storageOf_skipAstConsistancyTests;
    1129             :       bool storageOf_multifile_support;
    1130             :       bool storageOf_optimization;
    1131             :       bool storageOf_use_token_stream_to_improve_source_position_info;
    1132             :       bool storageOf_suppress_variable_declaration_normalization;
    1133             :       bool storageOf_edg_il_to_graphviz;
    1134             :       bool storageOf_clang_il_to_graphviz;
    1135             :       bool storageOf_no_optimize_flag_for_frontend;
    1136             :       bool storageOf_unparse_edg_normalized_method_ROSE_1392;
    1137             :       bool storageOf_header_file_unparsing_optimization_source_file;
    1138             :       bool storageOf_header_file_unparsing_optimization_header_file;
    1139             :       SgFile::standard_enum storageOf_standard;
    1140             :       bool storageOf_gnu_standard;
    1141             :       int storageOf_frontendErrorCode;
    1142             :       int storageOf_javacErrorCode;
    1143             :       int storageOf_ecjErrorCode;
    1144             :       int storageOf_midendErrorCode;
    1145             :       int storageOf_unparserErrorCode;
    1146             :       int storageOf_backendCompilerErrorCode;
    1147             :       bool storageOf_unparsedFileFailedCompilation;
    1148             : 
    1149             : 
    1150             : /* #line 10 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarStorageClassDeclatationMacros.macro" */
    1151             : 
    1152             : 
    1153             :     public:
    1154             :       void pickOutIRNodeData ( SgFile* source );
    1155             :       static void arrangeStaticDataOfEasyStorageClassesInOneBlock ( );
    1156             :       static void deleteStaticDataOfEasyStorageClasses ( );
    1157             :       static void pickOutStaticDataMembers ( );
    1158             :       static void rebuildStaticDataMembers ( );
    1159             :       static void writeEasyStorageDataToFile (std::ostream& out);
    1160             :       static void readEasyStorageDataFromFile (std::istream& in);
    1161             :       static void writeStaticDataToFile (std::ostream& out );
    1162             :       static void readStaticDataFromFile (std::istream& in );
    1163             :       friend class SgFile;
    1164             :    };
    1165             : /* #line 1166 "../../../src/frontend/SageIII//StorageClasses.h" */
    1166             : 
    1167             : 
    1168             : 
    1169             : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarStorageClassDeclatationMacros.macro" */
    1170             : /* 
    1171             :    JH (01/01/2006) ROSETTA generated class declarations for SgSourceFileStorageClass 
    1172             :    used for the ast file IO. Do not chance by hand! 
    1173             : */
    1174         395 : class SgSourceFileStorageClass  : public SgFileStorageClass
    1175             :    {
    1176             : 
    1177             :     protected: 
    1178             : 
    1179             : 
    1180             : /* #line 1181 "../../../src/frontend/SageIII//StorageClasses.h" */
    1181             : 
    1182             :      unsigned long storageOf_globalScope;
    1183             :        EasyStorage < SgModuleStatementPtrList > storageOf_module_list;
    1184             :        EasyStorage < SgTokenPtrList > storageOf_token_list;
    1185             :      unsigned long storageOf_temp_holding_scope;
    1186             :       bool storageOf_isHeaderFile;
    1187             :       bool storageOf_isHeaderFileIncludedMoreThanOnce;
    1188             :      unsigned long storageOf_headerFileReport;
    1189             :        EasyStorage < SgStringList > storageOf_extraIncludeDirectorySpecifierBeforeList;
    1190             :        EasyStorage < SgStringList > storageOf_extraIncludeDirectorySpecifierAfterList;
    1191             :      unsigned long storageOf_associated_include_file;
    1192             :       bool storageOf_processedToIncludeCppDirectivesAndComments;
    1193             :        EasyStorage < SgNodePtrList > storageOf_extra_nodes_for_namequal_init;
    1194             :       bool storageOf_isDynamicLibrary;
    1195             : 
    1196             : 
    1197             : /* #line 10 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarStorageClassDeclatationMacros.macro" */
    1198             : 
    1199             : 
    1200             :     public:
    1201             :       void pickOutIRNodeData ( SgSourceFile* source );
    1202             :       static void arrangeStaticDataOfEasyStorageClassesInOneBlock ( );
    1203             :       static void deleteStaticDataOfEasyStorageClasses ( );
    1204             :       static void pickOutStaticDataMembers ( );
    1205             :       static void rebuildStaticDataMembers ( );
    1206             :       static void writeEasyStorageDataToFile (std::ostream& out);
    1207             :       static void readEasyStorageDataFromFile (std::istream& in);
    1208             :       static void writeStaticDataToFile (std::ostream& out );
    1209             :       static void readStaticDataFromFile (std::istream& in );
    1210             :       friend class SgSourceFile;
    1211             :    };
    1212             : /* #line 1213 "../../../src/frontend/SageIII//StorageClasses.h" */
    1213             : 
    1214             : 
    1215             : 
    1216             : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarStorageClassDeclatationMacros.macro" */
    1217             : /* 
    1218             :    JH (01/01/2006) ROSETTA generated class declarations for SgUnknownFileStorageClass 
    1219             :    used for the ast file IO. Do not chance by hand! 
    1220             : */
    1221           0 : class SgUnknownFileStorageClass  : public SgFileStorageClass
    1222             :    {
    1223             : 
    1224             :     protected: 
    1225             : 
    1226             : 
    1227             : /* #line 1228 "../../../src/frontend/SageIII//StorageClasses.h" */
    1228             : 
    1229             :      unsigned long storageOf_globalScope;
    1230             : 
    1231             : 
    1232             : /* #line 10 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarStorageClassDeclatationMacros.macro" */
    1233             : 
    1234             : 
    1235             :     public:
    1236             :       void pickOutIRNodeData ( SgUnknownFile* source );
    1237             :       static void arrangeStaticDataOfEasyStorageClassesInOneBlock ( );
    1238             :       static void deleteStaticDataOfEasyStorageClasses ( );
    1239             :       static void pickOutStaticDataMembers ( );
    1240             :       static void rebuildStaticDataMembers ( );
    1241             :       static void writeEasyStorageDataToFile (std::ostream& out);
    1242             :       static void readEasyStorageDataFromFile (std::istream& in);
    1243             :       static void writeStaticDataToFile (std::ostream& out );
    1244             :       static void readStaticDataFromFile (std::istream& in );
    1245             :       friend class SgUnknownFile;
    1246             :    };
    1247             : /* #line 1248 "../../../src/frontend/SageIII//StorageClasses.h" */
    1248             : 
    1249             : 
    1250             : 
    1251             : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarStorageClassDeclatationMacros.macro" */
    1252             : /* 
    1253             :    JH (01/01/2006) ROSETTA generated class declarations for SgProjectStorageClass 
    1254             :    used for the ast file IO. Do not chance by hand! 
    1255             : */
    1256             : class SgProjectStorageClass  : public SgSupportStorageClass
    1257             :    {
    1258             : 
    1259             :     protected: 
    1260             : 
    1261             : 
    1262             : /* #line 1263 "../../../src/frontend/SageIII//StorageClasses.h" */
    1263             : 
    1264             :      unsigned long storageOf_fileList_ptr;
    1265             :        EasyStorage < SgStringList > storageOf_originalCommandLineArgumentList;
    1266             :       int storageOf_frontendErrorCode;
    1267             :       int storageOf_javacErrorCode;
    1268             :       int storageOf_ecjErrorCode;
    1269             :       int storageOf_midendErrorCode;
    1270             :       int storageOf_backendErrorCode;
    1271             :       bool storageOf_keep_going;
    1272             :       bool storageOf_unparser__clobber_input_file;
    1273             :        EasyStorage < std::string > storageOf_outputFileName;
    1274             :        EasyStorage < SgStringList > storageOf_sourceFileNameList;
    1275             :        EasyStorage < SgStringList > storageOf_objectFileNameList;
    1276             :        EasyStorage < SgStringList > storageOf_libraryFileList;
    1277             :        EasyStorage < SgStringList > storageOf_librarySpecifierList;
    1278             :        EasyStorage < SgStringList > storageOf_libraryDirectorySpecifierList;
    1279             :        EasyStorage < SgStringList > storageOf_includeDirectorySpecifierList;
    1280             :        EasyStorage < SgStringList > storageOf_macroSpecifierList;
    1281             :        EasyStorage < SgStringList > storageOf_preincludeFileList;
    1282             :        EasyStorage < SgStringList > storageOf_preincludeDirectoryList;
    1283             :       bool storageOf_compileOnly;
    1284             :       bool storageOf_wave;
    1285             :       bool storageOf_prelink;
    1286             :       SgProject::template_instantiation_enum storageOf_template_instantiation_mode;
    1287             :       bool storageOf_ast_merge;
    1288             :        EasyStorage < std::string > storageOf_projectSpecificDatabaseFile;
    1289             :       bool storageOf_C_PreprocessorOnly;
    1290             :        EasyStorage < AstAttributeMechanism* > storageOf_attributeMechanism;
    1291             :        EasyStorage < std::string > storageOf_compilationPerformanceFile;
    1292             :        EasyStorage < SgStringList > storageOf_includePathList;
    1293             :        EasyStorage < SgStringList > storageOf_excludePathList;
    1294             :        EasyStorage < SgStringList > storageOf_includeFileList;
    1295             :        EasyStorage < SgStringList > storageOf_excludeFileList;
    1296             :       bool storageOf_binary_only;
    1297             :      unsigned long storageOf_directoryList;
    1298             :       bool storageOf_C_only;
    1299             :       bool storageOf_Cxx_only;
    1300             :       bool storageOf_C11_only;
    1301             :       bool storageOf_Cxx0x_only;
    1302             :       bool storageOf_Cxx11_only;
    1303             :       bool storageOf_C14_only;
    1304             :       bool storageOf_Cxx14_only;
    1305             :       bool storageOf_Fortran_only;
    1306             :        EasyStorage < std::list<std::string> > storageOf_Fortran_ofp_jvm_options;
    1307             :       bool storageOf_openmp_linking;
    1308             :        EasyStorage < std::list<std::string> > storageOf_Java_ecj_jvm_options;
    1309             :       bool storageOf_Java_batch_mode;
    1310             :        EasyStorage < std::list<std::string> > storageOf_Java_classpath;
    1311             :        EasyStorage < std::list<std::string> > storageOf_Java_sourcepath;
    1312             :        EasyStorage < std::string > storageOf_Java_destdir;
    1313             :        EasyStorage < std::string > storageOf_Java_source_destdir;
    1314             :       bool storageOf_addCppDirectivesToAST;
    1315             :        EasyStorage < std::map<std::string, std::set<PreprocessingInfo*> > > storageOf_includingPreprocessingInfosMap;
    1316             :        EasyStorage < std::list<std::string> > storageOf_quotedIncludesSearchPaths;
    1317             :        EasyStorage < std::list<std::string> > storageOf_bracketedIncludesSearchPaths;
    1318             :        EasyStorage < std::string > storageOf_unparseHeaderFilesRootFolder;
    1319             :       bool storageOf_frontendConstantFolding;
    1320             :      unsigned long storageOf_globalScopeAcrossFiles;
    1321             :       bool storageOf_unparse_in_same_directory_as_input_file;
    1322             :       bool storageOf_stop_after_compilation_do_not_assemble_file;
    1323             :        EasyStorage < std::string > storageOf_gnuOptionForUndefinedSymbol;
    1324             :       bool storageOf_mode_32_bit;
    1325             :       bool storageOf_noclobber_output_file;
    1326             :       bool storageOf_noclobber_if_different_output_file;
    1327             :       bool storageOf_suppressConstantFoldingPostProcessing;
    1328             :       bool storageOf_appendPID;
    1329             :       bool storageOf_reportOnHeaderFileUnparsing;
    1330             :        EasyStorage < std::string > storageOf_applicationRootDirectory;
    1331             :       bool storageOf_usingApplicationRootDirectory;
    1332             :       bool storageOf_usingDeferredTransformations;
    1333             :        EasyStorage < std::string > storageOf_astfile_out;
    1334             :        EasyStorage < std::list<std::string> > storageOf_astfiles_in;
    1335             :        EasyStorage < SgStringList > storageOf_extraIncludeDirectorySpecifierBeforeList;
    1336             :        EasyStorage < SgStringList > storageOf_extraIncludeDirectorySpecifierAfterList;
    1337             : 
    1338             : 
    1339             : /* #line 10 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarStorageClassDeclatationMacros.macro" */
    1340             : 
    1341             : 
    1342             :     public:
    1343             :       void pickOutIRNodeData ( SgProject* source );
    1344             :       static void arrangeStaticDataOfEasyStorageClassesInOneBlock ( );
    1345             :       static void deleteStaticDataOfEasyStorageClasses ( );
    1346             :       static void pickOutStaticDataMembers ( );
    1347             :       static void rebuildStaticDataMembers ( );
    1348             :       static void writeEasyStorageDataToFile (std::ostream& out);
    1349             :       static void readEasyStorageDataFromFile (std::istream& in);
    1350             :       static void writeStaticDataToFile (std::ostream& out );
    1351             :       static void readStaticDataFromFile (std::istream& in );
    1352             :       friend class SgProject;
    1353             :    };
    1354             : /* #line 1355 "../../../src/frontend/SageIII//StorageClasses.h" */
    1355             : 
    1356             : 
    1357             : 
    1358             : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarStorageClassDeclatationMacros.macro" */
    1359             : /* 
    1360             :    JH (01/01/2006) ROSETTA generated class declarations for SgOptionsStorageClass 
    1361             :    used for the ast file IO. Do not chance by hand! 
    1362             : */
    1363             : class SgOptionsStorageClass  : public SgSupportStorageClass
    1364             :    {
    1365             : 
    1366             :     protected: 
    1367             : 
    1368             : 
    1369             : /* #line 1370 "../../../src/frontend/SageIII//StorageClasses.h" */
    1370             : 
    1371             :       int storageOf_debug_level;
    1372             :       int storageOf_logging_level;
    1373             : 
    1374             : 
    1375             : /* #line 10 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarStorageClassDeclatationMacros.macro" */
    1376             : 
    1377             : 
    1378             :     public:
    1379             :       void pickOutIRNodeData ( SgOptions* source );
    1380             :       static void arrangeStaticDataOfEasyStorageClassesInOneBlock ( );
    1381             :       static void deleteStaticDataOfEasyStorageClasses ( );
    1382             :       static void pickOutStaticDataMembers ( );
    1383             :       static void rebuildStaticDataMembers ( );
    1384             :       static void writeEasyStorageDataToFile (std::ostream& out);
    1385             :       static void readEasyStorageDataFromFile (std::istream& in);
    1386             :       static void writeStaticDataToFile (std::ostream& out );
    1387             :       static void readStaticDataFromFile (std::istream& in );
    1388             :       friend class SgOptions;
    1389             :    };
    1390             : /* #line 1391 "../../../src/frontend/SageIII//StorageClasses.h" */
    1391             : 
    1392             : 
    1393             : 
    1394             : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarStorageClassDeclatationMacros.macro" */
    1395             : /* 
    1396             :    JH (01/01/2006) ROSETTA generated class declarations for SgUnparse_InfoStorageClass 
    1397             :    used for the ast file IO. Do not chance by hand! 
    1398             : */
    1399           0 : class SgUnparse_InfoStorageClass  : public SgSupportStorageClass
    1400             :    {
    1401             : 
    1402             :     protected: 
    1403             : 
    1404             : 
    1405             : /* #line 1406 "../../../src/frontend/SageIII//StorageClasses.h" */
    1406             : 
    1407             :        EasyStorage < SgBitVector > storageOf_unparse_attribute;
    1408             :       int storageOf_access_attribute;
    1409             :       int storageOf_nested_expression;
    1410             :        EasyStorage < std::string > storageOf_operator_name;
    1411             :       SgNameStorageClass storageOf_var_name;
    1412             :      unsigned long storageOf_declstatement_ptr;
    1413             :      unsigned long storageOf_declaration_of_context;
    1414             :      unsigned long storageOf_current_context;
    1415             :       SgNameStorageClass storageOf_array_index_list;
    1416             :      unsigned long storageOf_current_namespace;
    1417             :       bool storageOf_outputCodeGenerationFormatDelimiters;
    1418             :        EasyStorage < SgQualifiedNamePtrList > storageOf_qualifiedNameList;
    1419             :      unsigned long storageOf_current_function_call;
    1420             :      unsigned long storageOf_current_scope;
    1421             :      unsigned long storageOf_reference_node_for_qualification;
    1422             :       int storageOf_name_qualification_length;
    1423             :       bool storageOf_type_elaboration_required;
    1424             :       bool storageOf_global_qualification_required;
    1425             :       int storageOf_nestingLevel;
    1426             :       SgFile::languageOption_enum storageOf_language;
    1427             :      unsigned long storageOf_current_source_file;
    1428             :       bool storageOf_use_generated_name_for_template_arguments;
    1429             :       bool storageOf_user_defined_literal;
    1430             :      unsigned long storageOf_declstatement_associated_with_type;
    1431             :       bool storageOf_context_for_added_parentheses;
    1432             : 
    1433             : 
    1434             : /* #line 10 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarStorageClassDeclatationMacros.macro" */
    1435             : 
    1436             : 
    1437             :     public:
    1438             :       void pickOutIRNodeData ( SgUnparse_Info* source );
    1439             :       static void arrangeStaticDataOfEasyStorageClassesInOneBlock ( );
    1440             :       static void deleteStaticDataOfEasyStorageClasses ( );
    1441             :       static void pickOutStaticDataMembers ( );
    1442             :       static void rebuildStaticDataMembers ( );
    1443             :       static void writeEasyStorageDataToFile (std::ostream& out);
    1444             :       static void readEasyStorageDataFromFile (std::istream& in);
    1445             :       static void writeStaticDataToFile (std::ostream& out );
    1446             :       static void readStaticDataFromFile (std::istream& in );
    1447             :       friend class SgUnparse_Info;
    1448             :    };
    1449             : /* #line 1450 "../../../src/frontend/SageIII//StorageClasses.h" */
    1450             : 
    1451             : 
    1452             : 
    1453             : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarStorageClassDeclatationMacros.macro" */
    1454             : /* 
    1455             :    JH (01/01/2006) ROSETTA generated class declarations for SgBaseClassStorageClass 
    1456             :    used for the ast file IO. Do not chance by hand! 
    1457             : */
    1458             : class SgBaseClassStorageClass  : public SgSupportStorageClass
    1459             :    {
    1460             : 
    1461             :     protected: 
    1462             : 
    1463             : 
    1464             : /* #line 1465 "../../../src/frontend/SageIII//StorageClasses.h" */
    1465             : 
    1466             :      unsigned long storageOf_base_class;
    1467             :       bool storageOf_isDirectBaseClass;
    1468             :      unsigned long storageOf_baseClassModifier;
    1469             :       int storageOf_name_qualification_length;
    1470             :       bool storageOf_type_elaboration_required;
    1471             :       bool storageOf_global_qualification_required;
    1472             : 
    1473             : 
    1474             : /* #line 10 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarStorageClassDeclatationMacros.macro" */
    1475             : 
    1476             : 
    1477             :     public:
    1478             :       void pickOutIRNodeData ( SgBaseClass* source );
    1479             :       static void arrangeStaticDataOfEasyStorageClassesInOneBlock ( );
    1480             :       static void deleteStaticDataOfEasyStorageClasses ( );
    1481             :       static void pickOutStaticDataMembers ( );
    1482             :       static void rebuildStaticDataMembers ( );
    1483             :       static void writeEasyStorageDataToFile (std::ostream& out);
    1484             :       static void readEasyStorageDataFromFile (std::istream& in);
    1485             :       static void writeStaticDataToFile (std::ostream& out );
    1486             :       static void readStaticDataFromFile (std::istream& in );
    1487             :       friend class SgBaseClass;
    1488             :    };
    1489             : /* #line 1490 "../../../src/frontend/SageIII//StorageClasses.h" */
    1490             : 
    1491             : 
    1492             : 
    1493             : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarStorageClassDeclatationMacros.macro" */
    1494             : /* 
    1495             :    JH (01/01/2006) ROSETTA generated class declarations for SgExpBaseClassStorageClass 
    1496             :    used for the ast file IO. Do not chance by hand! 
    1497             : */
    1498             : class SgExpBaseClassStorageClass  : public SgBaseClassStorageClass
    1499             :    {
    1500             : 
    1501             :     protected: 
    1502             : 
    1503             : 
    1504             : /* #line 1505 "../../../src/frontend/SageIII//StorageClasses.h" */
    1505             : 
    1506             :      unsigned long storageOf_base_class_exp;
    1507             : 
    1508             : 
    1509             : /* #line 10 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarStorageClassDeclatationMacros.macro" */
    1510             : 
    1511             : 
    1512             :     public:
    1513             :       void pickOutIRNodeData ( SgExpBaseClass* source );
    1514             :       static void arrangeStaticDataOfEasyStorageClassesInOneBlock ( );
    1515             :       static void deleteStaticDataOfEasyStorageClasses ( );
    1516             :       static void pickOutStaticDataMembers ( );
    1517             :       static void rebuildStaticDataMembers ( );
    1518             :       static void writeEasyStorageDataToFile (std::ostream& out);
    1519             :       static void readEasyStorageDataFromFile (std::istream& in);
    1520             :       static void writeStaticDataToFile (std::ostream& out );
    1521             :       static void readStaticDataFromFile (std::istream& in );
    1522             :       friend class SgExpBaseClass;
    1523             :    };
    1524             : /* #line 1525 "../../../src/frontend/SageIII//StorageClasses.h" */
    1525             : 
    1526             : 
    1527             : 
    1528             : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarStorageClassDeclatationMacros.macro" */
    1529             : /* 
    1530             :    JH (01/01/2006) ROSETTA generated class declarations for SgNonrealBaseClassStorageClass 
    1531             :    used for the ast file IO. Do not chance by hand! 
    1532             : */
    1533             : class SgNonrealBaseClassStorageClass  : public SgBaseClassStorageClass
    1534             :    {
    1535             : 
    1536             :     protected: 
    1537             : 
    1538             : 
    1539             : /* #line 1540 "../../../src/frontend/SageIII//StorageClasses.h" */
    1540             : 
    1541             :      unsigned long storageOf_base_class_nonreal;
    1542             : 
    1543             : 
    1544             : /* #line 10 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarStorageClassDeclatationMacros.macro" */
    1545             : 
    1546             : 
    1547             :     public:
    1548             :       void pickOutIRNodeData ( SgNonrealBaseClass* source );
    1549             :       static void arrangeStaticDataOfEasyStorageClassesInOneBlock ( );
    1550             :       static void deleteStaticDataOfEasyStorageClasses ( );
    1551             :       static void pickOutStaticDataMembers ( );
    1552             :       static void rebuildStaticDataMembers ( );
    1553             :       static void writeEasyStorageDataToFile (std::ostream& out);
    1554             :       static void readEasyStorageDataFromFile (std::istream& in);
    1555             :       static void writeStaticDataToFile (std::ostream& out );
    1556             :       static void readStaticDataFromFile (std::istream& in );
    1557             :       friend class SgNonrealBaseClass;
    1558             :    };
    1559             : /* #line 1560 "../../../src/frontend/SageIII//StorageClasses.h" */
    1560             : 
    1561             : 
    1562             : 
    1563             : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarStorageClassDeclatationMacros.macro" */
    1564             : /* 
    1565             :    JH (01/01/2006) ROSETTA generated class declarations for SgTypedefSeqStorageClass 
    1566             :    used for the ast file IO. Do not chance by hand! 
    1567             : */
    1568       32892 : class SgTypedefSeqStorageClass  : public SgSupportStorageClass
    1569             :    {
    1570             : 
    1571             :     protected: 
    1572             : 
    1573             : 
    1574             : /* #line 1575 "../../../src/frontend/SageIII//StorageClasses.h" */
    1575             : 
    1576             :        EasyStorage < SgTypePtrList > storageOf_typedefs;
    1577             : 
    1578             : 
    1579             : /* #line 10 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarStorageClassDeclatationMacros.macro" */
    1580             : 
    1581             : 
    1582             :     public:
    1583             :       void pickOutIRNodeData ( SgTypedefSeq* source );
    1584             :       static void arrangeStaticDataOfEasyStorageClassesInOneBlock ( );
    1585             :       static void deleteStaticDataOfEasyStorageClasses ( );
    1586             :       static void pickOutStaticDataMembers ( );
    1587             :       static void rebuildStaticDataMembers ( );
    1588             :       static void writeEasyStorageDataToFile (std::ostream& out);
    1589             :       static void readEasyStorageDataFromFile (std::istream& in);
    1590             :       static void writeStaticDataToFile (std::ostream& out );
    1591             :       static void readStaticDataFromFile (std::istream& in );
    1592             :       friend class SgTypedefSeq;
    1593             :    };
    1594             : /* #line 1595 "../../../src/frontend/SageIII//StorageClasses.h" */
    1595             : 
    1596             : 
    1597             : 
    1598             : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarStorageClassDeclatationMacros.macro" */
    1599             : /* 
    1600             :    JH (01/01/2006) ROSETTA generated class declarations for SgTemplateParameterStorageClass 
    1601             :    used for the ast file IO. Do not chance by hand! 
    1602             : */
    1603             : class SgTemplateParameterStorageClass  : public SgSupportStorageClass
    1604             :    {
    1605             : 
    1606             :     protected: 
    1607             : 
    1608             : 
    1609             : /* #line 1610 "../../../src/frontend/SageIII//StorageClasses.h" */
    1610             : 
    1611             :       SgTemplateParameter::template_parameter_enum storageOf_parameterType;
    1612             :      unsigned long storageOf_type;
    1613             :      unsigned long storageOf_defaultTypeParameter;
    1614             :      unsigned long storageOf_expression;
    1615             :      unsigned long storageOf_defaultExpressionParameter;
    1616             :      unsigned long storageOf_templateDeclaration;
    1617             :      unsigned long storageOf_defaultTemplateDeclarationParameter;
    1618             :      unsigned long storageOf_initializedName;
    1619             : 
    1620             : 
    1621             : /* #line 10 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarStorageClassDeclatationMacros.macro" */
    1622             : 
    1623             : 
    1624             :     public:
    1625             :       void pickOutIRNodeData ( SgTemplateParameter* source );
    1626             :       static void arrangeStaticDataOfEasyStorageClassesInOneBlock ( );
    1627             :       static void deleteStaticDataOfEasyStorageClasses ( );
    1628             :       static void pickOutStaticDataMembers ( );
    1629             :       static void rebuildStaticDataMembers ( );
    1630             :       static void writeEasyStorageDataToFile (std::ostream& out);
    1631             :       static void readEasyStorageDataFromFile (std::istream& in);
    1632             :       static void writeStaticDataToFile (std::ostream& out );
    1633             :       static void readStaticDataFromFile (std::istream& in );
    1634             :       friend class SgTemplateParameter;
    1635             :    };
    1636             : /* #line 1637 "../../../src/frontend/SageIII//StorageClasses.h" */
    1637             : 
    1638             : 
    1639             : 
    1640             : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarStorageClassDeclatationMacros.macro" */
    1641             : /* 
    1642             :    JH (01/01/2006) ROSETTA generated class declarations for SgTemplateArgumentStorageClass 
    1643             :    used for the ast file IO. Do not chance by hand! 
    1644             : */
    1645             : class SgTemplateArgumentStorageClass  : public SgSupportStorageClass
    1646             :    {
    1647             : 
    1648             :     protected: 
    1649             : 
    1650             : 
    1651             : /* #line 1652 "../../../src/frontend/SageIII//StorageClasses.h" */
    1652             : 
    1653             :       SgTemplateArgument::template_argument_enum storageOf_argumentType;
    1654             :       bool storageOf_isArrayBoundUnknownType;
    1655             :      unsigned long storageOf_type;
    1656             :      unsigned long storageOf_unparsable_type_alias;
    1657             :      unsigned long storageOf_expression;
    1658             :      unsigned long storageOf_templateDeclaration;
    1659             :      unsigned long storageOf_initializedName;
    1660             :       bool storageOf_explicitlySpecified;
    1661             :       int storageOf_name_qualification_length;
    1662             :       bool storageOf_type_elaboration_required;
    1663             :       bool storageOf_global_qualification_required;
    1664             :       bool storageOf_requiresGlobalNameQualificationOnType;
    1665             :       int storageOf_name_qualification_length_for_type;
    1666             :       bool storageOf_type_elaboration_required_for_type;
    1667             :       bool storageOf_global_qualification_required_for_type;
    1668             :      unsigned long storageOf_previous_instance;
    1669             :      unsigned long storageOf_next_instance;
    1670             :       bool storageOf_is_pack_element;
    1671             : 
    1672             : 
    1673             : /* #line 10 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarStorageClassDeclatationMacros.macro" */
    1674             : 
    1675             : 
    1676             :     public:
    1677             :       void pickOutIRNodeData ( SgTemplateArgument* source );
    1678             :       static void arrangeStaticDataOfEasyStorageClassesInOneBlock ( );
    1679             :       static void deleteStaticDataOfEasyStorageClasses ( );
    1680             :       static void pickOutStaticDataMembers ( );
    1681             :       static void rebuildStaticDataMembers ( );
    1682             :       static void writeEasyStorageDataToFile (std::ostream& out);
    1683             :       static void readEasyStorageDataFromFile (std::istream& in);
    1684             :       static void writeStaticDataToFile (std::ostream& out );
    1685             :       static void readStaticDataFromFile (std::istream& in );
    1686             :       friend class SgTemplateArgument;
    1687             :    };
    1688             : /* #line 1689 "../../../src/frontend/SageIII//StorageClasses.h" */
    1689             : 
    1690             : 
    1691             : 
    1692             : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarStorageClassDeclatationMacros.macro" */
    1693             : /* 
    1694             :    JH (01/01/2006) ROSETTA generated class declarations for SgDirectoryStorageClass 
    1695             :    used for the ast file IO. Do not chance by hand! 
    1696             : */
    1697           0 : class SgDirectoryStorageClass  : public SgSupportStorageClass
    1698             :    {
    1699             : 
    1700             :     protected: 
    1701             : 
    1702             : 
    1703             : /* #line 1704 "../../../src/frontend/SageIII//StorageClasses.h" */
    1704             : 
    1705             :        EasyStorage < std::string > storageOf_name;
    1706             :      unsigned long storageOf_fileList;
    1707             :      unsigned long storageOf_directoryList;
    1708             :        EasyStorage < AstAttributeMechanism* > storageOf_attributeMechanism;
    1709             : 
    1710             : 
    1711             : /* #line 10 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarStorageClassDeclatationMacros.macro" */
    1712             : 
    1713             : 
    1714             :     public:
    1715             :       void pickOutIRNodeData ( SgDirectory* source );
    1716             :       static void arrangeStaticDataOfEasyStorageClassesInOneBlock ( );
    1717             :       static void deleteStaticDataOfEasyStorageClasses ( );
    1718             :       static void pickOutStaticDataMembers ( );
    1719             :       static void rebuildStaticDataMembers ( );
    1720             :       static void writeEasyStorageDataToFile (std::ostream& out);
    1721             :       static void readEasyStorageDataFromFile (std::istream& in);
    1722             :       static void writeStaticDataToFile (std::ostream& out );
    1723             :       static void readStaticDataFromFile (std::istream& in );
    1724             :       friend class SgDirectory;
    1725             :    };
    1726             : /* #line 1727 "../../../src/frontend/SageIII//StorageClasses.h" */
    1727             : 
    1728             : 
    1729             : 
    1730             : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarStorageClassDeclatationMacros.macro" */
    1731             : /* 
    1732             :    JH (01/01/2006) ROSETTA generated class declarations for SgFileListStorageClass 
    1733             :    used for the ast file IO. Do not chance by hand! 
    1734             : */
    1735           5 : class SgFileListStorageClass  : public SgSupportStorageClass
    1736             :    {
    1737             : 
    1738             :     protected: 
    1739             : 
    1740             : 
    1741             : /* #line 1742 "../../../src/frontend/SageIII//StorageClasses.h" */
    1742             : 
    1743             :        EasyStorage < SgFilePtrList > storageOf_listOfFiles;
    1744             :        EasyStorage < AstAttributeMechanism* > storageOf_attributeMechanism;
    1745             : 
    1746             : 
    1747             : /* #line 10 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarStorageClassDeclatationMacros.macro" */
    1748             : 
    1749             : 
    1750             :     public:
    1751             :       void pickOutIRNodeData ( SgFileList* source );
    1752             :       static void arrangeStaticDataOfEasyStorageClassesInOneBlock ( );
    1753             :       static void deleteStaticDataOfEasyStorageClasses ( );
    1754             :       static void pickOutStaticDataMembers ( );
    1755             :       static void rebuildStaticDataMembers ( );
    1756             :       static void writeEasyStorageDataToFile (std::ostream& out);
    1757             :       static void readEasyStorageDataFromFile (std::istream& in);
    1758             :       static void writeStaticDataToFile (std::ostream& out );
    1759             :       static void readStaticDataFromFile (std::istream& in );
    1760             :       friend class SgFileList;
    1761             :    };
    1762             : /* #line 1763 "../../../src/frontend/SageIII//StorageClasses.h" */
    1763             : 
    1764             : 
    1765             : 
    1766             : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarStorageClassDeclatationMacros.macro" */
    1767             : /* 
    1768             :    JH (01/01/2006) ROSETTA generated class declarations for SgDirectoryListStorageClass 
    1769             :    used for the ast file IO. Do not chance by hand! 
    1770             : */
    1771           5 : class SgDirectoryListStorageClass  : public SgSupportStorageClass
    1772             :    {
    1773             : 
    1774             :     protected: 
    1775             : 
    1776             : 
    1777             : /* #line 1778 "../../../src/frontend/SageIII//StorageClasses.h" */
    1778             : 
    1779             :        EasyStorage < SgDirectoryPtrList > storageOf_listOfDirectories;
    1780             : 
    1781             : 
    1782             : /* #line 10 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarStorageClassDeclatationMacros.macro" */
    1783             : 
    1784             : 
    1785             :     public:
    1786             :       void pickOutIRNodeData ( SgDirectoryList* source );
    1787             :       static void arrangeStaticDataOfEasyStorageClassesInOneBlock ( );
    1788             :       static void deleteStaticDataOfEasyStorageClasses ( );
    1789             :       static void pickOutStaticDataMembers ( );
    1790             :       static void rebuildStaticDataMembers ( );
    1791             :       static void writeEasyStorageDataToFile (std::ostream& out);
    1792             :       static void readEasyStorageDataFromFile (std::istream& in);
    1793             :       static void writeStaticDataToFile (std::ostream& out );
    1794             :       static void readStaticDataFromFile (std::istream& in );
    1795             :       friend class SgDirectoryList;
    1796             :    };
    1797             : /* #line 1798 "../../../src/frontend/SageIII//StorageClasses.h" */
    1798             : 
    1799             : 
    1800             : 
    1801             : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarStorageClassDeclatationMacros.macro" */
    1802             : /* 
    1803             :    JH (01/01/2006) ROSETTA generated class declarations for SgFunctionParameterTypeListStorageClass 
    1804             :    used for the ast file IO. Do not chance by hand! 
    1805             : */
    1806       16821 : class SgFunctionParameterTypeListStorageClass  : public SgSupportStorageClass
    1807             :    {
    1808             : 
    1809             :     protected: 
    1810             : 
    1811             : 
    1812             : /* #line 1813 "../../../src/frontend/SageIII//StorageClasses.h" */
    1813             : 
    1814             :        EasyStorage < SgTypePtrList > storageOf_arguments;
    1815             : 
    1816             : 
    1817             : /* #line 10 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarStorageClassDeclatationMacros.macro" */
    1818             : 
    1819             : 
    1820             :     public:
    1821             :       void pickOutIRNodeData ( SgFunctionParameterTypeList* source );
    1822             :       static void arrangeStaticDataOfEasyStorageClassesInOneBlock ( );
    1823             :       static void deleteStaticDataOfEasyStorageClasses ( );
    1824             :       static void pickOutStaticDataMembers ( );
    1825             :       static void rebuildStaticDataMembers ( );
    1826             :       static void writeEasyStorageDataToFile (std::ostream& out);
    1827             :       static void readEasyStorageDataFromFile (std::istream& in);
    1828             :       static void writeStaticDataToFile (std::ostream& out );
    1829             :       static void readStaticDataFromFile (std::istream& in );
    1830             :       friend class SgFunctionParameterTypeList;
    1831             :    };
    1832             : /* #line 1833 "../../../src/frontend/SageIII//StorageClasses.h" */
    1833             : 
    1834             : 
    1835             : 
    1836             : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarStorageClassDeclatationMacros.macro" */
    1837             : /* 
    1838             :    JH (01/01/2006) ROSETTA generated class declarations for SgQualifiedNameStorageClass 
    1839             :    used for the ast file IO. Do not chance by hand! 
    1840             : */
    1841             : class SgQualifiedNameStorageClass  : public SgSupportStorageClass
    1842             :    {
    1843             : 
    1844             :     protected: 
    1845             : 
    1846             : 
    1847             : /* #line 1848 "../../../src/frontend/SageIII//StorageClasses.h" */
    1848             : 
    1849             :      unsigned long storageOf_scope;
    1850             : 
    1851             : 
    1852             : /* #line 10 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarStorageClassDeclatationMacros.macro" */
    1853             : 
    1854             : 
    1855             :     public:
    1856             :       void pickOutIRNodeData ( SgQualifiedName* source );
    1857             :       static void arrangeStaticDataOfEasyStorageClassesInOneBlock ( );
    1858             :       static void deleteStaticDataOfEasyStorageClasses ( );
    1859             :       static void pickOutStaticDataMembers ( );
    1860             :       static void rebuildStaticDataMembers ( );
    1861             :       static void writeEasyStorageDataToFile (std::ostream& out);
    1862             :       static void readEasyStorageDataFromFile (std::istream& in);
    1863             :       static void writeStaticDataToFile (std::ostream& out );
    1864             :       static void readStaticDataFromFile (std::istream& in );
    1865             :       friend class SgQualifiedName;
    1866             :    };
    1867             : /* #line 1868 "../../../src/frontend/SageIII//StorageClasses.h" */
    1868             : 
    1869             : 
    1870             : 
    1871             : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarStorageClassDeclatationMacros.macro" */
    1872             : /* 
    1873             :    JH (01/01/2006) ROSETTA generated class declarations for SgTemplateArgumentListStorageClass 
    1874             :    used for the ast file IO. Do not chance by hand! 
    1875             : */
    1876           0 : class SgTemplateArgumentListStorageClass  : public SgSupportStorageClass
    1877             :    {
    1878             : 
    1879             :     protected: 
    1880             : 
    1881             : 
    1882             : /* #line 1883 "../../../src/frontend/SageIII//StorageClasses.h" */
    1883             : 
    1884             :        EasyStorage < SgTemplateArgumentPtrList > storageOf_args;
    1885             : 
    1886             : 
    1887             : /* #line 10 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarStorageClassDeclatationMacros.macro" */
    1888             : 
    1889             : 
    1890             :     public:
    1891             :       void pickOutIRNodeData ( SgTemplateArgumentList* source );
    1892             :       static void arrangeStaticDataOfEasyStorageClassesInOneBlock ( );
    1893             :       static void deleteStaticDataOfEasyStorageClasses ( );
    1894             :       static void pickOutStaticDataMembers ( );
    1895             :       static void rebuildStaticDataMembers ( );
    1896             :       static void writeEasyStorageDataToFile (std::ostream& out);
    1897             :       static void readEasyStorageDataFromFile (std::istream& in);
    1898             :       static void writeStaticDataToFile (std::ostream& out );
    1899             :       static void readStaticDataFromFile (std::istream& in );
    1900             :       friend class SgTemplateArgumentList;
    1901             :    };
    1902             : /* #line 1903 "../../../src/frontend/SageIII//StorageClasses.h" */
    1903             : 
    1904             : 
    1905             : 
    1906             : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarStorageClassDeclatationMacros.macro" */
    1907             : /* 
    1908             :    JH (01/01/2006) ROSETTA generated class declarations for SgTemplateParameterListStorageClass 
    1909             :    used for the ast file IO. Do not chance by hand! 
    1910             : */
    1911           0 : class SgTemplateParameterListStorageClass  : public SgSupportStorageClass
    1912             :    {
    1913             : 
    1914             :     protected: 
    1915             : 
    1916             : 
    1917             : /* #line 1918 "../../../src/frontend/SageIII//StorageClasses.h" */
    1918             : 
    1919             :        EasyStorage < SgTemplateParameterPtrList > storageOf_args;
    1920             : 
    1921             : 
    1922             : /* #line 10 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarStorageClassDeclatationMacros.macro" */
    1923             : 
    1924             : 
    1925             :     public:
    1926             :       void pickOutIRNodeData ( SgTemplateParameterList* source );
    1927             :       static void arrangeStaticDataOfEasyStorageClassesInOneBlock ( );
    1928             :       static void deleteStaticDataOfEasyStorageClasses ( );
    1929             :       static void pickOutStaticDataMembers ( );
    1930             :       static void rebuildStaticDataMembers ( );
    1931             :       static void writeEasyStorageDataToFile (std::ostream& out);
    1932             :       static void readEasyStorageDataFromFile (std::istream& in);
    1933             :       static void writeStaticDataToFile (std::ostream& out );
    1934             :       static void readStaticDataFromFile (std::istream& in );
    1935             :       friend class SgTemplateParameterList;
    1936             :    };
    1937             : /* #line 1938 "../../../src/frontend/SageIII//StorageClasses.h" */
    1938             : 
    1939             : 
    1940             : 
    1941             : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarStorageClassDeclatationMacros.macro" */
    1942             : /* 
    1943             :    JH (01/01/2006) ROSETTA generated class declarations for SgGraphStorageClass 
    1944             :    used for the ast file IO. Do not chance by hand! 
    1945             : */
    1946           0 : class SgGraphStorageClass  : public SgSupportStorageClass
    1947             :    {
    1948             : 
    1949             :     protected: 
    1950             : 
    1951             : 
    1952             : /* #line 1953 "../../../src/frontend/SageIII//StorageClasses.h" */
    1953             : 
    1954             :        EasyStorage < std::string > storageOf_name;
    1955             :        EasyStorage < rose_graph_integer_node_hash_map > storageOf_node_index_to_node_map;
    1956             :        EasyStorage < rose_graph_integer_edge_hash_map > storageOf_edge_index_to_edge_map;
    1957             :        EasyStorage < rose_graph_integerpair_edge_hash_multimap > storageOf_node_index_pair_to_edge_multimap;
    1958             :        EasyStorage < rose_graph_string_integer_hash_multimap > storageOf_string_to_node_index_multimap;
    1959             :        EasyStorage < rose_graph_string_integer_hash_multimap > storageOf_string_to_edge_index_multimap;
    1960             :        EasyStorage < rose_graph_integer_edge_hash_multimap > storageOf_node_index_to_edge_multimap;
    1961             :       int storageOf_index;
    1962             :        EasyStorage < SgBoostEdgeList > storageOf_boost_edges;
    1963             :        EasyStorage < SgBoostEdgeWeightList > storageOf_boost_edge_weights;
    1964             :        EasyStorage < AstAttributeMechanism* > storageOf_attributeMechanism;
    1965             :        EasyStorage < std::map<int, std::string> > storageOf_properties;
    1966             : 
    1967             : 
    1968             : /* #line 10 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarStorageClassDeclatationMacros.macro" */
    1969             : 
    1970             : 
    1971             :     public:
    1972             :       void pickOutIRNodeData ( SgGraph* source );
    1973             :       static void arrangeStaticDataOfEasyStorageClassesInOneBlock ( );
    1974             :       static void deleteStaticDataOfEasyStorageClasses ( );
    1975             :       static void pickOutStaticDataMembers ( );
    1976             :       static void rebuildStaticDataMembers ( );
    1977             :       static void writeEasyStorageDataToFile (std::ostream& out);
    1978             :       static void readEasyStorageDataFromFile (std::istream& in);
    1979             :       static void writeStaticDataToFile (std::ostream& out );
    1980             :       static void readStaticDataFromFile (std::istream& in );
    1981             :       friend class SgGraph;
    1982             :    };
    1983             : /* #line 1984 "../../../src/frontend/SageIII//StorageClasses.h" */
    1984             : 
    1985             : 
    1986             : 
    1987             : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarStorageClassDeclatationMacros.macro" */
    1988             : /* 
    1989             :    JH (01/01/2006) ROSETTA generated class declarations for SgIncidenceDirectedGraphStorageClass 
    1990             :    used for the ast file IO. Do not chance by hand! 
    1991             : */
    1992             : class SgIncidenceDirectedGraphStorageClass  : public SgGraphStorageClass
    1993             :    {
    1994             : 
    1995             :     protected: 
    1996             : 
    1997             : 
    1998             : /* #line 1999 "../../../src/frontend/SageIII//StorageClasses.h" */
    1999             : 
    2000             :        EasyStorage < rose_graph_integer_edge_hash_multimap > storageOf_node_index_to_edge_multimap_edgesOut;
    2001             :        EasyStorage < rose_graph_integer_edge_hash_multimap > storageOf_node_index_to_edge_multimap_edgesIn;
    2002             : 
    2003             : 
    2004             : /* #line 10 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarStorageClassDeclatationMacros.macro" */
    2005             : 
    2006             : 
    2007             :     public:
    2008             :       void pickOutIRNodeData ( SgIncidenceDirectedGraph* source );
    2009             :       static void arrangeStaticDataOfEasyStorageClassesInOneBlock ( );
    2010             :       static void deleteStaticDataOfEasyStorageClasses ( );
    2011             :       static void pickOutStaticDataMembers ( );
    2012             :       static void rebuildStaticDataMembers ( );
    2013             :       static void writeEasyStorageDataToFile (std::ostream& out);
    2014             :       static void readEasyStorageDataFromFile (std::istream& in);
    2015             :       static void writeStaticDataToFile (std::ostream& out );
    2016             :       static void readStaticDataFromFile (std::istream& in );
    2017             :       friend class SgIncidenceDirectedGraph;
    2018             :    };
    2019             : /* #line 2020 "../../../src/frontend/SageIII//StorageClasses.h" */
    2020             : 
    2021             : 
    2022             : 
    2023             : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarStorageClassDeclatationMacros.macro" */
    2024             : /* 
    2025             :    JH (01/01/2006) ROSETTA generated class declarations for SgBidirectionalGraphStorageClass 
    2026             :    used for the ast file IO. Do not chance by hand! 
    2027             : */
    2028           0 : class SgBidirectionalGraphStorageClass  : public SgIncidenceDirectedGraphStorageClass
    2029             :    {
    2030             : 
    2031             :     protected: 
    2032             : 
    2033             : 
    2034             : /* #line 2035 "../../../src/frontend/SageIII//StorageClasses.h" */
    2035             : 
    2036             : 
    2037             : 
    2038             : /* #line 10 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarStorageClassDeclatationMacros.macro" */
    2039             : 
    2040             : 
    2041             :     public:
    2042             :       void pickOutIRNodeData ( SgBidirectionalGraph* source );
    2043             :       static void arrangeStaticDataOfEasyStorageClassesInOneBlock ( );
    2044             :       static void deleteStaticDataOfEasyStorageClasses ( );
    2045             :       static void pickOutStaticDataMembers ( );
    2046             :       static void rebuildStaticDataMembers ( );
    2047             :       static void writeEasyStorageDataToFile (std::ostream& out);
    2048             :       static void readEasyStorageDataFromFile (std::istream& in);
    2049             :       static void writeStaticDataToFile (std::ostream& out );
    2050             :       static void readStaticDataFromFile (std::istream& in );
    2051             :       friend class SgBidirectionalGraph;
    2052             :    };
    2053             : /* #line 2054 "../../../src/frontend/SageIII//StorageClasses.h" */
    2054             : 
    2055             : 
    2056             : 
    2057             : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarStorageClassDeclatationMacros.macro" */
    2058             : /* 
    2059             :    JH (01/01/2006) ROSETTA generated class declarations for SgStringKeyedBidirectionalGraphStorageClass 
    2060             :    used for the ast file IO. Do not chance by hand! 
    2061             : */
    2062           0 : class SgStringKeyedBidirectionalGraphStorageClass  : public SgBidirectionalGraphStorageClass
    2063             :    {
    2064             : 
    2065             :     protected: 
    2066             : 
    2067             : 
    2068             : /* #line 2069 "../../../src/frontend/SageIII//StorageClasses.h" */
    2069             : 
    2070             : 
    2071             : 
    2072             : /* #line 10 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarStorageClassDeclatationMacros.macro" */
    2073             : 
    2074             : 
    2075             :     public:
    2076             :       void pickOutIRNodeData ( SgStringKeyedBidirectionalGraph* source );
    2077             :       static void arrangeStaticDataOfEasyStorageClassesInOneBlock ( );
    2078             :       static void deleteStaticDataOfEasyStorageClasses ( );
    2079             :       static void pickOutStaticDataMembers ( );
    2080             :       static void rebuildStaticDataMembers ( );
    2081             :       static void writeEasyStorageDataToFile (std::ostream& out);
    2082             :       static void readEasyStorageDataFromFile (std::istream& in);
    2083             :       static void writeStaticDataToFile (std::ostream& out );
    2084             :       static void readStaticDataFromFile (std::istream& in );
    2085             :       friend class SgStringKeyedBidirectionalGraph;
    2086             :    };
    2087             : /* #line 2088 "../../../src/frontend/SageIII//StorageClasses.h" */
    2088             : 
    2089             : 
    2090             : 
    2091             : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarStorageClassDeclatationMacros.macro" */
    2092             : /* 
    2093             :    JH (01/01/2006) ROSETTA generated class declarations for SgIntKeyedBidirectionalGraphStorageClass 
    2094             :    used for the ast file IO. Do not chance by hand! 
    2095             : */
    2096           0 : class SgIntKeyedBidirectionalGraphStorageClass  : public SgBidirectionalGraphStorageClass
    2097             :    {
    2098             : 
    2099             :     protected: 
    2100             : 
    2101             : 
    2102             : /* #line 2103 "../../../src/frontend/SageIII//StorageClasses.h" */
    2103             : 
    2104             : 
    2105             : 
    2106             : /* #line 10 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarStorageClassDeclatationMacros.macro" */
    2107             : 
    2108             : 
    2109             :     public:
    2110             :       void pickOutIRNodeData ( SgIntKeyedBidirectionalGraph* source );
    2111             :       static void arrangeStaticDataOfEasyStorageClassesInOneBlock ( );
    2112             :       static void deleteStaticDataOfEasyStorageClasses ( );
    2113             :       static void pickOutStaticDataMembers ( );
    2114             :       static void rebuildStaticDataMembers ( );
    2115             :       static void writeEasyStorageDataToFile (std::ostream& out);
    2116             :       static void readEasyStorageDataFromFile (std::istream& in);
    2117             :       static void writeStaticDataToFile (std::ostream& out );
    2118             :       static void readStaticDataFromFile (std::istream& in );
    2119             :       friend class SgIntKeyedBidirectionalGraph;
    2120             :    };
    2121             : /* #line 2122 "../../../src/frontend/SageIII//StorageClasses.h" */
    2122             : 
    2123             : 
    2124             : 
    2125             : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarStorageClassDeclatationMacros.macro" */
    2126             : /* 
    2127             :    JH (01/01/2006) ROSETTA generated class declarations for SgIncidenceUndirectedGraphStorageClass 
    2128             :    used for the ast file IO. Do not chance by hand! 
    2129             : */
    2130           0 : class SgIncidenceUndirectedGraphStorageClass  : public SgGraphStorageClass
    2131             :    {
    2132             : 
    2133             :     protected: 
    2134             : 
    2135             : 
    2136             : /* #line 2137 "../../../src/frontend/SageIII//StorageClasses.h" */
    2137             : 
    2138             : 
    2139             : 
    2140             : /* #line 10 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarStorageClassDeclatationMacros.macro" */
    2141             : 
    2142             : 
    2143             :     public:
    2144             :       void pickOutIRNodeData ( SgIncidenceUndirectedGraph* source );
    2145             :       static void arrangeStaticDataOfEasyStorageClassesInOneBlock ( );
    2146             :       static void deleteStaticDataOfEasyStorageClasses ( );
    2147             :       static void pickOutStaticDataMembers ( );
    2148             :       static void rebuildStaticDataMembers ( );
    2149             :       static void writeEasyStorageDataToFile (std::ostream& out);
    2150             :       static void readEasyStorageDataFromFile (std::istream& in);
    2151             :       static void writeStaticDataToFile (std::ostream& out );
    2152             :       static void readStaticDataFromFile (std::istream& in );
    2153             :       friend class SgIncidenceUndirectedGraph;
    2154             :    };
    2155             : /* #line 2156 "../../../src/frontend/SageIII//StorageClasses.h" */
    2156             : 
    2157             : 
    2158             : 
    2159             : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarStorageClassDeclatationMacros.macro" */
    2160             : /* 
    2161             :    JH (01/01/2006) ROSETTA generated class declarations for SgGraphNodeStorageClass 
    2162             :    used for the ast file IO. Do not chance by hand! 
    2163             : */
    2164           0 : class SgGraphNodeStorageClass  : public SgSupportStorageClass
    2165             :    {
    2166             : 
    2167             :     protected: 
    2168             : 
    2169             : 
    2170             : /* #line 2171 "../../../src/frontend/SageIII//StorageClasses.h" */
    2171             : 
    2172             :        EasyStorage < std::string > storageOf_name;
    2173             :      unsigned long storageOf_SgNode;
    2174             :       int storageOf_index;
    2175             :        EasyStorage < AstAttributeMechanism* > storageOf_attributeMechanism;
    2176             :        EasyStorage < std::map<int, std::string> > storageOf_properties;
    2177             : 
    2178             : 
    2179             : /* #line 10 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarStorageClassDeclatationMacros.macro" */
    2180             : 
    2181             : 
    2182             :     public:
    2183             :       void pickOutIRNodeData ( SgGraphNode* source );
    2184             :       static void arrangeStaticDataOfEasyStorageClassesInOneBlock ( );
    2185             :       static void deleteStaticDataOfEasyStorageClasses ( );
    2186             :       static void pickOutStaticDataMembers ( );
    2187             :       static void rebuildStaticDataMembers ( );
    2188             :       static void writeEasyStorageDataToFile (std::ostream& out);
    2189             :       static void readEasyStorageDataFromFile (std::istream& in);
    2190             :       static void writeStaticDataToFile (std::ostream& out );
    2191             :       static void readStaticDataFromFile (std::istream& in );
    2192             :       friend class SgGraphNode;
    2193             :    };
    2194             : /* #line 2195 "../../../src/frontend/SageIII//StorageClasses.h" */
    2195             : 
    2196             : 
    2197             : 
    2198             : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarStorageClassDeclatationMacros.macro" */
    2199             : /* 
    2200             :    JH (01/01/2006) ROSETTA generated class declarations for SgGraphEdgeStorageClass 
    2201             :    used for the ast file IO. Do not chance by hand! 
    2202             : */
    2203           0 : class SgGraphEdgeStorageClass  : public SgSupportStorageClass
    2204             :    {
    2205             : 
    2206             :     protected: 
    2207             : 
    2208             : 
    2209             : /* #line 2210 "../../../src/frontend/SageIII//StorageClasses.h" */
    2210             : 
    2211             :      unsigned long storageOf_node_A;
    2212             :      unsigned long storageOf_node_B;
    2213             :        EasyStorage < std::string > storageOf_name;
    2214             :       int storageOf_index;
    2215             :        EasyStorage < AstAttributeMechanism* > storageOf_attributeMechanism;
    2216             :        EasyStorage < std::map<int, std::string> > storageOf_properties;
    2217             : 
    2218             : 
    2219             : /* #line 10 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarStorageClassDeclatationMacros.macro" */
    2220             : 
    2221             : 
    2222             :     public:
    2223             :       void pickOutIRNodeData ( SgGraphEdge* source );
    2224             :       static void arrangeStaticDataOfEasyStorageClassesInOneBlock ( );
    2225             :       static void deleteStaticDataOfEasyStorageClasses ( );
    2226             :       static void pickOutStaticDataMembers ( );
    2227             :       static void rebuildStaticDataMembers ( );
    2228             :       static void writeEasyStorageDataToFile (std::ostream& out);
    2229             :       static void readEasyStorageDataFromFile (std::istream& in);
    2230             :       static void writeStaticDataToFile (std::ostream& out );
    2231             :       static void readStaticDataFromFile (std::istream& in );
    2232             :       friend class SgGraphEdge;
    2233             :    };
    2234             : /* #line 2235 "../../../src/frontend/SageIII//StorageClasses.h" */
    2235             : 
    2236             : 
    2237             : 
    2238             : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarStorageClassDeclatationMacros.macro" */
    2239             : /* 
    2240             :    JH (01/01/2006) ROSETTA generated class declarations for SgDirectedGraphEdgeStorageClass 
    2241             :    used for the ast file IO. Do not chance by hand! 
    2242             : */
    2243           0 : class SgDirectedGraphEdgeStorageClass  : public SgGraphEdgeStorageClass
    2244             :    {
    2245             : 
    2246             :     protected: 
    2247             : 
    2248             : 
    2249             : /* #line 2250 "../../../src/frontend/SageIII//StorageClasses.h" */
    2250             : 
    2251             : 
    2252             : 
    2253             : /* #line 10 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarStorageClassDeclatationMacros.macro" */
    2254             : 
    2255             : 
    2256             :     public:
    2257             :       void pickOutIRNodeData ( SgDirectedGraphEdge* source );
    2258             :       static void arrangeStaticDataOfEasyStorageClassesInOneBlock ( );
    2259             :       static void deleteStaticDataOfEasyStorageClasses ( );
    2260             :       static void pickOutStaticDataMembers ( );
    2261             :       static void rebuildStaticDataMembers ( );
    2262             :       static void writeEasyStorageDataToFile (std::ostream& out);
    2263             :       static void readEasyStorageDataFromFile (std::istream& in);
    2264             :       static void writeStaticDataToFile (std::ostream& out );
    2265             :       static void readStaticDataFromFile (std::istream& in );
    2266             :       friend class SgDirectedGraphEdge;
    2267             :    };
    2268             : /* #line 2269 "../../../src/frontend/SageIII//StorageClasses.h" */
    2269             : 
    2270             : 
    2271             : 
    2272             : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarStorageClassDeclatationMacros.macro" */
    2273             : /* 
    2274             :    JH (01/01/2006) ROSETTA generated class declarations for SgUndirectedGraphEdgeStorageClass 
    2275             :    used for the ast file IO. Do not chance by hand! 
    2276             : */
    2277           0 : class SgUndirectedGraphEdgeStorageClass  : public SgGraphEdgeStorageClass
    2278             :    {
    2279             : 
    2280             :     protected: 
    2281             : 
    2282             : 
    2283             : /* #line 2284 "../../../src/frontend/SageIII//StorageClasses.h" */
    2284             : 
    2285             : 
    2286             : 
    2287             : /* #line 10 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarStorageClassDeclatationMacros.macro" */
    2288             : 
    2289             : 
    2290             :     public:
    2291             :       void pickOutIRNodeData ( SgUndirectedGraphEdge* source );
    2292             :       static void arrangeStaticDataOfEasyStorageClassesInOneBlock ( );
    2293             :       static void deleteStaticDataOfEasyStorageClasses ( );
    2294             :       static void pickOutStaticDataMembers ( );
    2295             :       static void rebuildStaticDataMembers ( );
    2296             :       static void writeEasyStorageDataToFile (std::ostream& out);
    2297             :       static void readEasyStorageDataFromFile (std::istream& in);
    2298             :       static void writeStaticDataToFile (std::ostream& out );
    2299             :       static void readStaticDataFromFile (std::istream& in );
    2300             :       friend class SgUndirectedGraphEdge;
    2301             :    };
    2302             : /* #line 2303 "../../../src/frontend/SageIII//StorageClasses.h" */
    2303             : 
    2304             : 
    2305             : 
    2306             : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarStorageClassDeclatationMacros.macro" */
    2307             : /* 
    2308             :    JH (01/01/2006) ROSETTA generated class declarations for SgGraphNodeListStorageClass 
    2309             :    used for the ast file IO. Do not chance by hand! 
    2310             : */
    2311             : class SgGraphNodeListStorageClass  : public SgSupportStorageClass
    2312             :    {
    2313             : 
    2314             :     protected: 
    2315             : 
    2316             : 
    2317             : /* #line 2318 "../../../src/frontend/SageIII//StorageClasses.h" */
    2318             : 
    2319             : 
    2320             : 
    2321             : /* #line 10 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarStorageClassDeclatationMacros.macro" */
    2322             : 
    2323             : 
    2324             :     public:
    2325             :       void pickOutIRNodeData ( SgGraphNodeList* source );
    2326             :       static void arrangeStaticDataOfEasyStorageClassesInOneBlock ( );
    2327             :       static void deleteStaticDataOfEasyStorageClasses ( );
    2328             :       static void pickOutStaticDataMembers ( );
    2329             :       static void rebuildStaticDataMembers ( );
    2330             :       static void writeEasyStorageDataToFile (std::ostream& out);
    2331             :       static void readEasyStorageDataFromFile (std::istream& in);
    2332             :       static void writeStaticDataToFile (std::ostream& out );
    2333             :       static void readStaticDataFromFile (std::istream& in );
    2334             :       friend class SgGraphNodeList;
    2335             :    };
    2336             : /* #line 2337 "../../../src/frontend/SageIII//StorageClasses.h" */
    2337             : 
    2338             : 
    2339             : 
    2340             : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarStorageClassDeclatationMacros.macro" */
    2341             : /* 
    2342             :    JH (01/01/2006) ROSETTA generated class declarations for SgGraphEdgeListStorageClass 
    2343             :    used for the ast file IO. Do not chance by hand! 
    2344             : */
    2345             : class SgGraphEdgeListStorageClass  : public SgSupportStorageClass
    2346             :    {
    2347             : 
    2348             :     protected: 
    2349             : 
    2350             : 
    2351             : /* #line 2352 "../../../src/frontend/SageIII//StorageClasses.h" */
    2352             : 
    2353             : 
    2354             : 
    2355             : /* #line 10 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarStorageClassDeclatationMacros.macro" */
    2356             : 
    2357             : 
    2358             :     public:
    2359             :       void pickOutIRNodeData ( SgGraphEdgeList* source );
    2360             :       static void arrangeStaticDataOfEasyStorageClassesInOneBlock ( );
    2361             :       static void deleteStaticDataOfEasyStorageClasses ( );
    2362             :       static void pickOutStaticDataMembers ( );
    2363             :       static void rebuildStaticDataMembers ( );
    2364             :       static void writeEasyStorageDataToFile (std::ostream& out);
    2365             :       static void readEasyStorageDataFromFile (std::istream& in);
    2366             :       static void writeStaticDataToFile (std::ostream& out );
    2367             :       static void readStaticDataFromFile (std::istream& in );
    2368             :       friend class SgGraphEdgeList;
    2369             :    };
    2370             : /* #line 2371 "../../../src/frontend/SageIII//StorageClasses.h" */
    2371             : 
    2372             : 
    2373             : 
    2374             : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarStorageClassDeclatationMacros.macro" */
    2375             : /* 
    2376             :    JH (01/01/2006) ROSETTA generated class declarations for SgTypeTableStorageClass 
    2377             :    used for the ast file IO. Do not chance by hand! 
    2378             : */
    2379             : class SgTypeTableStorageClass  : public SgSupportStorageClass
    2380             :    {
    2381             : 
    2382             :     protected: 
    2383             : 
    2384             : 
    2385             : /* #line 2386 "../../../src/frontend/SageIII//StorageClasses.h" */
    2386             : 
    2387             :      unsigned long storageOf_type_table;
    2388             : 
    2389             : 
    2390             : /* #line 10 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarStorageClassDeclatationMacros.macro" */
    2391             : 
    2392             : 
    2393             :     public:
    2394             :       void pickOutIRNodeData ( SgTypeTable* source );
    2395             :       static void arrangeStaticDataOfEasyStorageClassesInOneBlock ( );
    2396             :       static void deleteStaticDataOfEasyStorageClasses ( );
    2397             :       static void pickOutStaticDataMembers ( );
    2398             :       static void rebuildStaticDataMembers ( );
    2399             :       static void writeEasyStorageDataToFile (std::ostream& out);
    2400             :       static void readEasyStorageDataFromFile (std::istream& in);
    2401             :       static void writeStaticDataToFile (std::ostream& out );
    2402             :       static void readStaticDataFromFile (std::istream& in );
    2403             :       friend class SgTypeTable;
    2404             :    };
    2405             : /* #line 2406 "../../../src/frontend/SageIII//StorageClasses.h" */
    2406             : 
    2407             : 
    2408             : 
    2409             : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarStorageClassDeclatationMacros.macro" */
    2410             : /* 
    2411             :    JH (01/01/2006) ROSETTA generated class declarations for SgNameGroupStorageClass 
    2412             :    used for the ast file IO. Do not chance by hand! 
    2413             : */
    2414           0 : class SgNameGroupStorageClass  : public SgSupportStorageClass
    2415             :    {
    2416             : 
    2417             :     protected: 
    2418             : 
    2419             : 
    2420             : /* #line 2421 "../../../src/frontend/SageIII//StorageClasses.h" */
    2421             : 
    2422             :        EasyStorage < std::string > storageOf_group_name;
    2423             :        EasyStorage < SgStringList > storageOf_name_list;
    2424             : 
    2425             : 
    2426             : /* #line 10 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarStorageClassDeclatationMacros.macro" */
    2427             : 
    2428             : 
    2429             :     public:
    2430             :       void pickOutIRNodeData ( SgNameGroup* source );
    2431             :       static void arrangeStaticDataOfEasyStorageClassesInOneBlock ( );
    2432             :       static void deleteStaticDataOfEasyStorageClasses ( );
    2433             :       static void pickOutStaticDataMembers ( );
    2434             :       static void rebuildStaticDataMembers ( );
    2435             :       static void writeEasyStorageDataToFile (std::ostream& out);
    2436             :       static void readEasyStorageDataFromFile (std::istream& in);
    2437             :       static void writeStaticDataToFile (std::ostream& out );
    2438             :       static void readStaticDataFromFile (std::istream& in );
    2439             :       friend class SgNameGroup;
    2440             :    };
    2441             : /* #line 2442 "../../../src/frontend/SageIII//StorageClasses.h" */
    2442             : 
    2443             : 
    2444             : 
    2445             : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarStorageClassDeclatationMacros.macro" */
    2446             : /* 
    2447             :    JH (01/01/2006) ROSETTA generated class declarations for SgDimensionObjectStorageClass 
    2448             :    used for the ast file IO. Do not chance by hand! 
    2449             : */
    2450             : class SgDimensionObjectStorageClass  : public SgSupportStorageClass
    2451             :    {
    2452             : 
    2453             :     protected: 
    2454             : 
    2455             : 
    2456             : /* #line 2457 "../../../src/frontend/SageIII//StorageClasses.h" */
    2457             : 
    2458             :      unsigned long storageOf_array;
    2459             :      unsigned long storageOf_shape;
    2460             : 
    2461             : 
    2462             : /* #line 10 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarStorageClassDeclatationMacros.macro" */
    2463             : 
    2464             : 
    2465             :     public:
    2466             :       void pickOutIRNodeData ( SgDimensionObject* source );
    2467             :       static void arrangeStaticDataOfEasyStorageClassesInOneBlock ( );
    2468             :       static void deleteStaticDataOfEasyStorageClasses ( );
    2469             :       static void pickOutStaticDataMembers ( );
    2470             :       static void rebuildStaticDataMembers ( );
    2471             :       static void writeEasyStorageDataToFile (std::ostream& out);
    2472             :       static void readEasyStorageDataFromFile (std::istream& in);
    2473             :       static void writeStaticDataToFile (std::ostream& out );
    2474             :       static void readStaticDataFromFile (std::istream& in );
    2475             :       friend class SgDimensionObject;
    2476             :    };
    2477             : /* #line 2478 "../../../src/frontend/SageIII//StorageClasses.h" */
    2478             : 
    2479             : 
    2480             : 
    2481             : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarStorageClassDeclatationMacros.macro" */
    2482             : /* 
    2483             :    JH (01/01/2006) ROSETTA generated class declarations for SgFormatItemStorageClass 
    2484             :    used for the ast file IO. Do not chance by hand! 
    2485             : */
    2486             : class SgFormatItemStorageClass  : public SgSupportStorageClass
    2487             :    {
    2488             : 
    2489             :     protected: 
    2490             : 
    2491             : 
    2492             : /* #line 2493 "../../../src/frontend/SageIII//StorageClasses.h" */
    2493             : 
    2494             :       int storageOf_repeat_specification;
    2495             :      unsigned long storageOf_data;
    2496             :      unsigned long storageOf_format_item_list;
    2497             : 
    2498             : 
    2499             : /* #line 10 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarStorageClassDeclatationMacros.macro" */
    2500             : 
    2501             : 
    2502             :     public:
    2503             :       void pickOutIRNodeData ( SgFormatItem* source );
    2504             :       static void arrangeStaticDataOfEasyStorageClassesInOneBlock ( );
    2505             :       static void deleteStaticDataOfEasyStorageClasses ( );
    2506             :       static void pickOutStaticDataMembers ( );
    2507             :       static void rebuildStaticDataMembers ( );
    2508             :       static void writeEasyStorageDataToFile (std::ostream& out);
    2509             :       static void readEasyStorageDataFromFile (std::istream& in);
    2510             :       static void writeStaticDataToFile (std::ostream& out );
    2511             :       static void readStaticDataFromFile (std::istream& in );
    2512             :       friend class SgFormatItem;
    2513             :    };
    2514             : /* #line 2515 "../../../src/frontend/SageIII//StorageClasses.h" */
    2515             : 
    2516             : 
    2517             : 
    2518             : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarStorageClassDeclatationMacros.macro" */
    2519             : /* 
    2520             :    JH (01/01/2006) ROSETTA generated class declarations for SgFormatItemListStorageClass 
    2521             :    used for the ast file IO. Do not chance by hand! 
    2522             : */
    2523           0 : class SgFormatItemListStorageClass  : public SgSupportStorageClass
    2524             :    {
    2525             : 
    2526             :     protected: 
    2527             : 
    2528             : 
    2529             : /* #line 2530 "../../../src/frontend/SageIII//StorageClasses.h" */
    2530             : 
    2531             :        EasyStorage < SgFormatItemPtrList > storageOf_format_item_list;
    2532             : 
    2533             : 
    2534             : /* #line 10 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarStorageClassDeclatationMacros.macro" */
    2535             : 
    2536             : 
    2537             :     public:
    2538             :       void pickOutIRNodeData ( SgFormatItemList* source );
    2539             :       static void arrangeStaticDataOfEasyStorageClassesInOneBlock ( );
    2540             :       static void deleteStaticDataOfEasyStorageClasses ( );
    2541             :       static void pickOutStaticDataMembers ( );
    2542             :       static void rebuildStaticDataMembers ( );
    2543             :       static void writeEasyStorageDataToFile (std::ostream& out);
    2544             :       static void readEasyStorageDataFromFile (std::istream& in);
    2545             :       static void writeStaticDataToFile (std::ostream& out );
    2546             :       static void readStaticDataFromFile (std::istream& in );
    2547             :       friend class SgFormatItemList;
    2548             :    };
    2549             : /* #line 2550 "../../../src/frontend/SageIII//StorageClasses.h" */
    2550             : 
    2551             : 
    2552             : 
    2553             : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarStorageClassDeclatationMacros.macro" */
    2554             : /* 
    2555             :    JH (01/01/2006) ROSETTA generated class declarations for SgDataStatementGroupStorageClass 
    2556             :    used for the ast file IO. Do not chance by hand! 
    2557             : */
    2558           0 : class SgDataStatementGroupStorageClass  : public SgSupportStorageClass
    2559             :    {
    2560             : 
    2561             :     protected: 
    2562             : 
    2563             : 
    2564             : /* #line 2565 "../../../src/frontend/SageIII//StorageClasses.h" */
    2565             : 
    2566             :        EasyStorage < SgDataStatementObjectPtrList > storageOf_object_list;
    2567             :        EasyStorage < SgDataStatementValuePtrList > storageOf_value_list;
    2568             : 
    2569             : 
    2570             : /* #line 10 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarStorageClassDeclatationMacros.macro" */
    2571             : 
    2572             : 
    2573             :     public:
    2574             :       void pickOutIRNodeData ( SgDataStatementGroup* source );
    2575             :       static void arrangeStaticDataOfEasyStorageClassesInOneBlock ( );
    2576             :       static void deleteStaticDataOfEasyStorageClasses ( );
    2577             :       static void pickOutStaticDataMembers ( );
    2578             :       static void rebuildStaticDataMembers ( );
    2579             :       static void writeEasyStorageDataToFile (std::ostream& out);
    2580             :       static void readEasyStorageDataFromFile (std::istream& in);
    2581             :       static void writeStaticDataToFile (std::ostream& out );
    2582             :       static void readStaticDataFromFile (std::istream& in );
    2583             :       friend class SgDataStatementGroup;
    2584             :    };
    2585             : /* #line 2586 "../../../src/frontend/SageIII//StorageClasses.h" */
    2586             : 
    2587             : 
    2588             : 
    2589             : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarStorageClassDeclatationMacros.macro" */
    2590             : /* 
    2591             :    JH (01/01/2006) ROSETTA generated class declarations for SgDataStatementObjectStorageClass 
    2592             :    used for the ast file IO. Do not chance by hand! 
    2593             : */
    2594             : class SgDataStatementObjectStorageClass  : public SgSupportStorageClass
    2595             :    {
    2596             : 
    2597             :     protected: 
    2598             : 
    2599             : 
    2600             : /* #line 2601 "../../../src/frontend/SageIII//StorageClasses.h" */
    2601             : 
    2602             :      unsigned long storageOf_variableReference_list;
    2603             : 
    2604             : 
    2605             : /* #line 10 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarStorageClassDeclatationMacros.macro" */
    2606             : 
    2607             : 
    2608             :     public:
    2609             :       void pickOutIRNodeData ( SgDataStatementObject* source );
    2610             :       static void arrangeStaticDataOfEasyStorageClassesInOneBlock ( );
    2611             :       static void deleteStaticDataOfEasyStorageClasses ( );
    2612             :       static void pickOutStaticDataMembers ( );
    2613             :       static void rebuildStaticDataMembers ( );
    2614             :       static void writeEasyStorageDataToFile (std::ostream& out);
    2615             :       static void readEasyStorageDataFromFile (std::istream& in);
    2616             :       static void writeStaticDataToFile (std::ostream& out );
    2617             :       static void readStaticDataFromFile (std::istream& in );
    2618             :       friend class SgDataStatementObject;
    2619             :    };
    2620             : /* #line 2621 "../../../src/frontend/SageIII//StorageClasses.h" */
    2621             : 
    2622             : 
    2623             : 
    2624             : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarStorageClassDeclatationMacros.macro" */
    2625             : /* 
    2626             :    JH (01/01/2006) ROSETTA generated class declarations for SgIncludeFileStorageClass 
    2627             :    used for the ast file IO. Do not chance by hand! 
    2628             : */
    2629         448 : class SgIncludeFileStorageClass  : public SgSupportStorageClass
    2630             :    {
    2631             : 
    2632             :     protected: 
    2633             : 
    2634             : 
    2635             : /* #line 2636 "../../../src/frontend/SageIII//StorageClasses.h" */
    2636             : 
    2637             :       SgNameStorageClass storageOf_filename;
    2638             :      unsigned long storageOf_source_file;
    2639             :        EasyStorage < SgIncludeFilePtrList > storageOf_include_file_list;
    2640             :       unsigned int storageOf_first_source_sequence_number;
    2641             :       unsigned int storageOf_last_source_sequence_number;
    2642             :       bool storageOf_isIncludedMoreThanOnce;
    2643             :       bool storageOf_isPrimaryUse;
    2644             :        EasyStorage < std::string > storageOf_file_hash;
    2645             :       SgNameStorageClass storageOf_name_used_in_include_directive;
    2646             :      unsigned long storageOf_source_file_of_translation_unit;
    2647             :      unsigned long storageOf_including_source_file;
    2648             :      unsigned long storageOf_parent_include_file;
    2649             :       bool storageOf_isSystemInclude;
    2650             :       bool storageOf_isPreinclude;
    2651             :       bool storageOf_requires_explict_path_for_unparsed_headers;
    2652             :       bool storageOf_can_be_supported_using_token_based_unparsing;
    2653             :       SgNameStorageClass storageOf_directory_prefix;
    2654             :       SgNameStorageClass storageOf_name_without_path;
    2655             :       SgNameStorageClass storageOf_applicationRootDirectory;
    2656             :       bool storageOf_will_be_unparsed;
    2657             :       bool storageOf_isRoseSystemInclude;
    2658             :       bool storageOf_from_system_include_dir;
    2659             :       bool storageOf_preinclude_macros_only;
    2660             :       bool storageOf_isApplicationFile;
    2661             :       bool storageOf_isRootSourceFile;
    2662             :      unsigned long storageOf_firstStatement;
    2663             :      unsigned long storageOf_lastStatement;
    2664             : 
    2665             : 
    2666             : /* #line 10 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarStorageClassDeclatationMacros.macro" */
    2667             : 
    2668             : 
    2669             :     public:
    2670             :       void pickOutIRNodeData ( SgIncludeFile* source );
    2671             :       static void arrangeStaticDataOfEasyStorageClassesInOneBlock ( );
    2672             :       static void deleteStaticDataOfEasyStorageClasses ( );
    2673             :       static void pickOutStaticDataMembers ( );
    2674             :       static void rebuildStaticDataMembers ( );
    2675             :       static void writeEasyStorageDataToFile (std::ostream& out);
    2676             :       static void readEasyStorageDataFromFile (std::istream& in);
    2677             :       static void writeStaticDataToFile (std::ostream& out );
    2678             :       static void readStaticDataFromFile (std::istream& in );
    2679             :       friend class SgIncludeFile;
    2680             :    };
    2681             : /* #line 2682 "../../../src/frontend/SageIII//StorageClasses.h" */
    2682             : 
    2683             : 
    2684             : 
    2685             : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarStorageClassDeclatationMacros.macro" */
    2686             : /* 
    2687             :    JH (01/01/2006) ROSETTA generated class declarations for SgDataStatementValueStorageClass 
    2688             :    used for the ast file IO. Do not chance by hand! 
    2689             : */
    2690             : class SgDataStatementValueStorageClass  : public SgSupportStorageClass
    2691             :    {
    2692             : 
    2693             :     protected: 
    2694             : 
    2695             : 
    2696             : /* #line 2697 "../../../src/frontend/SageIII//StorageClasses.h" */
    2697             : 
    2698             :       SgDataStatementValue::data_statement_value_enum storageOf_data_initialization_format;
    2699             :      unsigned long storageOf_initializer_list;
    2700             :      unsigned long storageOf_repeat_expression;
    2701             :      unsigned long storageOf_constant_expression;
    2702             : 
    2703             : 
    2704             : /* #line 10 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarStorageClassDeclatationMacros.macro" */
    2705             : 
    2706             : 
    2707             :     public:
    2708             :       void pickOutIRNodeData ( SgDataStatementValue* source );
    2709             :       static void arrangeStaticDataOfEasyStorageClassesInOneBlock ( );
    2710             :       static void deleteStaticDataOfEasyStorageClasses ( );
    2711             :       static void pickOutStaticDataMembers ( );
    2712             :       static void rebuildStaticDataMembers ( );
    2713             :       static void writeEasyStorageDataToFile (std::ostream& out);
    2714             :       static void readEasyStorageDataFromFile (std::istream& in);
    2715             :       static void writeStaticDataToFile (std::ostream& out );
    2716             :       static void readStaticDataFromFile (std::istream& in );
    2717             :       friend class SgDataStatementValue;
    2718             :    };
    2719             : /* #line 2720 "../../../src/frontend/SageIII//StorageClasses.h" */
    2720             : 
    2721             : 
    2722             : 
    2723             : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarStorageClassDeclatationMacros.macro" */
    2724             : /* 
    2725             :    JH (01/01/2006) ROSETTA generated class declarations for SgHeaderFileReportStorageClass 
    2726             :    used for the ast file IO. Do not chance by hand! 
    2727             : */
    2728           0 : class SgHeaderFileReportStorageClass  : public SgSupportStorageClass
    2729             :    {
    2730             : 
    2731             :     protected: 
    2732             : 
    2733             : 
    2734             : /* #line 2735 "../../../src/frontend/SageIII//StorageClasses.h" */
    2735             : 
    2736             :      unsigned long storageOf_source_file;
    2737             :        EasyStorage < SgSourceFilePtrList > storageOf_include_file_list;
    2738             : 
    2739             : 
    2740             : /* #line 10 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarStorageClassDeclatationMacros.macro" */
    2741             : 
    2742             : 
    2743             :     public:
    2744             :       void pickOutIRNodeData ( SgHeaderFileReport* source );
    2745             :       static void arrangeStaticDataOfEasyStorageClassesInOneBlock ( );
    2746             :       static void deleteStaticDataOfEasyStorageClasses ( );
    2747             :       static void pickOutStaticDataMembers ( );
    2748             :       static void rebuildStaticDataMembers ( );
    2749             :       static void writeEasyStorageDataToFile (std::ostream& out);
    2750             :       static void readEasyStorageDataFromFile (std::istream& in);
    2751             :       static void writeStaticDataToFile (std::ostream& out );
    2752             :       static void readStaticDataFromFile (std::istream& in );
    2753             :       friend class SgHeaderFileReport;
    2754             :    };
    2755             : /* #line 2756 "../../../src/frontend/SageIII//StorageClasses.h" */
    2756             : 
    2757             : 
    2758             : 
    2759             : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarStorageClassDeclatationMacros.macro" */
    2760             : /* 
    2761             :    JH (01/01/2006) ROSETTA generated class declarations for SgTypeStorageClass 
    2762             :    used for the ast file IO. Do not chance by hand! 
    2763             : */
    2764           0 : class SgTypeStorageClass  : public SgNodeStorageClass
    2765             :    {
    2766             : 
    2767             :     protected: 
    2768             : 
    2769             : 
    2770             : /* #line 2771 "../../../src/frontend/SageIII//StorageClasses.h" */
    2771             : 
    2772             :       bool storageOf_isCoArray;
    2773             :       int storageOf_substitutedForTemplateParam;
    2774             :      unsigned long storageOf_ref_to;
    2775             :      unsigned long storageOf_ptr_to;
    2776             :      unsigned long storageOf_modifiers;
    2777             :      unsigned long storageOf_typedefs;
    2778             :      unsigned long storageOf_rvalue_ref_to;
    2779             :      unsigned long storageOf_decltype_ref_to;
    2780             :      unsigned long storageOf_typeof_ref_to;
    2781             :      unsigned long storageOf_type_kind;
    2782             :        EasyStorage < AstAttributeMechanism* > storageOf_attributeMechanism;
    2783             : 
    2784             : 
    2785             : /* #line 10 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarStorageClassDeclatationMacros.macro" */
    2786             : 
    2787             : 
    2788             :     public:
    2789             :       void pickOutIRNodeData ( SgType* source );
    2790             :       static void arrangeStaticDataOfEasyStorageClassesInOneBlock ( );
    2791             :       static void deleteStaticDataOfEasyStorageClasses ( );
    2792             :       static void pickOutStaticDataMembers ( );
    2793             :       static void rebuildStaticDataMembers ( );
    2794             :       static void writeEasyStorageDataToFile (std::ostream& out);
    2795             :       static void readEasyStorageDataFromFile (std::istream& in);
    2796             :       static void writeStaticDataToFile (std::ostream& out );
    2797             :       static void readStaticDataFromFile (std::istream& in );
    2798             :       friend class SgType;
    2799             :    };
    2800             : /* #line 2801 "../../../src/frontend/SageIII//StorageClasses.h" */
    2801             : 
    2802             : 
    2803             : 
    2804             : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarStorageClassDeclatationMacros.macro" */
    2805             : /* 
    2806             :    JH (01/01/2006) ROSETTA generated class declarations for SgTypeUnknownStorageClass 
    2807             :    used for the ast file IO. Do not chance by hand! 
    2808             : */
    2809           2 : class SgTypeUnknownStorageClass  : public SgTypeStorageClass
    2810             :    {
    2811             : 
    2812             :     protected: 
    2813             : 
    2814             : 
    2815             : /* #line 2816 "../../../src/frontend/SageIII//StorageClasses.h" */
    2816             : 
    2817             :        EasyStorage < std::string > storageOf_type_name;
    2818             :       bool storageOf_has_type_name;
    2819             : 
    2820             : 
    2821             : /* #line 10 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarStorageClassDeclatationMacros.macro" */
    2822             : 
    2823             : 
    2824             :     public:
    2825             :       void pickOutIRNodeData ( SgTypeUnknown* source );
    2826             :       static void arrangeStaticDataOfEasyStorageClassesInOneBlock ( );
    2827             :       static void deleteStaticDataOfEasyStorageClasses ( );
    2828             :       static void pickOutStaticDataMembers ( );
    2829             :       static void rebuildStaticDataMembers ( );
    2830             :       static void writeEasyStorageDataToFile (std::ostream& out);
    2831             :       static void readEasyStorageDataFromFile (std::istream& in);
    2832             :       static void writeStaticDataToFile (std::ostream& out );
    2833             :       static void readStaticDataFromFile (std::istream& in );
    2834             :       friend class SgTypeUnknown;
    2835             :    };
    2836             : /* #line 2837 "../../../src/frontend/SageIII//StorageClasses.h" */
    2837             : 
    2838             : 
    2839             : 
    2840             : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarStorageClassDeclatationMacros.macro" */
    2841             : /* 
    2842             :    JH (01/01/2006) ROSETTA generated class declarations for SgTypeCharStorageClass 
    2843             :    used for the ast file IO. Do not chance by hand! 
    2844             : */
    2845           4 : class SgTypeCharStorageClass  : public SgTypeStorageClass
    2846             :    {
    2847             : 
    2848             :     protected: 
    2849             : 
    2850             : 
    2851             : /* #line 2852 "../../../src/frontend/SageIII//StorageClasses.h" */
    2852             : 
    2853             : 
    2854             : 
    2855             : /* #line 10 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarStorageClassDeclatationMacros.macro" */
    2856             : 
    2857             : 
    2858             :     public:
    2859             :       void pickOutIRNodeData ( SgTypeChar* source );
    2860             :       static void arrangeStaticDataOfEasyStorageClassesInOneBlock ( );
    2861             :       static void deleteStaticDataOfEasyStorageClasses ( );
    2862             :       static void pickOutStaticDataMembers ( );
    2863             :       static void rebuildStaticDataMembers ( );
    2864             :       static void writeEasyStorageDataToFile (std::ostream& out);
    2865             :       static void readEasyStorageDataFromFile (std::istream& in);
    2866             :       static void writeStaticDataToFile (std::ostream& out );
    2867             :       static void readStaticDataFromFile (std::istream& in );
    2868             :       friend class SgTypeChar;
    2869             :    };
    2870             : /* #line 2871 "../../../src/frontend/SageIII//StorageClasses.h" */
    2871             : 
    2872             : 
    2873             : 
    2874             : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarStorageClassDeclatationMacros.macro" */
    2875             : /* 
    2876             :    JH (01/01/2006) ROSETTA generated class declarations for SgTypeSignedCharStorageClass 
    2877             :    used for the ast file IO. Do not chance by hand! 
    2878             : */
    2879           4 : class SgTypeSignedCharStorageClass  : public SgTypeStorageClass
    2880             :    {
    2881             : 
    2882             :     protected: 
    2883             : 
    2884             : 
    2885             : /* #line 2886 "../../../src/frontend/SageIII//StorageClasses.h" */
    2886             : 
    2887             : 
    2888             : 
    2889             : /* #line 10 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarStorageClassDeclatationMacros.macro" */
    2890             : 
    2891             : 
    2892             :     public:
    2893             :       void pickOutIRNodeData ( SgTypeSignedChar* source );
    2894             :       static void arrangeStaticDataOfEasyStorageClassesInOneBlock ( );
    2895             :       static void deleteStaticDataOfEasyStorageClasses ( );
    2896             :       static void pickOutStaticDataMembers ( );
    2897             :       static void rebuildStaticDataMembers ( );
    2898             :       static void writeEasyStorageDataToFile (std::ostream& out);
    2899             :       static void readEasyStorageDataFromFile (std::istream& in);
    2900             :       static void writeStaticDataToFile (std::ostream& out );
    2901             :       static void readStaticDataFromFile (std::istream& in );
    2902             :       friend class SgTypeSignedChar;
    2903             :    };
    2904             : /* #line 2905 "../../../src/frontend/SageIII//StorageClasses.h" */
    2905             : 
    2906             : 
    2907             : 
    2908             : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarStorageClassDeclatationMacros.macro" */
    2909             : /* 
    2910             :    JH (01/01/2006) ROSETTA generated class declarations for SgTypeUnsignedCharStorageClass 
    2911             :    used for the ast file IO. Do not chance by hand! 
    2912             : */
    2913           4 : class SgTypeUnsignedCharStorageClass  : public SgTypeStorageClass
    2914             :    {
    2915             : 
    2916             :     protected: 
    2917             : 
    2918             : 
    2919             : /* #line 2920 "../../../src/frontend/SageIII//StorageClasses.h" */
    2920             : 
    2921             : 
    2922             : 
    2923             : /* #line 10 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarStorageClassDeclatationMacros.macro" */
    2924             : 
    2925             : 
    2926             :     public:
    2927             :       void pickOutIRNodeData ( SgTypeUnsignedChar* source );
    2928             :       static void arrangeStaticDataOfEasyStorageClassesInOneBlock ( );
    2929             :       static void deleteStaticDataOfEasyStorageClasses ( );
    2930             :       static void pickOutStaticDataMembers ( );
    2931             :       static void rebuildStaticDataMembers ( );
    2932             :       static void writeEasyStorageDataToFile (std::ostream& out);
    2933             :       static void readEasyStorageDataFromFile (std::istream& in);
    2934             :       static void writeStaticDataToFile (std::ostream& out );
    2935             :       static void readStaticDataFromFile (std::istream& in );
    2936             :       friend class SgTypeUnsignedChar;
    2937             :    };
    2938             : /* #line 2939 "../../../src/frontend/SageIII//StorageClasses.h" */
    2939             : 
    2940             : 
    2941             : 
    2942             : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarStorageClassDeclatationMacros.macro" */
    2943             : /* 
    2944             :    JH (01/01/2006) ROSETTA generated class declarations for SgTypeShortStorageClass 
    2945             :    used for the ast file IO. Do not chance by hand! 
    2946             : */
    2947           4 : class SgTypeShortStorageClass  : public SgTypeStorageClass
    2948             :    {
    2949             : 
    2950             :     protected: 
    2951             : 
    2952             : 
    2953             : /* #line 2954 "../../../src/frontend/SageIII//StorageClasses.h" */
    2954             : 
    2955             : 
    2956             : 
    2957             : /* #line 10 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarStorageClassDeclatationMacros.macro" */
    2958             : 
    2959             : 
    2960             :     public:
    2961             :       void pickOutIRNodeData ( SgTypeShort* source );
    2962             :       static void arrangeStaticDataOfEasyStorageClassesInOneBlock ( );
    2963             :       static void deleteStaticDataOfEasyStorageClasses ( );
    2964             :       static void pickOutStaticDataMembers ( );
    2965             :       static void rebuildStaticDataMembers ( );
    2966             :       static void writeEasyStorageDataToFile (std::ostream& out);
    2967             :       static void readEasyStorageDataFromFile (std::istream& in);
    2968             :       static void writeStaticDataToFile (std::ostream& out );
    2969             :       static void readStaticDataFromFile (std::istream& in );
    2970             :       friend class SgTypeShort;
    2971             :    };
    2972             : /* #line 2973 "../../../src/frontend/SageIII//StorageClasses.h" */
    2973             : 
    2974             : 
    2975             : 
    2976             : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarStorageClassDeclatationMacros.macro" */
    2977             : /* 
    2978             :    JH (01/01/2006) ROSETTA generated class declarations for SgTypeSignedShortStorageClass 
    2979             :    used for the ast file IO. Do not chance by hand! 
    2980             : */
    2981           4 : class SgTypeSignedShortStorageClass  : public SgTypeStorageClass
    2982             :    {
    2983             : 
    2984             :     protected: 
    2985             : 
    2986             : 
    2987             : /* #line 2988 "../../../src/frontend/SageIII//StorageClasses.h" */
    2988             : 
    2989             : 
    2990             : 
    2991             : /* #line 10 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarStorageClassDeclatationMacros.macro" */
    2992             : 
    2993             : 
    2994             :     public:
    2995             :       void pickOutIRNodeData ( SgTypeSignedShort* source );
    2996             :       static void arrangeStaticDataOfEasyStorageClassesInOneBlock ( );
    2997             :       static void deleteStaticDataOfEasyStorageClasses ( );
    2998             :       static void pickOutStaticDataMembers ( );
    2999             :       static void rebuildStaticDataMembers ( );
    3000             :       static void writeEasyStorageDataToFile (std::ostream& out);
    3001             :       static void readEasyStorageDataFromFile (std::istream& in);
    3002             :       static void writeStaticDataToFile (std::ostream& out );
    3003             :       static void readStaticDataFromFile (std::istream& in );
    3004             :       friend class SgTypeSignedShort;
    3005             :    };
    3006             : /* #line 3007 "../../../src/frontend/SageIII//StorageClasses.h" */
    3007             : 
    3008             : 
    3009             : 
    3010             : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarStorageClassDeclatationMacros.macro" */
    3011             : /* 
    3012             :    JH (01/01/2006) ROSETTA generated class declarations for SgTypeUnsignedShortStorageClass 
    3013             :    used for the ast file IO. Do not chance by hand! 
    3014             : */
    3015           4 : class SgTypeUnsignedShortStorageClass  : public SgTypeStorageClass
    3016             :    {
    3017             : 
    3018             :     protected: 
    3019             : 
    3020             : 
    3021             : /* #line 3022 "../../../src/frontend/SageIII//StorageClasses.h" */
    3022             : 
    3023             : 
    3024             : 
    3025             : /* #line 10 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarStorageClassDeclatationMacros.macro" */
    3026             : 
    3027             : 
    3028             :     public:
    3029             :       void pickOutIRNodeData ( SgTypeUnsignedShort* source );
    3030             :       static void arrangeStaticDataOfEasyStorageClassesInOneBlock ( );
    3031             :       static void deleteStaticDataOfEasyStorageClasses ( );
    3032             :       static void pickOutStaticDataMembers ( );
    3033             :       static void rebuildStaticDataMembers ( );
    3034             :       static void writeEasyStorageDataToFile (std::ostream& out);
    3035             :       static void readEasyStorageDataFromFile (std::istream& in);
    3036             :       static void writeStaticDataToFile (std::ostream& out );
    3037             :       static void readStaticDataFromFile (std::istream& in );
    3038             :       friend class SgTypeUnsignedShort;
    3039             :    };
    3040             : /* #line 3041 "../../../src/frontend/SageIII//StorageClasses.h" */
    3041             : 
    3042             : 
    3043             : 
    3044             : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarStorageClassDeclatationMacros.macro" */
    3045             : /* 
    3046             :    JH (01/01/2006) ROSETTA generated class declarations for SgTypeIntStorageClass 
    3047             :    used for the ast file IO. Do not chance by hand! 
    3048             : */
    3049           4 : class SgTypeIntStorageClass  : public SgTypeStorageClass
    3050             :    {
    3051             : 
    3052             :     protected: 
    3053             : 
    3054             : 
    3055             : /* #line 3056 "../../../src/frontend/SageIII//StorageClasses.h" */
    3056             : 
    3057             :       int storageOf_field_size;
    3058             : 
    3059             : 
    3060             : /* #line 10 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarStorageClassDeclatationMacros.macro" */
    3061             : 
    3062             : 
    3063             :     public:
    3064             :       void pickOutIRNodeData ( SgTypeInt* source );
    3065             :       static void arrangeStaticDataOfEasyStorageClassesInOneBlock ( );
    3066             :       static void deleteStaticDataOfEasyStorageClasses ( );
    3067             :       static void pickOutStaticDataMembers ( );
    3068             :       static void rebuildStaticDataMembers ( );
    3069             :       static void writeEasyStorageDataToFile (std::ostream& out);
    3070             :       static void readEasyStorageDataFromFile (std::istream& in);
    3071             :       static void writeStaticDataToFile (std::ostream& out );
    3072             :       static void readStaticDataFromFile (std::istream& in );
    3073             :       friend class SgTypeInt;
    3074             :    };
    3075             : /* #line 3076 "../../../src/frontend/SageIII//StorageClasses.h" */
    3076             : 
    3077             : 
    3078             : 
    3079             : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarStorageClassDeclatationMacros.macro" */
    3080             : /* 
    3081             :    JH (01/01/2006) ROSETTA generated class declarations for SgTypeSignedIntStorageClass 
    3082             :    used for the ast file IO. Do not chance by hand! 
    3083             : */
    3084           4 : class SgTypeSignedIntStorageClass  : public SgTypeStorageClass
    3085             :    {
    3086             : 
    3087             :     protected: 
    3088             : 
    3089             : 
    3090             : /* #line 3091 "../../../src/frontend/SageIII//StorageClasses.h" */
    3091             : 
    3092             : 
    3093             : 
    3094             : /* #line 10 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarStorageClassDeclatationMacros.macro" */
    3095             : 
    3096             : 
    3097             :     public:
    3098             :       void pickOutIRNodeData ( SgTypeSignedInt* source );
    3099             :       static void arrangeStaticDataOfEasyStorageClassesInOneBlock ( );
    3100             :       static void deleteStaticDataOfEasyStorageClasses ( );
    3101             :       static void pickOutStaticDataMembers ( );
    3102             :       static void rebuildStaticDataMembers ( );
    3103             :       static void writeEasyStorageDataToFile (std::ostream& out);
    3104             :       static void readEasyStorageDataFromFile (std::istream& in);
    3105             :       static void writeStaticDataToFile (std::ostream& out );
    3106             :       static void readStaticDataFromFile (std::istream& in );
    3107             :       friend class SgTypeSignedInt;
    3108             :    };
    3109             : /* #line 3110 "../../../src/frontend/SageIII//StorageClasses.h" */
    3110             : 
    3111             : 
    3112             : 
    3113             : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarStorageClassDeclatationMacros.macro" */
    3114             : /* 
    3115             :    JH (01/01/2006) ROSETTA generated class declarations for SgTypeUnsignedIntStorageClass 
    3116             :    used for the ast file IO. Do not chance by hand! 
    3117             : */
    3118           4 : class SgTypeUnsignedIntStorageClass  : public SgTypeStorageClass
    3119             :    {
    3120             : 
    3121             :     protected: 
    3122             : 
    3123             : 
    3124             : /* #line 3125 "../../../src/frontend/SageIII//StorageClasses.h" */
    3125             : 
    3126             : 
    3127             : 
    3128             : /* #line 10 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarStorageClassDeclatationMacros.macro" */
    3129             : 
    3130             : 
    3131             :     public:
    3132             :       void pickOutIRNodeData ( SgTypeUnsignedInt* source );
    3133             :       static void arrangeStaticDataOfEasyStorageClassesInOneBlock ( );
    3134             :       static void deleteStaticDataOfEasyStorageClasses ( );
    3135             :       static void pickOutStaticDataMembers ( );
    3136             :       static void rebuildStaticDataMembers ( );
    3137             :       static void writeEasyStorageDataToFile (std::ostream& out);
    3138             :       static void readEasyStorageDataFromFile (std::istream& in);
    3139             :       static void writeStaticDataToFile (std::ostream& out );
    3140             :       static void readStaticDataFromFile (std::istream& in );
    3141             :       friend class SgTypeUnsignedInt;
    3142             :    };
    3143             : /* #line 3144 "../../../src/frontend/SageIII//StorageClasses.h" */
    3144             : 
    3145             : 
    3146             : 
    3147             : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarStorageClassDeclatationMacros.macro" */
    3148             : /* 
    3149             :    JH (01/01/2006) ROSETTA generated class declarations for SgTypeLongStorageClass 
    3150             :    used for the ast file IO. Do not chance by hand! 
    3151             : */
    3152           4 : class SgTypeLongStorageClass  : public SgTypeStorageClass
    3153             :    {
    3154             : 
    3155             :     protected: 
    3156             : 
    3157             : 
    3158             : /* #line 3159 "../../../src/frontend/SageIII//StorageClasses.h" */
    3159             : 
    3160             : 
    3161             : 
    3162             : /* #line 10 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarStorageClassDeclatationMacros.macro" */
    3163             : 
    3164             : 
    3165             :     public:
    3166             :       void pickOutIRNodeData ( SgTypeLong* source );
    3167             :       static void arrangeStaticDataOfEasyStorageClassesInOneBlock ( );
    3168             :       static void deleteStaticDataOfEasyStorageClasses ( );
    3169             :       static void pickOutStaticDataMembers ( );
    3170             :       static void rebuildStaticDataMembers ( );
    3171             :       static void writeEasyStorageDataToFile (std::ostream& out);
    3172             :       static void readEasyStorageDataFromFile (std::istream& in);
    3173             :       static void writeStaticDataToFile (std::ostream& out );
    3174             :       static void readStaticDataFromFile (std::istream& in );
    3175             :       friend class SgTypeLong;
    3176             :    };
    3177             : /* #line 3178 "../../../src/frontend/SageIII//StorageClasses.h" */
    3178             : 
    3179             : 
    3180             : 
    3181             : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarStorageClassDeclatationMacros.macro" */
    3182             : /* 
    3183             :    JH (01/01/2006) ROSETTA generated class declarations for SgTypeSignedLongStorageClass 
    3184             :    used for the ast file IO. Do not chance by hand! 
    3185             : */
    3186           4 : class SgTypeSignedLongStorageClass  : public SgTypeStorageClass
    3187             :    {
    3188             : 
    3189             :     protected: 
    3190             : 
    3191             : 
    3192             : /* #line 3193 "../../../src/frontend/SageIII//StorageClasses.h" */
    3193             : 
    3194             : 
    3195             : 
    3196             : /* #line 10 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarStorageClassDeclatationMacros.macro" */
    3197             : 
    3198             : 
    3199             :     public:
    3200             :       void pickOutIRNodeData ( SgTypeSignedLong* source );
    3201             :       static void arrangeStaticDataOfEasyStorageClassesInOneBlock ( );
    3202             :       static void deleteStaticDataOfEasyStorageClasses ( );
    3203             :       static void pickOutStaticDataMembers ( );
    3204             :       static void rebuildStaticDataMembers ( );
    3205             :       static void writeEasyStorageDataToFile (std::ostream& out);
    3206             :       static void readEasyStorageDataFromFile (std::istream& in);
    3207             :       static void writeStaticDataToFile (std::ostream& out );
    3208             :       static void readStaticDataFromFile (std::istream& in );
    3209             :       friend class SgTypeSignedLong;
    3210             :    };
    3211             : /* #line 3212 "../../../src/frontend/SageIII//StorageClasses.h" */
    3212             : 
    3213             : 
    3214             : 
    3215             : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarStorageClassDeclatationMacros.macro" */
    3216             : /* 
    3217             :    JH (01/01/2006) ROSETTA generated class declarations for SgTypeUnsignedLongStorageClass 
    3218             :    used for the ast file IO. Do not chance by hand! 
    3219             : */
    3220           4 : class SgTypeUnsignedLongStorageClass  : public SgTypeStorageClass
    3221             :    {
    3222             : 
    3223             :     protected: 
    3224             : 
    3225             : 
    3226             : /* #line 3227 "../../../src/frontend/SageIII//StorageClasses.h" */
    3227             : 
    3228             : 
    3229             : 
    3230             : /* #line 10 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarStorageClassDeclatationMacros.macro" */
    3231             : 
    3232             : 
    3233             :     public:
    3234             :       void pickOutIRNodeData ( SgTypeUnsignedLong* source );
    3235             :       static void arrangeStaticDataOfEasyStorageClassesInOneBlock ( );
    3236             :       static void deleteStaticDataOfEasyStorageClasses ( );
    3237             :       static void pickOutStaticDataMembers ( );
    3238             :       static void rebuildStaticDataMembers ( );
    3239             :       static void writeEasyStorageDataToFile (std::ostream& out);
    3240             :       static void readEasyStorageDataFromFile (std::istream& in);
    3241             :       static void writeStaticDataToFile (std::ostream& out );
    3242             :       static void readStaticDataFromFile (std::istream& in );
    3243             :       friend class SgTypeUnsignedLong;
    3244             :    };
    3245             : /* #line 3246 "../../../src/frontend/SageIII//StorageClasses.h" */
    3246             : 
    3247             : 
    3248             : 
    3249             : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarStorageClassDeclatationMacros.macro" */
    3250             : /* 
    3251             :    JH (01/01/2006) ROSETTA generated class declarations for SgTypeVoidStorageClass 
    3252             :    used for the ast file IO. Do not chance by hand! 
    3253             : */
    3254           5 : class SgTypeVoidStorageClass  : public SgTypeStorageClass
    3255             :    {
    3256             : 
    3257             :     protected: 
    3258             : 
    3259             : 
    3260             : /* #line 3261 "../../../src/frontend/SageIII//StorageClasses.h" */
    3261             : 
    3262             : 
    3263             : 
    3264             : /* #line 10 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarStorageClassDeclatationMacros.macro" */
    3265             : 
    3266             : 
    3267             :     public:
    3268             :       void pickOutIRNodeData ( SgTypeVoid* source );
    3269             :       static void arrangeStaticDataOfEasyStorageClassesInOneBlock ( );
    3270             :       static void deleteStaticDataOfEasyStorageClasses ( );
    3271             :       static void pickOutStaticDataMembers ( );
    3272             :       static void rebuildStaticDataMembers ( );
    3273             :       static void writeEasyStorageDataToFile (std::ostream& out);
    3274             :       static void readEasyStorageDataFromFile (std::istream& in);
    3275             :       static void writeStaticDataToFile (std::ostream& out );
    3276             :       static void readStaticDataFromFile (std::istream& in );
    3277             :       friend class SgTypeVoid;
    3278             :    };
    3279             : /* #line 3280 "../../../src/frontend/SageIII//StorageClasses.h" */
    3280             : 
    3281             : 
    3282             : 
    3283             : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarStorageClassDeclatationMacros.macro" */
    3284             : /* 
    3285             :    JH (01/01/2006) ROSETTA generated class declarations for SgTypeGlobalVoidStorageClass 
    3286             :    used for the ast file IO. Do not chance by hand! 
    3287             : */
    3288           0 : class SgTypeGlobalVoidStorageClass  : public SgTypeStorageClass
    3289             :    {
    3290             : 
    3291             :     protected: 
    3292             : 
    3293             : 
    3294             : /* #line 3295 "../../../src/frontend/SageIII//StorageClasses.h" */
    3295             : 
    3296             : 
    3297             : 
    3298             : /* #line 10 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarStorageClassDeclatationMacros.macro" */
    3299             : 
    3300             : 
    3301             :     public:
    3302             :       void pickOutIRNodeData ( SgTypeGlobalVoid* source );
    3303             :       static void arrangeStaticDataOfEasyStorageClassesInOneBlock ( );
    3304             :       static void deleteStaticDataOfEasyStorageClasses ( );
    3305             :       static void pickOutStaticDataMembers ( );
    3306             :       static void rebuildStaticDataMembers ( );
    3307             :       static void writeEasyStorageDataToFile (std::ostream& out);
    3308             :       static void readEasyStorageDataFromFile (std::istream& in);
    3309             :       static void writeStaticDataToFile (std::ostream& out );
    3310             :       static void readStaticDataFromFile (std::istream& in );
    3311             :       friend class SgTypeGlobalVoid;
    3312             :    };
    3313             : /* #line 3314 "../../../src/frontend/SageIII//StorageClasses.h" */
    3314             : 
    3315             : 
    3316             : 
    3317             : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarStorageClassDeclatationMacros.macro" */
    3318             : /* 
    3319             :    JH (01/01/2006) ROSETTA generated class declarations for SgTypeWcharStorageClass 
    3320             :    used for the ast file IO. Do not chance by hand! 
    3321             : */
    3322           2 : class SgTypeWcharStorageClass  : public SgTypeStorageClass
    3323             :    {
    3324             : 
    3325             :     protected: 
    3326             : 
    3327             : 
    3328             : /* #line 3329 "../../../src/frontend/SageIII//StorageClasses.h" */
    3329             : 
    3330             : 
    3331             : 
    3332             : /* #line 10 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarStorageClassDeclatationMacros.macro" */
    3333             : 
    3334             : 
    3335             :     public:
    3336             :       void pickOutIRNodeData ( SgTypeWchar* source );
    3337             :       static void arrangeStaticDataOfEasyStorageClassesInOneBlock ( );
    3338             :       static void deleteStaticDataOfEasyStorageClasses ( );
    3339             :       static void pickOutStaticDataMembers ( );
    3340             :       static void rebuildStaticDataMembers ( );
    3341             :       static void writeEasyStorageDataToFile (std::ostream& out);
    3342             :       static void readEasyStorageDataFromFile (std::istream& in);
    3343             :       static void writeStaticDataToFile (std::ostream& out );
    3344             :       static void readStaticDataFromFile (std::istream& in );
    3345             :       friend class SgTypeWchar;
    3346             :    };
    3347             : /* #line 3348 "../../../src/frontend/SageIII//StorageClasses.h" */
    3348             : 
    3349             : 
    3350             : 
    3351             : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarStorageClassDeclatationMacros.macro" */
    3352             : /* 
    3353             :    JH (01/01/2006) ROSETTA generated class declarations for SgTypeFloatStorageClass 
    3354             :    used for the ast file IO. Do not chance by hand! 
    3355             : */
    3356           4 : class SgTypeFloatStorageClass  : public SgTypeStorageClass
    3357             :    {
    3358             : 
    3359             :     protected: 
    3360             : 
    3361             : 
    3362             : /* #line 3363 "../../../src/frontend/SageIII//StorageClasses.h" */
    3363             : 
    3364             : 
    3365             : 
    3366             : /* #line 10 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarStorageClassDeclatationMacros.macro" */
    3367             : 
    3368             : 
    3369             :     public:
    3370             :       void pickOutIRNodeData ( SgTypeFloat* source );
    3371             :       static void arrangeStaticDataOfEasyStorageClassesInOneBlock ( );
    3372             :       static void deleteStaticDataOfEasyStorageClasses ( );
    3373             :       static void pickOutStaticDataMembers ( );
    3374             :       static void rebuildStaticDataMembers ( );
    3375             :       static void writeEasyStorageDataToFile (std::ostream& out);
    3376             :       static void readEasyStorageDataFromFile (std::istream& in);
    3377             :       static void writeStaticDataToFile (std::ostream& out );
    3378             :       static void readStaticDataFromFile (std::istream& in );
    3379             :       friend class SgTypeFloat;
    3380             :    };
    3381             : /* #line 3382 "../../../src/frontend/SageIII//StorageClasses.h" */
    3382             : 
    3383             : 
    3384             : 
    3385             : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarStorageClassDeclatationMacros.macro" */
    3386             : /* 
    3387             :    JH (01/01/2006) ROSETTA generated class declarations for SgTypeDoubleStorageClass 
    3388             :    used for the ast file IO. Do not chance by hand! 
    3389             : */
    3390           4 : class SgTypeDoubleStorageClass  : public SgTypeStorageClass
    3391             :    {
    3392             : 
    3393             :     protected: 
    3394             : 
    3395             : 
    3396             : /* #line 3397 "../../../src/frontend/SageIII//StorageClasses.h" */
    3397             : 
    3398             : 
    3399             : 
    3400             : /* #line 10 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarStorageClassDeclatationMacros.macro" */
    3401             : 
    3402             : 
    3403             :     public:
    3404             :       void pickOutIRNodeData ( SgTypeDouble* source );
    3405             :       static void arrangeStaticDataOfEasyStorageClassesInOneBlock ( );
    3406             :       static void deleteStaticDataOfEasyStorageClasses ( );
    3407             :       static void pickOutStaticDataMembers ( );
    3408             :       static void rebuildStaticDataMembers ( );
    3409             :       static void writeEasyStorageDataToFile (std::ostream& out);
    3410             :       static void readEasyStorageDataFromFile (std::istream& in);
    3411             :       static void writeStaticDataToFile (std::ostream& out );
    3412             :       static void readStaticDataFromFile (std::istream& in );
    3413             :       friend class SgTypeDouble;
    3414             :    };
    3415             : /* #line 3416 "../../../src/frontend/SageIII//StorageClasses.h" */
    3416             : 
    3417             : 
    3418             : 
    3419             : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarStorageClassDeclatationMacros.macro" */
    3420             : /* 
    3421             :    JH (01/01/2006) ROSETTA generated class declarations for SgTypeLongLongStorageClass 
    3422             :    used for the ast file IO. Do not chance by hand! 
    3423             : */
    3424           4 : class SgTypeLongLongStorageClass  : public SgTypeStorageClass
    3425             :    {
    3426             : 
    3427             :     protected: 
    3428             : 
    3429             : 
    3430             : /* #line 3431 "../../../src/frontend/SageIII//StorageClasses.h" */
    3431             : 
    3432             : 
    3433             : 
    3434             : /* #line 10 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarStorageClassDeclatationMacros.macro" */
    3435             : 
    3436             : 
    3437             :     public:
    3438             :       void pickOutIRNodeData ( SgTypeLongLong* source );
    3439             :       static void arrangeStaticDataOfEasyStorageClassesInOneBlock ( );
    3440             :       static void deleteStaticDataOfEasyStorageClasses ( );
    3441             :       static void pickOutStaticDataMembers ( );
    3442             :       static void rebuildStaticDataMembers ( );
    3443             :       static void writeEasyStorageDataToFile (std::ostream& out);
    3444             :       static void readEasyStorageDataFromFile (std::istream& in);
    3445             :       static void writeStaticDataToFile (std::ostream& out );
    3446             :       static void readStaticDataFromFile (std::istream& in );
    3447             :       friend class SgTypeLongLong;
    3448             :    };
    3449             : /* #line 3450 "../../../src/frontend/SageIII//StorageClasses.h" */
    3450             : 
    3451             : 
    3452             : 
    3453             : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarStorageClassDeclatationMacros.macro" */
    3454             : /* 
    3455             :    JH (01/01/2006) ROSETTA generated class declarations for SgTypeSignedLongLongStorageClass 
    3456             :    used for the ast file IO. Do not chance by hand! 
    3457             : */
    3458           2 : class SgTypeSignedLongLongStorageClass  : public SgTypeStorageClass
    3459             :    {
    3460             : 
    3461             :     protected: 
    3462             : 
    3463             : 
    3464             : /* #line 3465 "../../../src/frontend/SageIII//StorageClasses.h" */
    3465             : 
    3466             : 
    3467             : 
    3468             : /* #line 10 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarStorageClassDeclatationMacros.macro" */
    3469             : 
    3470             : 
    3471             :     public:
    3472             :       void pickOutIRNodeData ( SgTypeSignedLongLong* source );
    3473             :       static void arrangeStaticDataOfEasyStorageClassesInOneBlock ( );
    3474             :       static void deleteStaticDataOfEasyStorageClasses ( );
    3475             :       static void pickOutStaticDataMembers ( );
    3476             :       static void rebuildStaticDataMembers ( );
    3477             :       static void writeEasyStorageDataToFile (std::ostream& out);
    3478             :       static void readEasyStorageDataFromFile (std::istream& in);
    3479             :       static void writeStaticDataToFile (std::ostream& out );
    3480             :       static void readStaticDataFromFile (std::istream& in );
    3481             :       friend class SgTypeSignedLongLong;
    3482             :    };
    3483             : /* #line 3484 "../../../src/frontend/SageIII//StorageClasses.h" */
    3484             : 
    3485             : 
    3486             : 
    3487             : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarStorageClassDeclatationMacros.macro" */
    3488             : /* 
    3489             :    JH (01/01/2006) ROSETTA generated class declarations for SgTypeUnsignedLongLongStorageClass 
    3490             :    used for the ast file IO. Do not chance by hand! 
    3491             : */
    3492           4 : class SgTypeUnsignedLongLongStorageClass  : public SgTypeStorageClass
    3493             :    {
    3494             : 
    3495             :     protected: 
    3496             : 
    3497             : 
    3498             : /* #line 3499 "../../../src/frontend/SageIII//StorageClasses.h" */
    3499             : 
    3500             : 
    3501             : 
    3502             : /* #line 10 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarStorageClassDeclatationMacros.macro" */
    3503             : 
    3504             : 
    3505             :     public:
    3506             :       void pickOutIRNodeData ( SgTypeUnsignedLongLong* source );
    3507             :       static void arrangeStaticDataOfEasyStorageClassesInOneBlock ( );
    3508             :       static void deleteStaticDataOfEasyStorageClasses ( );
    3509             :       static void pickOutStaticDataMembers ( );
    3510             :       static void rebuildStaticDataMembers ( );
    3511             :       static void writeEasyStorageDataToFile (std::ostream& out);
    3512             :       static void readEasyStorageDataFromFile (std::istream& in);
    3513             :       static void writeStaticDataToFile (std::ostream& out );
    3514             :       static void readStaticDataFromFile (std::istream& in );
    3515             :       friend class SgTypeUnsignedLongLong;
    3516             :    };
    3517             : /* #line 3518 "../../../src/frontend/SageIII//StorageClasses.h" */
    3518             : 
    3519             : 
    3520             : 
    3521             : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarStorageClassDeclatationMacros.macro" */
    3522             : /* 
    3523             :    JH (01/01/2006) ROSETTA generated class declarations for SgTypeSigned128bitIntegerStorageClass 
    3524             :    used for the ast file IO. Do not chance by hand! 
    3525             : */
    3526           2 : class SgTypeSigned128bitIntegerStorageClass  : public SgTypeStorageClass
    3527             :    {
    3528             : 
    3529             :     protected: 
    3530             : 
    3531             : 
    3532             : /* #line 3533 "../../../src/frontend/SageIII//StorageClasses.h" */
    3533             : 
    3534             : 
    3535             : 
    3536             : /* #line 10 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarStorageClassDeclatationMacros.macro" */
    3537             : 
    3538             : 
    3539             :     public:
    3540             :       void pickOutIRNodeData ( SgTypeSigned128bitInteger* source );
    3541             :       static void arrangeStaticDataOfEasyStorageClassesInOneBlock ( );
    3542             :       static void deleteStaticDataOfEasyStorageClasses ( );
    3543             :       static void pickOutStaticDataMembers ( );
    3544             :       static void rebuildStaticDataMembers ( );
    3545             :       static void writeEasyStorageDataToFile (std::ostream& out);
    3546             :       static void readEasyStorageDataFromFile (std::istream& in);
    3547             :       static void writeStaticDataToFile (std::ostream& out );
    3548             :       static void readStaticDataFromFile (std::istream& in );
    3549             :       friend class SgTypeSigned128bitInteger;
    3550             :    };
    3551             : /* #line 3552 "../../../src/frontend/SageIII//StorageClasses.h" */
    3552             : 
    3553             : 
    3554             : 
    3555             : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarStorageClassDeclatationMacros.macro" */
    3556             : /* 
    3557             :    JH (01/01/2006) ROSETTA generated class declarations for SgTypeUnsigned128bitIntegerStorageClass 
    3558             :    used for the ast file IO. Do not chance by hand! 
    3559             : */
    3560           2 : class SgTypeUnsigned128bitIntegerStorageClass  : public SgTypeStorageClass
    3561             :    {
    3562             : 
    3563             :     protected: 
    3564             : 
    3565             : 
    3566             : /* #line 3567 "../../../src/frontend/SageIII//StorageClasses.h" */
    3567             : 
    3568             : 
    3569             : 
    3570             : /* #line 10 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarStorageClassDeclatationMacros.macro" */
    3571             : 
    3572             : 
    3573             :     public:
    3574             :       void pickOutIRNodeData ( SgTypeUnsigned128bitInteger* source );
    3575             :       static void arrangeStaticDataOfEasyStorageClassesInOneBlock ( );
    3576             :       static void deleteStaticDataOfEasyStorageClasses ( );
    3577             :       static void pickOutStaticDataMembers ( );
    3578             :       static void rebuildStaticDataMembers ( );
    3579             :       static void writeEasyStorageDataToFile (std::ostream& out);
    3580             :       static void readEasyStorageDataFromFile (std::istream& in);
    3581             :       static void writeStaticDataToFile (std::ostream& out );
    3582             :       static void readStaticDataFromFile (std::istream& in );
    3583             :       friend class SgTypeUnsigned128bitInteger;
    3584             :    };
    3585             : /* #line 3586 "../../../src/frontend/SageIII//StorageClasses.h" */
    3586             : 
    3587             : 
    3588             : 
    3589             : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarStorageClassDeclatationMacros.macro" */
    3590             : /* 
    3591             :    JH (01/01/2006) ROSETTA generated class declarations for SgTypeFloat80StorageClass 
    3592             :    used for the ast file IO. Do not chance by hand! 
    3593             : */
    3594           0 : class SgTypeFloat80StorageClass  : public SgTypeStorageClass
    3595             :    {
    3596             : 
    3597             :     protected: 
    3598             : 
    3599             : 
    3600             : /* #line 3601 "../../../src/frontend/SageIII//StorageClasses.h" */
    3601             : 
    3602             : 
    3603             : 
    3604             : /* #line 10 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarStorageClassDeclatationMacros.macro" */
    3605             : 
    3606             : 
    3607             :     public:
    3608             :       void pickOutIRNodeData ( SgTypeFloat80* source );
    3609             :       static void arrangeStaticDataOfEasyStorageClassesInOneBlock ( );
    3610             :       static void deleteStaticDataOfEasyStorageClasses ( );
    3611             :       static void pickOutStaticDataMembers ( );
    3612             :       static void rebuildStaticDataMembers ( );
    3613             :       static void writeEasyStorageDataToFile (std::ostream& out);
    3614             :       static void readEasyStorageDataFromFile (std::istream& in);
    3615             :       static void writeStaticDataToFile (std::ostream& out );
    3616             :       static void readStaticDataFromFile (std::istream& in );
    3617             :       friend class SgTypeFloat80;
    3618             :    };
    3619             : /* #line 3620 "../../../src/frontend/SageIII//StorageClasses.h" */
    3620             : 
    3621             : 
    3622             : 
    3623             : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarStorageClassDeclatationMacros.macro" */
    3624             : /* 
    3625             :    JH (01/01/2006) ROSETTA generated class declarations for SgTypeLongDoubleStorageClass 
    3626             :    used for the ast file IO. Do not chance by hand! 
    3627             : */
    3628           4 : class SgTypeLongDoubleStorageClass  : public SgTypeStorageClass
    3629             :    {
    3630             : 
    3631             :     protected: 
    3632             : 
    3633             : 
    3634             : /* #line 3635 "../../../src/frontend/SageIII//StorageClasses.h" */
    3635             : 
    3636             : 
    3637             : 
    3638             : /* #line 10 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarStorageClassDeclatationMacros.macro" */
    3639             : 
    3640             : 
    3641             :     public:
    3642             :       void pickOutIRNodeData ( SgTypeLongDouble* source );
    3643             :       static void arrangeStaticDataOfEasyStorageClassesInOneBlock ( );
    3644             :       static void deleteStaticDataOfEasyStorageClasses ( );
    3645             :       static void pickOutStaticDataMembers ( );
    3646             :       static void rebuildStaticDataMembers ( );
    3647             :       static void writeEasyStorageDataToFile (std::ostream& out);
    3648             :       static void readEasyStorageDataFromFile (std::istream& in);
    3649             :       static void writeStaticDataToFile (std::ostream& out );
    3650             :       static void readStaticDataFromFile (std::istream& in );
    3651             :       friend class SgTypeLongDouble;
    3652             :    };
    3653             : /* #line 3654 "../../../src/frontend/SageIII//StorageClasses.h" */
    3654             : 
    3655             : 
    3656             : 
    3657             : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarStorageClassDeclatationMacros.macro" */
    3658             : /* 
    3659             :    JH (01/01/2006) ROSETTA generated class declarations for SgTypeStringStorageClass 
    3660             :    used for the ast file IO. Do not chance by hand! 
    3661             : */
    3662           0 : class SgTypeStringStorageClass  : public SgTypeStorageClass
    3663             :    {
    3664             : 
    3665             :     protected: 
    3666             : 
    3667             : 
    3668             : /* #line 3669 "../../../src/frontend/SageIII//StorageClasses.h" */
    3669             : 
    3670             :      unsigned long storageOf_lengthExpression;
    3671             : 
    3672             : 
    3673             : /* #line 10 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarStorageClassDeclatationMacros.macro" */
    3674             : 
    3675             : 
    3676             :     public:
    3677             :       void pickOutIRNodeData ( SgTypeString* source );
    3678             :       static void arrangeStaticDataOfEasyStorageClassesInOneBlock ( );
    3679             :       static void deleteStaticDataOfEasyStorageClasses ( );
    3680             :       static void pickOutStaticDataMembers ( );
    3681             :       static void rebuildStaticDataMembers ( );
    3682             :       static void writeEasyStorageDataToFile (std::ostream& out);
    3683             :       static void readEasyStorageDataFromFile (std::istream& in);
    3684             :       static void writeStaticDataToFile (std::ostream& out );
    3685             :       static void readStaticDataFromFile (std::istream& in );
    3686             :       friend class SgTypeString;
    3687             :    };
    3688             : /* #line 3689 "../../../src/frontend/SageIII//StorageClasses.h" */
    3689             : 
    3690             : 
    3691             : 
    3692             : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarStorageClassDeclatationMacros.macro" */
    3693             : /* 
    3694             :    JH (01/01/2006) ROSETTA generated class declarations for SgTypeBoolStorageClass 
    3695             :    used for the ast file IO. Do not chance by hand! 
    3696             : */
    3697           2 : class SgTypeBoolStorageClass  : public SgTypeStorageClass
    3698             :    {
    3699             : 
    3700             :     protected: 
    3701             : 
    3702             : 
    3703             : /* #line 3704 "../../../src/frontend/SageIII//StorageClasses.h" */
    3704             : 
    3705             : 
    3706             : 
    3707             : /* #line 10 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarStorageClassDeclatationMacros.macro" */
    3708             : 
    3709             : 
    3710             :     public:
    3711             :       void pickOutIRNodeData ( SgTypeBool* source );
    3712             :       static void arrangeStaticDataOfEasyStorageClassesInOneBlock ( );
    3713             :       static void deleteStaticDataOfEasyStorageClasses ( );
    3714             :       static void pickOutStaticDataMembers ( );
    3715             :       static void rebuildStaticDataMembers ( );
    3716             :       static void writeEasyStorageDataToFile (std::ostream& out);
    3717             :       static void readEasyStorageDataFromFile (std::istream& in);
    3718             :       static void writeStaticDataToFile (std::ostream& out );
    3719             :       static void readStaticDataFromFile (std::istream& in );
    3720             :       friend class SgTypeBool;
    3721             :    };
    3722             : /* #line 3723 "../../../src/frontend/SageIII//StorageClasses.h" */
    3723             : 
    3724             : 
    3725             : 
    3726             : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarStorageClassDeclatationMacros.macro" */
    3727             : /* 
    3728             :    JH (01/01/2006) ROSETTA generated class declarations for SgPointerTypeStorageClass 
    3729             :    used for the ast file IO. Do not chance by hand! 
    3730             : */
    3731        1252 : class SgPointerTypeStorageClass  : public SgTypeStorageClass
    3732             :    {
    3733             : 
    3734             :     protected: 
    3735             : 
    3736             : 
    3737             : /* #line 3738 "../../../src/frontend/SageIII//StorageClasses.h" */
    3738             : 
    3739             :      unsigned long storageOf_base_type;
    3740             : 
    3741             : 
    3742             : /* #line 10 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarStorageClassDeclatationMacros.macro" */
    3743             : 
    3744             : 
    3745             :     public:
    3746             :       void pickOutIRNodeData ( SgPointerType* source );
    3747             :       static void arrangeStaticDataOfEasyStorageClassesInOneBlock ( );
    3748             :       static void deleteStaticDataOfEasyStorageClasses ( );
    3749             :       static void pickOutStaticDataMembers ( );
    3750             :       static void rebuildStaticDataMembers ( );
    3751             :       static void writeEasyStorageDataToFile (std::ostream& out);
    3752             :       static void readEasyStorageDataFromFile (std::istream& in);
    3753             :       static void writeStaticDataToFile (std::ostream& out );
    3754             :       static void readStaticDataFromFile (std::istream& in );
    3755             :       friend class SgPointerType;
    3756             :    };
    3757             : /* #line 3758 "../../../src/frontend/SageIII//StorageClasses.h" */
    3758             : 
    3759             : 
    3760             : 
    3761             : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarStorageClassDeclatationMacros.macro" */
    3762             : /* 
    3763             :    JH (01/01/2006) ROSETTA generated class declarations for SgPointerMemberTypeStorageClass 
    3764             :    used for the ast file IO. Do not chance by hand! 
    3765             : */
    3766          58 : class SgPointerMemberTypeStorageClass  : public SgPointerTypeStorageClass
    3767             :    {
    3768             : 
    3769             :     protected: 
    3770             : 
    3771             : 
    3772             : /* #line 3773 "../../../src/frontend/SageIII//StorageClasses.h" */
    3773             : 
    3774             :      unsigned long storageOf_class_type;
    3775             : 
    3776             : 
    3777             : /* #line 10 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarStorageClassDeclatationMacros.macro" */
    3778             : 
    3779             : 
    3780             :     public:
    3781             :       void pickOutIRNodeData ( SgPointerMemberType* source );
    3782             :       static void arrangeStaticDataOfEasyStorageClassesInOneBlock ( );
    3783             :       static void deleteStaticDataOfEasyStorageClasses ( );
    3784             :       static void pickOutStaticDataMembers ( );
    3785             :       static void rebuildStaticDataMembers ( );
    3786             :       static void writeEasyStorageDataToFile (std::ostream& out);
    3787             :       static void readEasyStorageDataFromFile (std::istream& in);
    3788             :       static void writeStaticDataToFile (std::ostream& out );
    3789             :       static void readStaticDataFromFile (std::istream& in );
    3790             :       friend class SgPointerMemberType;
    3791             :    };
    3792             : /* #line 3793 "../../../src/frontend/SageIII//StorageClasses.h" */
    3793             : 
    3794             : 
    3795             : 
    3796             : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarStorageClassDeclatationMacros.macro" */
    3797             : /* 
    3798             :    JH (01/01/2006) ROSETTA generated class declarations for SgReferenceTypeStorageClass 
    3799             :    used for the ast file IO. Do not chance by hand! 
    3800             : */
    3801        1448 : class SgReferenceTypeStorageClass  : public SgTypeStorageClass
    3802             :    {
    3803             : 
    3804             :     protected: 
    3805             : 
    3806             : 
    3807             : /* #line 3808 "../../../src/frontend/SageIII//StorageClasses.h" */
    3808             : 
    3809             :      unsigned long storageOf_base_type;
    3810             : 
    3811             : 
    3812             : /* #line 10 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarStorageClassDeclatationMacros.macro" */
    3813             : 
    3814             : 
    3815             :     public:
    3816             :       void pickOutIRNodeData ( SgReferenceType* source );
    3817             :       static void arrangeStaticDataOfEasyStorageClassesInOneBlock ( );
    3818             :       static void deleteStaticDataOfEasyStorageClasses ( );
    3819             :       static void pickOutStaticDataMembers ( );
    3820             :       static void rebuildStaticDataMembers ( );
    3821             :       static void writeEasyStorageDataToFile (std::ostream& out);
    3822             :       static void readEasyStorageDataFromFile (std::istream& in);
    3823             :       static void writeStaticDataToFile (std::ostream& out );
    3824             :       static void readStaticDataFromFile (std::istream& in );
    3825             :       friend class SgReferenceType;
    3826             :    };
    3827             : /* #line 3828 "../../../src/frontend/SageIII//StorageClasses.h" */
    3828             : 
    3829             : 
    3830             : 
    3831             : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarStorageClassDeclatationMacros.macro" */
    3832             : /* 
    3833             :    JH (01/01/2006) ROSETTA generated class declarations for SgNamedTypeStorageClass 
    3834             :    used for the ast file IO. Do not chance by hand! 
    3835             : */
    3836           0 : class SgNamedTypeStorageClass  : public SgTypeStorageClass
    3837             :    {
    3838             : 
    3839             :     protected: 
    3840             : 
    3841             : 
    3842             : /* #line 3843 "../../../src/frontend/SageIII//StorageClasses.h" */
    3843             : 
    3844             :      unsigned long storageOf_declaration;
    3845             :       bool storageOf_autonomous_declaration;
    3846             :       bool storageOf_is_from_template_parameter;
    3847             : 
    3848             : 
    3849             : /* #line 10 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarStorageClassDeclatationMacros.macro" */
    3850             : 
    3851             : 
    3852             :     public:
    3853             :       void pickOutIRNodeData ( SgNamedType* source );
    3854             :       static void arrangeStaticDataOfEasyStorageClassesInOneBlock ( );
    3855             :       static void deleteStaticDataOfEasyStorageClasses ( );
    3856             :       static void pickOutStaticDataMembers ( );
    3857             :       static void rebuildStaticDataMembers ( );
    3858             :       static void writeEasyStorageDataToFile (std::ostream& out);
    3859             :       static void readEasyStorageDataFromFile (std::istream& in);
    3860             :       static void writeStaticDataToFile (std::ostream& out );
    3861             :       static void readStaticDataFromFile (std::istream& in );
    3862             :       friend class SgNamedType;
    3863             :    };
    3864             : /* #line 3865 "../../../src/frontend/SageIII//StorageClasses.h" */
    3865             : 
    3866             : 
    3867             : 
    3868             : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarStorageClassDeclatationMacros.macro" */
    3869             : /* 
    3870             :    JH (01/01/2006) ROSETTA generated class declarations for SgClassTypeStorageClass 
    3871             :    used for the ast file IO. Do not chance by hand! 
    3872             : */
    3873        2802 : class SgClassTypeStorageClass  : public SgNamedTypeStorageClass
    3874             :    {
    3875             : 
    3876             :     protected: 
    3877             : 
    3878             : 
    3879             : /* #line 3880 "../../../src/frontend/SageIII//StorageClasses.h" */
    3880             : 
    3881             :       bool storageOf_packed;
    3882             : 
    3883             : 
    3884             : /* #line 10 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarStorageClassDeclatationMacros.macro" */
    3885             : 
    3886             : 
    3887             :     public:
    3888             :       void pickOutIRNodeData ( SgClassType* source );
    3889             :       static void arrangeStaticDataOfEasyStorageClassesInOneBlock ( );
    3890             :       static void deleteStaticDataOfEasyStorageClasses ( );
    3891             :       static void pickOutStaticDataMembers ( );
    3892             :       static void rebuildStaticDataMembers ( );
    3893             :       static void writeEasyStorageDataToFile (std::ostream& out);
    3894             :       static void readEasyStorageDataFromFile (std::istream& in);
    3895             :       static void writeStaticDataToFile (std::ostream& out );
    3896             :       static void readStaticDataFromFile (std::istream& in );
    3897             :       friend class SgClassType;
    3898             :    };
    3899             : /* #line 3900 "../../../src/frontend/SageIII//StorageClasses.h" */
    3900             : 
    3901             : 
    3902             : 
    3903             : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarStorageClassDeclatationMacros.macro" */
    3904             : /* 
    3905             :    JH (01/01/2006) ROSETTA generated class declarations for SgEnumTypeStorageClass 
    3906             :    used for the ast file IO. Do not chance by hand! 
    3907             : */
    3908         174 : class SgEnumTypeStorageClass  : public SgNamedTypeStorageClass
    3909             :    {
    3910             : 
    3911             :     protected: 
    3912             : 
    3913             : 
    3914             : /* #line 3915 "../../../src/frontend/SageIII//StorageClasses.h" */
    3915             : 
    3916             : 
    3917             : 
    3918             : /* #line 10 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarStorageClassDeclatationMacros.macro" */
    3919             : 
    3920             : 
    3921             :     public:
    3922             :       void pickOutIRNodeData ( SgEnumType* source );
    3923             :       static void arrangeStaticDataOfEasyStorageClassesInOneBlock ( );
    3924             :       static void deleteStaticDataOfEasyStorageClasses ( );
    3925             :       static void pickOutStaticDataMembers ( );
    3926             :       static void rebuildStaticDataMembers ( );
    3927             :       static void writeEasyStorageDataToFile (std::ostream& out);
    3928             :       static void readEasyStorageDataFromFile (std::istream& in);
    3929             :       static void writeStaticDataToFile (std::ostream& out );
    3930             :       static void readStaticDataFromFile (std::istream& in );
    3931             :       friend class SgEnumType;
    3932             :    };
    3933             : /* #line 3934 "../../../src/frontend/SageIII//StorageClasses.h" */
    3934             : 
    3935             : 
    3936             : 
    3937             : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarStorageClassDeclatationMacros.macro" */
    3938             : /* 
    3939             :    JH (01/01/2006) ROSETTA generated class declarations for SgTypedefTypeStorageClass 
    3940             :    used for the ast file IO. Do not chance by hand! 
    3941             : */
    3942        3696 : class SgTypedefTypeStorageClass  : public SgNamedTypeStorageClass
    3943             :    {
    3944             : 
    3945             :     protected: 
    3946             : 
    3947             : 
    3948             : /* #line 3949 "../../../src/frontend/SageIII//StorageClasses.h" */
    3949             : 
    3950             :      unsigned long storageOf_parent_scope;
    3951             : 
    3952             : 
    3953             : /* #line 10 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarStorageClassDeclatationMacros.macro" */
    3954             : 
    3955             : 
    3956             :     public:
    3957             :       void pickOutIRNodeData ( SgTypedefType* source );
    3958             :       static void arrangeStaticDataOfEasyStorageClassesInOneBlock ( );
    3959             :       static void deleteStaticDataOfEasyStorageClasses ( );
    3960             :       static void pickOutStaticDataMembers ( );
    3961             :       static void rebuildStaticDataMembers ( );
    3962             :       static void writeEasyStorageDataToFile (std::ostream& out);
    3963             :       static void readEasyStorageDataFromFile (std::istream& in);
    3964             :       static void writeStaticDataToFile (std::ostream& out );
    3965             :       static void readStaticDataFromFile (std::istream& in );
    3966             :       friend class SgTypedefType;
    3967             :    };
    3968             : /* #line 3969 "../../../src/frontend/SageIII//StorageClasses.h" */
    3969             : 
    3970             : 
    3971             : 
    3972             : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarStorageClassDeclatationMacros.macro" */
    3973             : /* 
    3974             :    JH (01/01/2006) ROSETTA generated class declarations for SgNonrealTypeStorageClass 
    3975             :    used for the ast file IO. Do not chance by hand! 
    3976             : */
    3977       10160 : class SgNonrealTypeStorageClass  : public SgNamedTypeStorageClass
    3978             :    {
    3979             : 
    3980             :     protected: 
    3981             : 
    3982             : 
    3983             : /* #line 3984 "../../../src/frontend/SageIII//StorageClasses.h" */
    3984             : 
    3985             : 
    3986             : 
    3987             : /* #line 10 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarStorageClassDeclatationMacros.macro" */
    3988             : 
    3989             : 
    3990             :     public:
    3991             :       void pickOutIRNodeData ( SgNonrealType* source );
    3992             :       static void arrangeStaticDataOfEasyStorageClassesInOneBlock ( );
    3993             :       static void deleteStaticDataOfEasyStorageClasses ( );
    3994             :       static void pickOutStaticDataMembers ( );
    3995             :       static void rebuildStaticDataMembers ( );
    3996             :       static void writeEasyStorageDataToFile (std::ostream& out);
    3997             :       static void readEasyStorageDataFromFile (std::istream& in);
    3998             :       static void writeStaticDataToFile (std::ostream& out );
    3999             :       static void readStaticDataFromFile (std::istream& in );
    4000             :       friend class SgNonrealType;
    4001             :    };
    4002             : /* #line 4003 "../../../src/frontend/SageIII//StorageClasses.h" */
    4003             : 
    4004             : 
    4005             : 
    4006             : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarStorageClassDeclatationMacros.macro" */
    4007             : /* 
    4008             :    JH (01/01/2006) ROSETTA generated class declarations for SgModifierTypeStorageClass 
    4009             :    used for the ast file IO. Do not chance by hand! 
    4010             : */
    4011        1752 : class SgModifierTypeStorageClass  : public SgTypeStorageClass
    4012             :    {
    4013             : 
    4014             :     protected: 
    4015             : 
    4016             : 
    4017             : /* #line 4018 "../../../src/frontend/SageIII//StorageClasses.h" */
    4018             : 
    4019             :      unsigned long storageOf_base_type;
    4020             :       SgTypeModifierStorageClass storageOf_typeModifier;
    4021             :        EasyStorage < char* > storageOf_frontend_type_reference;
    4022             : 
    4023             : 
    4024             : /* #line 10 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarStorageClassDeclatationMacros.macro" */
    4025             : 
    4026             : 
    4027             :     public:
    4028             :       void pickOutIRNodeData ( SgModifierType* source );
    4029             :       static void arrangeStaticDataOfEasyStorageClassesInOneBlock ( );
    4030             :       static void deleteStaticDataOfEasyStorageClasses ( );
    4031             :       static void pickOutStaticDataMembers ( );
    4032             :       static void rebuildStaticDataMembers ( );
    4033             :       static void writeEasyStorageDataToFile (std::ostream& out);
    4034             :       static void readEasyStorageDataFromFile (std::istream& in);
    4035             :       static void writeStaticDataToFile (std::ostream& out );
    4036             :       static void readStaticDataFromFile (std::istream& in );
    4037             :       friend class SgModifierType;
    4038             :    };
    4039             : /* #line 4040 "../../../src/frontend/SageIII//StorageClasses.h" */
    4040             : 
    4041             : 
    4042             : 
    4043             : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarStorageClassDeclatationMacros.macro" */
    4044             : /* 
    4045             :    JH (01/01/2006) ROSETTA generated class declarations for SgFunctionTypeStorageClass 
    4046             :    used for the ast file IO. Do not chance by hand! 
    4047             : */
    4048        6299 : class SgFunctionTypeStorageClass  : public SgTypeStorageClass
    4049             :    {
    4050             : 
    4051             :     protected: 
    4052             : 
    4053             : 
    4054             : /* #line 4055 "../../../src/frontend/SageIII//StorageClasses.h" */
    4055             : 
    4056             :      unsigned long storageOf_return_type;
    4057             :       bool storageOf_has_ellipses;
    4058             :      unsigned long storageOf_orig_return_type;
    4059             :      unsigned long storageOf_argument_list;
    4060             : 
    4061             : 
    4062             : /* #line 10 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarStorageClassDeclatationMacros.macro" */
    4063             : 
    4064             : 
    4065             :     public:
    4066             :       void pickOutIRNodeData ( SgFunctionType* source );
    4067             :       static void arrangeStaticDataOfEasyStorageClassesInOneBlock ( );
    4068             :       static void deleteStaticDataOfEasyStorageClasses ( );
    4069             :       static void pickOutStaticDataMembers ( );
    4070             :       static void rebuildStaticDataMembers ( );
    4071             :       static void writeEasyStorageDataToFile (std::ostream& out);
    4072             :       static void readEasyStorageDataFromFile (std::istream& in);
    4073             :       static void writeStaticDataToFile (std::ostream& out );
    4074             :       static void readStaticDataFromFile (std::istream& in );
    4075             :       friend class SgFunctionType;
    4076             :    };
    4077             : /* #line 4078 "../../../src/frontend/SageIII//StorageClasses.h" */
    4078             : 
    4079             : 
    4080             : 
    4081             : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarStorageClassDeclatationMacros.macro" */
    4082             : /* 
    4083             :    JH (01/01/2006) ROSETTA generated class declarations for SgMemberFunctionTypeStorageClass 
    4084             :    used for the ast file IO. Do not chance by hand! 
    4085             : */
    4086        4334 : class SgMemberFunctionTypeStorageClass  : public SgFunctionTypeStorageClass
    4087             :    {
    4088             : 
    4089             :     protected: 
    4090             : 
    4091             : 
    4092             : /* #line 4093 "../../../src/frontend/SageIII//StorageClasses.h" */
    4093             : 
    4094             :      unsigned long storageOf_class_type;
    4095             :       unsigned int storageOf_mfunc_specifier;
    4096             :       unsigned int storageOf_ref_qualifiers;
    4097             : 
    4098             : 
    4099             : /* #line 10 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarStorageClassDeclatationMacros.macro" */
    4100             : 
    4101             : 
    4102             :     public:
    4103             :       void pickOutIRNodeData ( SgMemberFunctionType* source );
    4104             :       static void arrangeStaticDataOfEasyStorageClassesInOneBlock ( );
    4105             :       static void deleteStaticDataOfEasyStorageClasses ( );
    4106             :       static void pickOutStaticDataMembers ( );
    4107             :       static void rebuildStaticDataMembers ( );
    4108             :       static void writeEasyStorageDataToFile (std::ostream& out);
    4109             :       static void readEasyStorageDataFromFile (std::istream& in);
    4110             :       static void writeStaticDataToFile (std::ostream& out );
    4111             :       static void readStaticDataFromFile (std::istream& in );
    4112             :       friend class SgMemberFunctionType;
    4113             :    };
    4114             : /* #line 4115 "../../../src/frontend/SageIII//StorageClasses.h" */
    4115             : 
    4116             : 
    4117             : 
    4118             : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarStorageClassDeclatationMacros.macro" */
    4119             : /* 
    4120             :    JH (01/01/2006) ROSETTA generated class declarations for SgPartialFunctionTypeStorageClass 
    4121             :    used for the ast file IO. Do not chance by hand! 
    4122             : */
    4123           0 : class SgPartialFunctionTypeStorageClass  : public SgMemberFunctionTypeStorageClass
    4124             :    {
    4125             : 
    4126             :     protected: 
    4127             : 
    4128             : 
    4129             : /* #line 4130 "../../../src/frontend/SageIII//StorageClasses.h" */
    4130             : 
    4131             : 
    4132             : 
    4133             : /* #line 10 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarStorageClassDeclatationMacros.macro" */
    4134             : 
    4135             : 
    4136             :     public:
    4137             :       void pickOutIRNodeData ( SgPartialFunctionType* source );
    4138             :       static void arrangeStaticDataOfEasyStorageClassesInOneBlock ( );
    4139             :       static void deleteStaticDataOfEasyStorageClasses ( );
    4140             :       static void pickOutStaticDataMembers ( );
    4141             :       static void rebuildStaticDataMembers ( );
    4142             :       static void writeEasyStorageDataToFile (std::ostream& out);
    4143             :       static void readEasyStorageDataFromFile (std::istream& in);
    4144             :       static void writeStaticDataToFile (std::ostream& out );
    4145             :       static void readStaticDataFromFile (std::istream& in );
    4146             :       friend class SgPartialFunctionType;
    4147             :    };
    4148             : /* #line 4149 "../../../src/frontend/SageIII//StorageClasses.h" */
    4149             : 
    4150             : 
    4151             : 
    4152             : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarStorageClassDeclatationMacros.macro" */
    4153             : /* 
    4154             :    JH (01/01/2006) ROSETTA generated class declarations for SgPartialFunctionModifierTypeStorageClass 
    4155             :    used for the ast file IO. Do not chance by hand! 
    4156             : */
    4157           0 : class SgPartialFunctionModifierTypeStorageClass  : public SgPartialFunctionTypeStorageClass
    4158             :    {
    4159             : 
    4160             :     protected: 
    4161             : 
    4162             : 
    4163             : /* #line 4164 "../../../src/frontend/SageIII//StorageClasses.h" */
    4164             : 
    4165             : 
    4166             : 
    4167             : /* #line 10 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarStorageClassDeclatationMacros.macro" */
    4168             : 
    4169             : 
    4170             :     public:
    4171             :       void pickOutIRNodeData ( SgPartialFunctionModifierType* source );
    4172             :       static void arrangeStaticDataOfEasyStorageClassesInOneBlock ( );
    4173             :       static void deleteStaticDataOfEasyStorageClasses ( );
    4174             :       static void pickOutStaticDataMembers ( );
    4175             :       static void rebuildStaticDataMembers ( );
    4176             :       static void writeEasyStorageDataToFile (std::ostream& out);
    4177             :       static void readEasyStorageDataFromFile (std::istream& in);
    4178             :       static void writeStaticDataToFile (std::ostream& out );
    4179             :       static void readStaticDataFromFile (std::istream& in );
    4180             :       friend class SgPartialFunctionModifierType;
    4181             :    };
    4182             : /* #line 4183 "../../../src/frontend/SageIII//StorageClasses.h" */
    4183             : 
    4184             : 
    4185             : 
    4186             : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarStorageClassDeclatationMacros.macro" */
    4187             : /* 
    4188             :    JH (01/01/2006) ROSETTA generated class declarations for SgArrayTypeStorageClass 
    4189             :    used for the ast file IO. Do not chance by hand! 
    4190             : */
    4191         216 : class SgArrayTypeStorageClass  : public SgTypeStorageClass
    4192             :    {
    4193             : 
    4194             :     protected: 
    4195             : 
    4196             : 
    4197             : /* #line 4198 "../../../src/frontend/SageIII//StorageClasses.h" */
    4198             : 
    4199             :      unsigned long storageOf_base_type;
    4200             :      unsigned long storageOf_index;
    4201             :      unsigned long storageOf_dim_info;
    4202             :       int storageOf_rank;
    4203             :       int storageOf_number_of_elements;
    4204             :       bool storageOf_is_variable_length_array;
    4205             : 
    4206             : 
    4207             : /* #line 10 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarStorageClassDeclatationMacros.macro" */
    4208             : 
    4209             : 
    4210             :     public:
    4211             :       void pickOutIRNodeData ( SgArrayType* source );
    4212             :       static void arrangeStaticDataOfEasyStorageClassesInOneBlock ( );
    4213             :       static void deleteStaticDataOfEasyStorageClasses ( );
    4214             :       static void pickOutStaticDataMembers ( );
    4215             :       static void rebuildStaticDataMembers ( );
    4216             :       static void writeEasyStorageDataToFile (std::ostream& out);
    4217             :       static void readEasyStorageDataFromFile (std::istream& in);
    4218             :       static void writeStaticDataToFile (std::ostream& out );
    4219             :       static void readStaticDataFromFile (std::istream& in );
    4220             :       friend class SgArrayType;
    4221             :    };
    4222             : /* #line 4223 "../../../src/frontend/SageIII//StorageClasses.h" */
    4223             : 
    4224             : 
    4225             : 
    4226             : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarStorageClassDeclatationMacros.macro" */
    4227             : /* 
    4228             :    JH (01/01/2006) ROSETTA generated class declarations for SgTypeEllipseStorageClass 
    4229             :    used for the ast file IO. Do not chance by hand! 
    4230             : */
    4231           4 : class SgTypeEllipseStorageClass  : public SgTypeStorageClass
    4232             :    {
    4233             : 
    4234             :     protected: 
    4235             : 
    4236             : 
    4237             : /* #line 4238 "../../../src/frontend/SageIII//StorageClasses.h" */
    4238             : 
    4239             : 
    4240             : 
    4241             : /* #line 10 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarStorageClassDeclatationMacros.macro" */
    4242             : 
    4243             : 
    4244             :     public:
    4245             :       void pickOutIRNodeData ( SgTypeEllipse* source );
    4246             :       static void arrangeStaticDataOfEasyStorageClassesInOneBlock ( );
    4247             :       static void deleteStaticDataOfEasyStorageClasses ( );
    4248             :       static void pickOutStaticDataMembers ( );
    4249             :       static void rebuildStaticDataMembers ( );
    4250             :       static void writeEasyStorageDataToFile (std::ostream& out);
    4251             :       static void readEasyStorageDataFromFile (std::istream& in);
    4252             :       static void writeStaticDataToFile (std::ostream& out );
    4253             :       static void readStaticDataFromFile (std::istream& in );
    4254             :       friend class SgTypeEllipse;
    4255             :    };
    4256             : /* #line 4257 "../../../src/frontend/SageIII//StorageClasses.h" */
    4257             : 
    4258             : 
    4259             : 
    4260             : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarStorageClassDeclatationMacros.macro" */
    4261             : /* 
    4262             :    JH (01/01/2006) ROSETTA generated class declarations for SgTemplateTypeStorageClass 
    4263             :    used for the ast file IO. Do not chance by hand! 
    4264             : */
    4265           0 : class SgTemplateTypeStorageClass  : public SgTypeStorageClass
    4266             :    {
    4267             : 
    4268             :     protected: 
    4269             : 
    4270             : 
    4271             : /* #line 4272 "../../../src/frontend/SageIII//StorageClasses.h" */
    4272             : 
    4273             :       SgNameStorageClass storageOf_name;
    4274             :       int storageOf_template_parameter_position;
    4275             :       int storageOf_template_parameter_depth;
    4276             :      unsigned long storageOf_class_type;
    4277             :      unsigned long storageOf_parent_class_type;
    4278             :      unsigned long storageOf_template_parameter;
    4279             :        EasyStorage < SgTemplateArgumentPtrList > storageOf_tpl_args;
    4280             :        EasyStorage < SgTemplateArgumentPtrList > storageOf_part_spec_tpl_args;
    4281             :       bool storageOf_packed;
    4282             : 
    4283             : 
    4284             : /* #line 10 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarStorageClassDeclatationMacros.macro" */
    4285             : 
    4286             : 
    4287             :     public:
    4288             :       void pickOutIRNodeData ( SgTemplateType* source );
    4289             :       static void arrangeStaticDataOfEasyStorageClassesInOneBlock ( );
    4290             :       static void deleteStaticDataOfEasyStorageClasses ( );
    4291             :       static void pickOutStaticDataMembers ( );
    4292             :       static void rebuildStaticDataMembers ( );
    4293             :       static void writeEasyStorageDataToFile (std::ostream& out);
    4294             :       static void readEasyStorageDataFromFile (std::istream& in);
    4295             :       static void writeStaticDataToFile (std::ostream& out );
    4296             :       static void readStaticDataFromFile (std::istream& in );
    4297             :       friend class SgTemplateType;
    4298             :    };
    4299             : /* #line 4300 "../../../src/frontend/SageIII//StorageClasses.h" */
    4300             : 
    4301             : 
    4302             : 
    4303             : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarStorageClassDeclatationMacros.macro" */
    4304             : /* 
    4305             :    JH (01/01/2006) ROSETTA generated class declarations for SgQualifiedNameTypeStorageClass 
    4306             :    used for the ast file IO. Do not chance by hand! 
    4307             : */
    4308           0 : class SgQualifiedNameTypeStorageClass  : public SgTypeStorageClass
    4309             :    {
    4310             : 
    4311             :     protected: 
    4312             : 
    4313             : 
    4314             : /* #line 4315 "../../../src/frontend/SageIII//StorageClasses.h" */
    4315             : 
    4316             :      unsigned long storageOf_base_type;
    4317             :        EasyStorage < SgQualifiedNamePtrList > storageOf_qualifiedNameList;
    4318             : 
    4319             : 
    4320             : /* #line 10 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarStorageClassDeclatationMacros.macro" */
    4321             : 
    4322             : 
    4323             :     public:
    4324             :       void pickOutIRNodeData ( SgQualifiedNameType* source );
    4325             :       static void arrangeStaticDataOfEasyStorageClassesInOneBlock ( );
    4326             :       static void deleteStaticDataOfEasyStorageClasses ( );
    4327             :       static void pickOutStaticDataMembers ( );
    4328             :       static void rebuildStaticDataMembers ( );
    4329             :       static void writeEasyStorageDataToFile (std::ostream& out);
    4330             :       static void readEasyStorageDataFromFile (std::istream& in);
    4331             :       static void writeStaticDataToFile (std::ostream& out );
    4332             :       static void readStaticDataFromFile (std::istream& in );
    4333             :       friend class SgQualifiedNameType;
    4334             :    };
    4335             : /* #line 4336 "../../../src/frontend/SageIII//StorageClasses.h" */
    4336             : 
    4337             : 
    4338             : 
    4339             : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarStorageClassDeclatationMacros.macro" */
    4340             : /* 
    4341             :    JH (01/01/2006) ROSETTA generated class declarations for SgTypeComplexStorageClass 
    4342             :    used for the ast file IO. Do not chance by hand! 
    4343             : */
    4344          14 : class SgTypeComplexStorageClass  : public SgTypeStorageClass
    4345             :    {
    4346             : 
    4347             :     protected: 
    4348             : 
    4349             : 
    4350             : /* #line 4351 "../../../src/frontend/SageIII//StorageClasses.h" */
    4351             : 
    4352             :      unsigned long storageOf_base_type;
    4353             : 
    4354             : 
    4355             : /* #line 10 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarStorageClassDeclatationMacros.macro" */
    4356             : 
    4357             : 
    4358             :     public:
    4359             :       void pickOutIRNodeData ( SgTypeComplex* source );
    4360             :       static void arrangeStaticDataOfEasyStorageClassesInOneBlock ( );
    4361             :       static void deleteStaticDataOfEasyStorageClasses ( );
    4362             :       static void pickOutStaticDataMembers ( );
    4363             :       static void rebuildStaticDataMembers ( );
    4364             :       static void writeEasyStorageDataToFile (std::ostream& out);
    4365             :       static void readEasyStorageDataFromFile (std::istream& in);
    4366             :       static void writeStaticDataToFile (std::ostream& out );
    4367             :       static void readStaticDataFromFile (std::istream& in );
    4368             :       friend class SgTypeComplex;
    4369             :    };
    4370             : /* #line 4371 "../../../src/frontend/SageIII//StorageClasses.h" */
    4371             : 
    4372             : 
    4373             : 
    4374             : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarStorageClassDeclatationMacros.macro" */
    4375             : /* 
    4376             :    JH (01/01/2006) ROSETTA generated class declarations for SgTypeImaginaryStorageClass 
    4377             :    used for the ast file IO. Do not chance by hand! 
    4378             : */
    4379           0 : class SgTypeImaginaryStorageClass  : public SgTypeStorageClass
    4380             :    {
    4381             : 
    4382             :     protected: 
    4383             : 
    4384             : 
    4385             : /* #line 4386 "../../../src/frontend/SageIII//StorageClasses.h" */
    4386             : 
    4387             :      unsigned long storageOf_base_type;
    4388             : 
    4389             : 
    4390             : /* #line 10 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarStorageClassDeclatationMacros.macro" */
    4391             : 
    4392             : 
    4393             :     public:
    4394             :       void pickOutIRNodeData ( SgTypeImaginary* source );
    4395             :       static void arrangeStaticDataOfEasyStorageClassesInOneBlock ( );
    4396             :       static void deleteStaticDataOfEasyStorageClasses ( );
    4397             :       static void pickOutStaticDataMembers ( );
    4398             :       static void rebuildStaticDataMembers ( );
    4399             :       static void writeEasyStorageDataToFile (std::ostream& out);
    4400             :       static void readEasyStorageDataFromFile (std::istream& in);
    4401             :       static void writeStaticDataToFile (std::ostream& out );
    4402             :       static void readStaticDataFromFile (std::istream& in );
    4403             :       friend class SgTypeImaginary;
    4404             :    };
    4405             : /* #line 4406 "../../../src/frontend/SageIII//StorageClasses.h" */
    4406             : 
    4407             : 
    4408             : 
    4409             : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarStorageClassDeclatationMacros.macro" */
    4410             : /* 
    4411             :    JH (01/01/2006) ROSETTA generated class declarations for SgTypeDefaultStorageClass 
    4412             :    used for the ast file IO. Do not chance by hand! 
    4413             : */
    4414           8 : class SgTypeDefaultStorageClass  : public SgTypeStorageClass
    4415             :    {
    4416             : 
    4417             :     protected: 
    4418             : 
    4419             : 
    4420             : /* #line 4421 "../../../src/frontend/SageIII//StorageClasses.h" */
    4421             : 
    4422             :       SgNameStorageClass storageOf_name;
    4423             : 
    4424             : 
    4425             : /* #line 10 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarStorageClassDeclatationMacros.macro" */
    4426             : 
    4427             : 
    4428             :     public:
    4429             :       void pickOutIRNodeData ( SgTypeDefault* source );
    4430             :       static void arrangeStaticDataOfEasyStorageClassesInOneBlock ( );
    4431             :       static void deleteStaticDataOfEasyStorageClasses ( );
    4432             :       static void pickOutStaticDataMembers ( );
    4433             :       static void rebuildStaticDataMembers ( );
    4434             :       static void writeEasyStorageDataToFile (std::ostream& out);
    4435             :       static void readEasyStorageDataFromFile (std::istream& in);
    4436             :       static void writeStaticDataToFile (std::ostream& out );
    4437             :       static void readStaticDataFromFile (std::istream& in );
    4438             :       friend class SgTypeDefault;
    4439             :    };
    4440             : /* #line 4441 "../../../src/frontend/SageIII//StorageClasses.h" */
    4441             : 
    4442             : 
    4443             : 
    4444             : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarStorageClassDeclatationMacros.macro" */
    4445             : /* 
    4446             :    JH (01/01/2006) ROSETTA generated class declarations for SgTypeCAFTeamStorageClass 
    4447             :    used for the ast file IO. Do not chance by hand! 
    4448             : */
    4449           0 : class SgTypeCAFTeamStorageClass  : public SgTypeStorageClass
    4450             :    {
    4451             : 
    4452             :     protected: 
    4453             : 
    4454             : 
    4455             : /* #line 4456 "../../../src/frontend/SageIII//StorageClasses.h" */
    4456             : 
    4457             : 
    4458             : 
    4459             : /* #line 10 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarStorageClassDeclatationMacros.macro" */
    4460             : 
    4461             : 
    4462             :     public:
    4463             :       void pickOutIRNodeData ( SgTypeCAFTeam* source );
    4464             :       static void arrangeStaticDataOfEasyStorageClassesInOneBlock ( );
    4465             :       static void deleteStaticDataOfEasyStorageClasses ( );
    4466             :       static void pickOutStaticDataMembers ( );
    4467             :       static void rebuildStaticDataMembers ( );
    4468             :       static void writeEasyStorageDataToFile (std::ostream& out);
    4469             :       static void readEasyStorageDataFromFile (std::istream& in);
    4470             :       static void writeStaticDataToFile (std::ostream& out );
    4471             :       static void readStaticDataFromFile (std::istream& in );
    4472             :       friend class SgTypeCAFTeam;
    4473             :    };
    4474             : /* #line 4475 "../../../src/frontend/SageIII//StorageClasses.h" */
    4475             : 
    4476             : 
    4477             : 
    4478             : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarStorageClassDeclatationMacros.macro" */
    4479             : /* 
    4480             :    JH (01/01/2006) ROSETTA generated class declarations for SgTypeCrayPointerStorageClass 
    4481             :    used for the ast file IO. Do not chance by hand! 
    4482             : */
    4483           0 : class SgTypeCrayPointerStorageClass  : public SgTypeStorageClass
    4484             :    {
    4485             : 
    4486             :     protected: 
    4487             : 
    4488             : 
    4489             : /* #line 4490 "../../../src/frontend/SageIII//StorageClasses.h" */
    4490             : 
    4491             : 
    4492             : 
    4493             : /* #line 10 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarStorageClassDeclatationMacros.macro" */
    4494             : 
    4495             : 
    4496             :     public:
    4497             :       void pickOutIRNodeData ( SgTypeCrayPointer* source );
    4498             :       static void arrangeStaticDataOfEasyStorageClassesInOneBlock ( );
    4499             :       static void deleteStaticDataOfEasyStorageClasses ( );
    4500             :       static void pickOutStaticDataMembers ( );
    4501             :       static void rebuildStaticDataMembers ( );
    4502             :       static void writeEasyStorageDataToFile (std::ostream& out);
    4503             :       static void readEasyStorageDataFromFile (std::istream& in);
    4504             :       static void writeStaticDataToFile (std::ostream& out );
    4505             :       static void readStaticDataFromFile (std::istream& in );
    4506             :       friend class SgTypeCrayPointer;
    4507             :    };
    4508             : /* #line 4509 "../../../src/frontend/SageIII//StorageClasses.h" */
    4509             : 
    4510             : 
    4511             : 
    4512             : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarStorageClassDeclatationMacros.macro" */
    4513             : /* 
    4514             :    JH (01/01/2006) ROSETTA generated class declarations for SgTypeLabelStorageClass 
    4515             :    used for the ast file IO. Do not chance by hand! 
    4516             : */
    4517           0 : class SgTypeLabelStorageClass  : public SgTypeStorageClass
    4518             :    {
    4519             : 
    4520             :     protected: 
    4521             : 
    4522             : 
    4523             : /* #line 4524 "../../../src/frontend/SageIII//StorageClasses.h" */
    4524             : 
    4525             :       SgNameStorageClass storageOf_name;
    4526             : 
    4527             : 
    4528             : /* #line 10 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarStorageClassDeclatationMacros.macro" */
    4529             : 
    4530             : 
    4531             :     public:
    4532             :       void pickOutIRNodeData ( SgTypeLabel* source );
    4533             :       static void arrangeStaticDataOfEasyStorageClassesInOneBlock ( );
    4534             :       static void deleteStaticDataOfEasyStorageClasses ( );
    4535             :       static void pickOutStaticDataMembers ( );
    4536             :       static void rebuildStaticDataMembers ( );
    4537             :       static void writeEasyStorageDataToFile (std::ostream& out);
    4538             :       static void readEasyStorageDataFromFile (std::istream& in);
    4539             :       static void writeStaticDataToFile (std::ostream& out );
    4540             :       static void readStaticDataFromFile (std::istream& in );
    4541             :       friend class SgTypeLabel;
    4542             :    };
    4543             : /* #line 4544 "../../../src/frontend/SageIII//StorageClasses.h" */
    4544             : 
    4545             : 
    4546             : 
    4547             : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarStorageClassDeclatationMacros.macro" */
    4548             : /* 
    4549             :    JH (01/01/2006) ROSETTA generated class declarations for SgRvalueReferenceTypeStorageClass 
    4550             :    used for the ast file IO. Do not chance by hand! 
    4551             : */
    4552         364 : class SgRvalueReferenceTypeStorageClass  : public SgTypeStorageClass
    4553             :    {
    4554             : 
    4555             :     protected: 
    4556             : 
    4557             : 
    4558             : /* #line 4559 "../../../src/frontend/SageIII//StorageClasses.h" */
    4559             : 
    4560             :      unsigned long storageOf_base_type;
    4561             : 
    4562             : 
    4563             : /* #line 10 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarStorageClassDeclatationMacros.macro" */
    4564             : 
    4565             : 
    4566             :     public:
    4567             :       void pickOutIRNodeData ( SgRvalueReferenceType* source );
    4568             :       static void arrangeStaticDataOfEasyStorageClassesInOneBlock ( );
    4569             :       static void deleteStaticDataOfEasyStorageClasses ( );
    4570             :       static void pickOutStaticDataMembers ( );
    4571             :       static void rebuildStaticDataMembers ( );
    4572             :       static void writeEasyStorageDataToFile (std::ostream& out);
    4573             :       static void readEasyStorageDataFromFile (std::istream& in);
    4574             :       static void writeStaticDataToFile (std::ostream& out );
    4575             :       static void readStaticDataFromFile (std::istream& in );
    4576             :       friend class SgRvalueReferenceType;
    4577             :    };
    4578             : /* #line 4579 "../../../src/frontend/SageIII//StorageClasses.h" */
    4579             : 
    4580             : 
    4581             : 
    4582             : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarStorageClassDeclatationMacros.macro" */
    4583             : /* 
    4584             :    JH (01/01/2006) ROSETTA generated class declarations for SgTypeNullptrStorageClass 
    4585             :    used for the ast file IO. Do not chance by hand! 
    4586             : */
    4587           2 : class SgTypeNullptrStorageClass  : public SgTypeStorageClass
    4588             :    {
    4589             : 
    4590             :     protected: 
    4591             : 
    4592             : 
    4593             : /* #line 4594 "../../../src/frontend/SageIII//StorageClasses.h" */
    4594             : 
    4595             : 
    4596             : 
    4597             : /* #line 10 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarStorageClassDeclatationMacros.macro" */
    4598             : 
    4599             : 
    4600             :     public:
    4601             :       void pickOutIRNodeData ( SgTypeNullptr* source );
    4602             :       static void arrangeStaticDataOfEasyStorageClassesInOneBlock ( );
    4603             :       static void deleteStaticDataOfEasyStorageClasses ( );
    4604             :       static void pickOutStaticDataMembers ( );
    4605             :       static void rebuildStaticDataMembers ( );
    4606             :       static void writeEasyStorageDataToFile (std::ostream& out);
    4607             :       static void readEasyStorageDataFromFile (std::istream& in);
    4608             :       static void writeStaticDataToFile (std::ostream& out );
    4609             :       static void readStaticDataFromFile (std::istream& in );
    4610             :       friend class SgTypeNullptr;
    4611             :    };
    4612             : /* #line 4613 "../../../src/frontend/SageIII//StorageClasses.h" */
    4613             : 
    4614             : 
    4615             : 
    4616             : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarStorageClassDeclatationMacros.macro" */
    4617             : /* 
    4618             :    JH (01/01/2006) ROSETTA generated class declarations for SgDeclTypeStorageClass 
    4619             :    used for the ast file IO. Do not chance by hand! 
    4620             : */
    4621         184 : class SgDeclTypeStorageClass  : public SgTypeStorageClass
    4622             :    {
    4623             : 
    4624             :     protected: 
    4625             : 
    4626             : 
    4627             : /* #line 4628 "../../../src/frontend/SageIII//StorageClasses.h" */
    4628             : 
    4629             :      unsigned long storageOf_base_expression;
    4630             :      unsigned long storageOf_base_type;
    4631             : 
    4632             : 
    4633             : /* #line 10 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarStorageClassDeclatationMacros.macro" */
    4634             : 
    4635             : 
    4636             :     public:
    4637             :       void pickOutIRNodeData ( SgDeclType* source );
    4638             :       static void arrangeStaticDataOfEasyStorageClassesInOneBlock ( );
    4639             :       static void deleteStaticDataOfEasyStorageClasses ( );
    4640             :       static void pickOutStaticDataMembers ( );
    4641             :       static void rebuildStaticDataMembers ( );
    4642             :       static void writeEasyStorageDataToFile (std::ostream& out);
    4643             :       static void readEasyStorageDataFromFile (std::istream& in);
    4644             :       static void writeStaticDataToFile (std::ostream& out );
    4645             :       static void readStaticDataFromFile (std::istream& in );
    4646             :       friend class SgDeclType;
    4647             :    };
    4648             : /* #line 4649 "../../../src/frontend/SageIII//StorageClasses.h" */
    4649             : 
    4650             : 
    4651             : 
    4652             : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarStorageClassDeclatationMacros.macro" */
    4653             : /* 
    4654             :    JH (01/01/2006) ROSETTA generated class declarations for SgTypeOfTypeStorageClass 
    4655             :    used for the ast file IO. Do not chance by hand! 
    4656             : */
    4657           6 : class SgTypeOfTypeStorageClass  : public SgTypeStorageClass
    4658             :    {
    4659             : 
    4660             :     protected: 
    4661             : 
    4662             : 
    4663             : /* #line 4664 "../../../src/frontend/SageIII//StorageClasses.h" */
    4664             : 
    4665             :      unsigned long storageOf_base_expression;
    4666             :      unsigned long storageOf_base_type;
    4667             : 
    4668             : 
    4669             : /* #line 10 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarStorageClassDeclatationMacros.macro" */
    4670             : 
    4671             : 
    4672             :     public:
    4673             :       void pickOutIRNodeData ( SgTypeOfType* source );
    4674             :       static void arrangeStaticDataOfEasyStorageClassesInOneBlock ( );
    4675             :       static void deleteStaticDataOfEasyStorageClasses ( );
    4676             :       static void pickOutStaticDataMembers ( );
    4677             :       static void rebuildStaticDataMembers ( );
    4678             :       static void writeEasyStorageDataToFile (std::ostream& out);
    4679             :       static void readEasyStorageDataFromFile (std::istream& in);
    4680             :       static void writeStaticDataToFile (std::ostream& out );
    4681             :       static void readStaticDataFromFile (std::istream& in );
    4682             :       friend class SgTypeOfType;
    4683             :    };
    4684             : /* #line 4685 "../../../src/frontend/SageIII//StorageClasses.h" */
    4685             : 
    4686             : 
    4687             : 
    4688             : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarStorageClassDeclatationMacros.macro" */
    4689             : /* 
    4690             :    JH (01/01/2006) ROSETTA generated class declarations for SgTypeMatrixStorageClass 
    4691             :    used for the ast file IO. Do not chance by hand! 
    4692             : */
    4693           0 : class SgTypeMatrixStorageClass  : public SgTypeStorageClass
    4694             :    {
    4695             : 
    4696             :     protected: 
    4697             : 
    4698             : 
    4699             : /* #line 4700 "../../../src/frontend/SageIII//StorageClasses.h" */
    4700             : 
    4701             :      unsigned long storageOf_base_type;
    4702             : 
    4703             : 
    4704             : /* #line 10 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarStorageClassDeclatationMacros.macro" */
    4705             : 
    4706             : 
    4707             :     public:
    4708             :       void pickOutIRNodeData ( SgTypeMatrix* source );
    4709             :       static void arrangeStaticDataOfEasyStorageClassesInOneBlock ( );
    4710             :       static void deleteStaticDataOfEasyStorageClasses ( );
    4711             :       static void pickOutStaticDataMembers ( );
    4712             :       static void rebuildStaticDataMembers ( );
    4713             :       static void writeEasyStorageDataToFile (std::ostream& out);
    4714             :       static void readEasyStorageDataFromFile (std::istream& in);
    4715             :       static void writeStaticDataToFile (std::ostream& out );
    4716             :       static void readStaticDataFromFile (std::istream& in );
    4717             :       friend class SgTypeMatrix;
    4718             :    };
    4719             : /* #line 4720 "../../../src/frontend/SageIII//StorageClasses.h" */
    4720             : 
    4721             : 
    4722             : 
    4723             : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarStorageClassDeclatationMacros.macro" */
    4724             : /* 
    4725             :    JH (01/01/2006) ROSETTA generated class declarations for SgTypeTupleStorageClass 
    4726             :    used for the ast file IO. Do not chance by hand! 
    4727             : */
    4728           0 : class SgTypeTupleStorageClass  : public SgTypeStorageClass
    4729             :    {
    4730             : 
    4731             :     protected: 
    4732             : 
    4733             : 
    4734             : /* #line 4735 "../../../src/frontend/SageIII//StorageClasses.h" */
    4735             : 
    4736             :        EasyStorage < SgTypePtrList > storageOf_types;
    4737             : 
    4738             : 
    4739             : /* #line 10 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarStorageClassDeclatationMacros.macro" */
    4740             : 
    4741             : 
    4742             :     public:
    4743             :       void pickOutIRNodeData ( SgTypeTuple* source );
    4744             :       static void arrangeStaticDataOfEasyStorageClassesInOneBlock ( );
    4745             :       static void deleteStaticDataOfEasyStorageClasses ( );
    4746             :       static void pickOutStaticDataMembers ( );
    4747             :       static void rebuildStaticDataMembers ( );
    4748             :       static void writeEasyStorageDataToFile (std::ostream& out);
    4749             :       static void readEasyStorageDataFromFile (std::istream& in);
    4750             :       static void writeStaticDataToFile (std::ostream& out );
    4751             :       static void readStaticDataFromFile (std::istream& in );
    4752             :       friend class SgTypeTuple;
    4753             :    };
    4754             : /* #line 4755 "../../../src/frontend/SageIII//StorageClasses.h" */
    4755             : 
    4756             : 
    4757             : 
    4758             : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarStorageClassDeclatationMacros.macro" */
    4759             : /* 
    4760             :    JH (01/01/2006) ROSETTA generated class declarations for SgTypeChar16StorageClass 
    4761             :    used for the ast file IO. Do not chance by hand! 
    4762             : */
    4763           2 : class SgTypeChar16StorageClass  : public SgTypeStorageClass
    4764             :    {
    4765             : 
    4766             :     protected: 
    4767             : 
    4768             : 
    4769             : /* #line 4770 "../../../src/frontend/SageIII//StorageClasses.h" */
    4770             : 
    4771             : 
    4772             : 
    4773             : /* #line 10 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarStorageClassDeclatationMacros.macro" */
    4774             : 
    4775             : 
    4776             :     public:
    4777             :       void pickOutIRNodeData ( SgTypeChar16* source );
    4778             :       static void arrangeStaticDataOfEasyStorageClassesInOneBlock ( );
    4779             :       static void deleteStaticDataOfEasyStorageClasses ( );
    4780             :       static void pickOutStaticDataMembers ( );
    4781             :       static void rebuildStaticDataMembers ( );
    4782             :       static void writeEasyStorageDataToFile (std::ostream& out);
    4783             :       static void readEasyStorageDataFromFile (std::istream& in);
    4784             :       static void writeStaticDataToFile (std::ostream& out );
    4785             :       static void readStaticDataFromFile (std::istream& in );
    4786             :       friend class SgTypeChar16;
    4787             :    };
    4788             : /* #line 4789 "../../../src/frontend/SageIII//StorageClasses.h" */
    4789             : 
    4790             : 
    4791             : 
    4792             : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarStorageClassDeclatationMacros.macro" */
    4793             : /* 
    4794             :    JH (01/01/2006) ROSETTA generated class declarations for SgTypeChar32StorageClass 
    4795             :    used for the ast file IO. Do not chance by hand! 
    4796             : */
    4797           2 : class SgTypeChar32StorageClass  : public SgTypeStorageClass
    4798             :    {
    4799             : 
    4800             :     protected: 
    4801             : 
    4802             : 
    4803             : /* #line 4804 "../../../src/frontend/SageIII//StorageClasses.h" */
    4804             : 
    4805             : 
    4806             : 
    4807             : /* #line 10 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarStorageClassDeclatationMacros.macro" */
    4808             : 
    4809             : 
    4810             :     public:
    4811             :       void pickOutIRNodeData ( SgTypeChar32* source );
    4812             :       static void arrangeStaticDataOfEasyStorageClassesInOneBlock ( );
    4813             :       static void deleteStaticDataOfEasyStorageClasses ( );
    4814             :       static void pickOutStaticDataMembers ( );
    4815             :       static void rebuildStaticDataMembers ( );
    4816             :       static void writeEasyStorageDataToFile (std::ostream& out);
    4817             :       static void readEasyStorageDataFromFile (std::istream& in);
    4818             :       static void writeStaticDataToFile (std::ostream& out );
    4819             :       static void readStaticDataFromFile (std::istream& in );
    4820             :       friend class SgTypeChar32;
    4821             :    };
    4822             : /* #line 4823 "../../../src/frontend/SageIII//StorageClasses.h" */
    4823             : 
    4824             : 
    4825             : 
    4826             : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarStorageClassDeclatationMacros.macro" */
    4827             : /* 
    4828             :    JH (01/01/2006) ROSETTA generated class declarations for SgTypeFloat128StorageClass 
    4829             :    used for the ast file IO. Do not chance by hand! 
    4830             : */
    4831           2 : class SgTypeFloat128StorageClass  : public SgTypeStorageClass
    4832             :    {
    4833             : 
    4834             :     protected: 
    4835             : 
    4836             : 
    4837             : /* #line 4838 "../../../src/frontend/SageIII//StorageClasses.h" */
    4838             : 
    4839             : 
    4840             : 
    4841             : /* #line 10 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarStorageClassDeclatationMacros.macro" */
    4842             : 
    4843             : 
    4844             :     public:
    4845             :       void pickOutIRNodeData ( SgTypeFloat128* source );
    4846             :       static void arrangeStaticDataOfEasyStorageClassesInOneBlock ( );
    4847             :       static void deleteStaticDataOfEasyStorageClasses ( );
    4848             :       static void pickOutStaticDataMembers ( );
    4849             :       static void rebuildStaticDataMembers ( );
    4850             :       static void writeEasyStorageDataToFile (std::ostream& out);
    4851             :       static void readEasyStorageDataFromFile (std::istream& in);
    4852             :       static void writeStaticDataToFile (std::ostream& out );
    4853             :       static void readStaticDataFromFile (std::istream& in );
    4854             :       friend class SgTypeFloat128;
    4855             :    };
    4856             : /* #line 4857 "../../../src/frontend/SageIII//StorageClasses.h" */
    4857             : 
    4858             : 
    4859             : 
    4860             : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarStorageClassDeclatationMacros.macro" */
    4861             : /* 
    4862             :    JH (01/01/2006) ROSETTA generated class declarations for SgTypeFixedStorageClass 
    4863             :    used for the ast file IO. Do not chance by hand! 
    4864             : */
    4865           0 : class SgTypeFixedStorageClass  : public SgTypeStorageClass
    4866             :    {
    4867             : 
    4868             :     protected: 
    4869             : 
    4870             : 
    4871             : /* #line 4872 "../../../src/frontend/SageIII//StorageClasses.h" */
    4872             : 
    4873             :      unsigned long storageOf_scale;
    4874             :      unsigned long storageOf_fraction;
    4875             : 
    4876             : 
    4877             : /* #line 10 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarStorageClassDeclatationMacros.macro" */
    4878             : 
    4879             : 
    4880             :     public:
    4881             :       void pickOutIRNodeData ( SgTypeFixed* source );
    4882             :       static void arrangeStaticDataOfEasyStorageClassesInOneBlock ( );
    4883             :       static void deleteStaticDataOfEasyStorageClasses ( );
    4884             :       static void pickOutStaticDataMembers ( );
    4885             :       static void rebuildStaticDataMembers ( );
    4886             :       static void writeEasyStorageDataToFile (std::ostream& out);
    4887             :       static void readEasyStorageDataFromFile (std::istream& in);
    4888             :       static void writeStaticDataToFile (std::ostream& out );
    4889             :       static void readStaticDataFromFile (std::istream& in );
    4890             :       friend class SgTypeFixed;
    4891             :    };
    4892             : /* #line 4893 "../../../src/frontend/SageIII//StorageClasses.h" */
    4893             : 
    4894             : 
    4895             : 
    4896             : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarStorageClassDeclatationMacros.macro" */
    4897             : /* 
    4898             :    JH (01/01/2006) ROSETTA generated class declarations for SgAutoTypeStorageClass 
    4899             :    used for the ast file IO. Do not chance by hand! 
    4900             : */
    4901          28 : class SgAutoTypeStorageClass  : public SgTypeStorageClass
    4902             :    {
    4903             : 
    4904             :     protected: 
    4905             : 
    4906             : 
    4907             : /* #line 4908 "../../../src/frontend/SageIII//StorageClasses.h" */
    4908             : 
    4909             : 
    4910             : 
    4911             : /* #line 10 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarStorageClassDeclatationMacros.macro" */
    4912             : 
    4913             : 
    4914             :     public:
    4915             :       void pickOutIRNodeData ( SgAutoType* source );
    4916             :       static void arrangeStaticDataOfEasyStorageClassesInOneBlock ( );
    4917             :       static void deleteStaticDataOfEasyStorageClasses ( );
    4918             :       static void pickOutStaticDataMembers ( );
    4919             :       static void rebuildStaticDataMembers ( );
    4920             :       static void writeEasyStorageDataToFile (std::ostream& out);
    4921             :       static void readEasyStorageDataFromFile (std::istream& in);
    4922             :       static void writeStaticDataToFile (std::ostream& out );
    4923             :       static void readStaticDataFromFile (std::istream& in );
    4924             :       friend class SgAutoType;
    4925             :    };
    4926             : /* #line 4927 "../../../src/frontend/SageIII//StorageClasses.h" */
    4927             : 
    4928             : 
    4929             : 
    4930             : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarStorageClassDeclatationMacros.macro" */
    4931             : /* 
    4932             :    JH (01/01/2006) ROSETTA generated class declarations for SgLocatedNodeStorageClass 
    4933             :    used for the ast file IO. Do not chance by hand! 
    4934             : */
    4935           0 : class SgLocatedNodeStorageClass  : public SgNodeStorageClass
    4936             :    {
    4937             : 
    4938             :     protected: 
    4939             : 
    4940             : 
    4941             : /* #line 4942 "../../../src/frontend/SageIII//StorageClasses.h" */
    4942             : 
    4943             :      unsigned long storageOf_startOfConstruct;
    4944             :      unsigned long storageOf_endOfConstruct;
    4945             :        EasyStorage < AttachedPreprocessingInfoType* > storageOf_attachedPreprocessingInfoPtr;
    4946             :        EasyStorage < AstAttributeMechanism* > storageOf_attributeMechanism;
    4947             :       bool storageOf_containsTransformationToSurroundingWhitespace;
    4948             : 
    4949             : 
    4950             : /* #line 10 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarStorageClassDeclatationMacros.macro" */
    4951             : 
    4952             : 
    4953             :     public:
    4954             :       void pickOutIRNodeData ( SgLocatedNode* source );
    4955             :       static void arrangeStaticDataOfEasyStorageClassesInOneBlock ( );
    4956             :       static void deleteStaticDataOfEasyStorageClasses ( );
    4957             :       static void pickOutStaticDataMembers ( );
    4958             :       static void rebuildStaticDataMembers ( );
    4959             :       static void writeEasyStorageDataToFile (std::ostream& out);
    4960             :       static void readEasyStorageDataFromFile (std::istream& in);
    4961             :       static void writeStaticDataToFile (std::ostream& out );
    4962             :       static void readStaticDataFromFile (std::istream& in );
    4963             :       friend class SgLocatedNode;
    4964             :    };
    4965             : /* #line 4966 "../../../src/frontend/SageIII//StorageClasses.h" */
    4966             : 
    4967             : 
    4968             : 
    4969             : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarStorageClassDeclatationMacros.macro" */
    4970             : /* 
    4971             :    JH (01/01/2006) ROSETTA generated class declarations for SgTokenStorageClass 
    4972             :    used for the ast file IO. Do not chance by hand! 
    4973             : */
    4974           0 : class SgTokenStorageClass  : public SgLocatedNodeStorageClass
    4975             :    {
    4976             : 
    4977             :     protected: 
    4978             : 
    4979             : 
    4980             : /* #line 4981 "../../../src/frontend/SageIII//StorageClasses.h" */
    4981             : 
    4982             :        EasyStorage < std::string > storageOf_lexeme_string;
    4983             :       unsigned int storageOf_classification_code;
    4984             : 
    4985             : 
    4986             : /* #line 10 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarStorageClassDeclatationMacros.macro" */
    4987             : 
    4988             : 
    4989             :     public:
    4990             :       void pickOutIRNodeData ( SgToken* source );
    4991             :       static void arrangeStaticDataOfEasyStorageClassesInOneBlock ( );
    4992             :       static void deleteStaticDataOfEasyStorageClasses ( );
    4993             :       static void pickOutStaticDataMembers ( );
    4994             :       static void rebuildStaticDataMembers ( );
    4995             :       static void writeEasyStorageDataToFile (std::ostream& out);
    4996             :       static void readEasyStorageDataFromFile (std::istream& in);
    4997             :       static void writeStaticDataToFile (std::ostream& out );
    4998             :       static void readStaticDataFromFile (std::istream& in );
    4999             :       friend class SgToken;
    5000             :    };
    5001             : /* #line 5002 "../../../src/frontend/SageIII//StorageClasses.h" */
    5002             : 
    5003             : 
    5004             : 
    5005             : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarStorageClassDeclatationMacros.macro" */
    5006             : /* 
    5007             :    JH (01/01/2006) ROSETTA generated class declarations for SgLocatedNodeSupportStorageClass 
    5008             :    used for the ast file IO. Do not chance by hand! 
    5009             : */
    5010           0 : class SgLocatedNodeSupportStorageClass  : public SgLocatedNodeStorageClass
    5011             :    {
    5012             : 
    5013             :     protected: 
    5014             : 
    5015             : 
    5016             : /* #line 5017 "../../../src/frontend/SageIII//StorageClasses.h" */
    5017             : 
    5018             : 
    5019             : 
    5020             : /* #line 10 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarStorageClassDeclatationMacros.macro" */
    5021             : 
    5022             : 
    5023             :     public:
    5024             :       void pickOutIRNodeData ( SgLocatedNodeSupport* source );
    5025             :       static void arrangeStaticDataOfEasyStorageClassesInOneBlock ( );
    5026             :       static void deleteStaticDataOfEasyStorageClasses ( );
    5027             :       static void pickOutStaticDataMembers ( );
    5028             :       static void rebuildStaticDataMembers ( );
    5029             :       static void writeEasyStorageDataToFile (std::ostream& out);
    5030             :       static void readEasyStorageDataFromFile (std::istream& in);
    5031             :       static void writeStaticDataToFile (std::ostream& out );
    5032             :       static void readStaticDataFromFile (std::istream& in );
    5033             :       friend class SgLocatedNodeSupport;
    5034             :    };
    5035             : /* #line 5036 "../../../src/frontend/SageIII//StorageClasses.h" */
    5036             : 
    5037             : 
    5038             : 
    5039             : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarStorageClassDeclatationMacros.macro" */
    5040             : /* 
    5041             :    JH (01/01/2006) ROSETTA generated class declarations for SgCommonBlockObjectStorageClass 
    5042             :    used for the ast file IO. Do not chance by hand! 
    5043             : */
    5044           0 : class SgCommonBlockObjectStorageClass  : public SgLocatedNodeSupportStorageClass
    5045             :    {
    5046             : 
    5047             :     protected: 
    5048             : 
    5049             : 
    5050             : /* #line 5051 "../../../src/frontend/SageIII//StorageClasses.h" */
    5051             : 
    5052             :        EasyStorage < std::string > storageOf_block_name;
    5053             :      unsigned long storageOf_variable_reference_list;
    5054             : 
    5055             : 
    5056             : /* #line 10 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarStorageClassDeclatationMacros.macro" */
    5057             : 
    5058             : 
    5059             :     public:
    5060             :       void pickOutIRNodeData ( SgCommonBlockObject* source );
    5061             :       static void arrangeStaticDataOfEasyStorageClassesInOneBlock ( );
    5062             :       static void deleteStaticDataOfEasyStorageClasses ( );
    5063             :       static void pickOutStaticDataMembers ( );
    5064             :       static void rebuildStaticDataMembers ( );
    5065             :       static void writeEasyStorageDataToFile (std::ostream& out);
    5066             :       static void readEasyStorageDataFromFile (std::istream& in);
    5067             :       static void writeStaticDataToFile (std::ostream& out );
    5068             :       static void readStaticDataFromFile (std::istream& in );
    5069             :       friend class SgCommonBlockObject;
    5070             :    };
    5071             : /* #line 5072 "../../../src/frontend/SageIII//StorageClasses.h" */
    5072             : 
    5073             : 
    5074             : 
    5075             : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarStorageClassDeclatationMacros.macro" */
    5076             : /* 
    5077             :    JH (01/01/2006) ROSETTA generated class declarations for SgInitializedNameStorageClass 
    5078             :    used for the ast file IO. Do not chance by hand! 
    5079             : */
    5080      110450 : class SgInitializedNameStorageClass  : public SgLocatedNodeSupportStorageClass
    5081             :    {
    5082             : 
    5083             :     protected: 
    5084             : 
    5085             : 
    5086             : /* #line 5087 "../../../src/frontend/SageIII//StorageClasses.h" */
    5087             : 
    5088             :       SgNameStorageClass storageOf_name;
    5089             :        EasyStorage < std::string > storageOf_microsoft_uuid_string;
    5090             :      unsigned long storageOf_typeptr;
    5091             :      unsigned long storageOf_initptr;
    5092             :      unsigned long storageOf_prev_decl_item;
    5093             :       bool storageOf_is_initializer;
    5094             :      unsigned long storageOf_declptr;
    5095             :      unsigned long storageOf_storageModifier;
    5096             :      unsigned long storageOf_scope;
    5097             :       SgInitializedName::preinitialization_enum storageOf_preinitialization;
    5098             :       bool storageOf_isCoArray;
    5099             :       SgInitializedName::asm_register_name_enum storageOf_register_name_code;
    5100             :       SgInitializedName::excess_specifier_enum storageOf_excess_specifier;
    5101             :        EasyStorage < std::string > storageOf_register_name_string;
    5102             :       bool storageOf_requiresGlobalNameQualificationOnType;
    5103             :       bool storageOf_shapeDeferred;
    5104             :       bool storageOf_initializationDeferred;
    5105             :        EasyStorage < SgBitVector > storageOf_gnu_attribute_modifierVector;
    5106             :       unsigned long int storageOf_gnu_attribute_initialization_priority;
    5107             :        EasyStorage < std::string > storageOf_gnu_attribute_named_weak_reference;
    5108             :        EasyStorage < std::string > storageOf_gnu_attribute_named_alias;
    5109             :        EasyStorage < std::string > storageOf_gnu_attribute_cleanup_function;
    5110             :        EasyStorage < std::string > storageOf_gnu_attribute_section_name;
    5111             :       int storageOf_gnu_attribute_alignment;
    5112             :       SgDeclarationModifier::gnu_declaration_visability_enum storageOf_gnu_attribute_visability;
    5113             :       bool storageOf_protected_declaration;
    5114             :       int storageOf_name_qualification_length;
    5115             :       bool storageOf_type_elaboration_required;
    5116             :       bool storageOf_global_qualification_required;
    5117             :       int storageOf_name_qualification_length_for_type;
    5118             :       bool storageOf_type_elaboration_required_for_type;
    5119             :       bool storageOf_global_qualification_required_for_type;
    5120             :       bool storageOf_hasArrayTypeWithEmptyBracketSyntax;
    5121             :       bool storageOf_using_C11_Alignas_keyword;
    5122             :      unsigned long storageOf_constant_or_type_argument_for_Alignas_keyword;
    5123             :       bool storageOf_using_auto_keyword;
    5124             :      unsigned long storageOf_auto_decltype;
    5125             :       bool storageOf_using_device_keyword;
    5126             :       bool storageOf_is_braced_initialized;
    5127             :       bool storageOf_using_assignment_copy_constructor_syntax;
    5128             :       bool storageOf_needs_definitions;
    5129             :       bool storageOf_is_parameter_pack;
    5130             :       bool storageOf_is_pack_element;
    5131             : 
    5132             : 
    5133             : /* #line 10 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarStorageClassDeclatationMacros.macro" */
    5134             : 
    5135             : 
    5136             :     public:
    5137             :       void pickOutIRNodeData ( SgInitializedName* source );
    5138             :       static void arrangeStaticDataOfEasyStorageClassesInOneBlock ( );
    5139             :       static void deleteStaticDataOfEasyStorageClasses ( );
    5140             :       static void pickOutStaticDataMembers ( );
    5141             :       static void rebuildStaticDataMembers ( );
    5142             :       static void writeEasyStorageDataToFile (std::ostream& out);
    5143             :       static void readEasyStorageDataFromFile (std::istream& in);
    5144             :       static void writeStaticDataToFile (std::ostream& out );
    5145             :       static void readStaticDataFromFile (std::istream& in );
    5146             :       friend class SgInitializedName;
    5147             :    };
    5148             : /* #line 5149 "../../../src/frontend/SageIII//StorageClasses.h" */
    5149             : 
    5150             : 
    5151             : 
    5152             : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarStorageClassDeclatationMacros.macro" */
    5153             : /* 
    5154             :    JH (01/01/2006) ROSETTA generated class declarations for SgInterfaceBodyStorageClass 
    5155             :    used for the ast file IO. Do not chance by hand! 
    5156             : */
    5157           0 : class SgInterfaceBodyStorageClass  : public SgLocatedNodeSupportStorageClass
    5158             :    {
    5159             : 
    5160             :     protected: 
    5161             : 
    5162             : 
    5163             : /* #line 5164 "../../../src/frontend/SageIII//StorageClasses.h" */
    5164             : 
    5165             :       SgNameStorageClass storageOf_function_name;
    5166             :      unsigned long storageOf_functionDeclaration;
    5167             :       bool storageOf_use_function_name;
    5168             : 
    5169             : 
    5170             : /* #line 10 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarStorageClassDeclatationMacros.macro" */
    5171             : 
    5172             : 
    5173             :     public:
    5174             :       void pickOutIRNodeData ( SgInterfaceBody* source );
    5175             :       static void arrangeStaticDataOfEasyStorageClassesInOneBlock ( );
    5176             :       static void deleteStaticDataOfEasyStorageClasses ( );
    5177             :       static void pickOutStaticDataMembers ( );
    5178             :       static void rebuildStaticDataMembers ( );
    5179             :       static void writeEasyStorageDataToFile (std::ostream& out);
    5180             :       static void readEasyStorageDataFromFile (std::istream& in);
    5181             :       static void writeStaticDataToFile (std::ostream& out );
    5182             :       static void readStaticDataFromFile (std::istream& in );
    5183             :       friend class SgInterfaceBody;
    5184             :    };
    5185             : /* #line 5186 "../../../src/frontend/SageIII//StorageClasses.h" */
    5186             : 
    5187             : 
    5188             : 
    5189             : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarStorageClassDeclatationMacros.macro" */
    5190             : /* 
    5191             :    JH (01/01/2006) ROSETTA generated class declarations for SgHeaderFileBodyStorageClass 
    5192             :    used for the ast file IO. Do not chance by hand! 
    5193             : */
    5194           0 : class SgHeaderFileBodyStorageClass  : public SgLocatedNodeSupportStorageClass
    5195             :    {
    5196             : 
    5197             :     protected: 
    5198             : 
    5199             : 
    5200             : /* #line 5201 "../../../src/frontend/SageIII//StorageClasses.h" */
    5201             : 
    5202             :      unsigned long storageOf_include_file;
    5203             : 
    5204             : 
    5205             : /* #line 10 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarStorageClassDeclatationMacros.macro" */
    5206             : 
    5207             : 
    5208             :     public:
    5209             :       void pickOutIRNodeData ( SgHeaderFileBody* source );
    5210             :       static void arrangeStaticDataOfEasyStorageClassesInOneBlock ( );
    5211             :       static void deleteStaticDataOfEasyStorageClasses ( );
    5212             :       static void pickOutStaticDataMembers ( );
    5213             :       static void rebuildStaticDataMembers ( );
    5214             :       static void writeEasyStorageDataToFile (std::ostream& out);
    5215             :       static void readEasyStorageDataFromFile (std::istream& in);
    5216             :       static void writeStaticDataToFile (std::ostream& out );
    5217             :       static void readStaticDataFromFile (std::istream& in );
    5218             :       friend class SgHeaderFileBody;
    5219             :    };
    5220             : /* #line 5221 "../../../src/frontend/SageIII//StorageClasses.h" */
    5221             : 
    5222             : 
    5223             : 
    5224             : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarStorageClassDeclatationMacros.macro" */
    5225             : /* 
    5226             :    JH (01/01/2006) ROSETTA generated class declarations for SgRenamePairStorageClass 
    5227             :    used for the ast file IO. Do not chance by hand! 
    5228             : */
    5229           0 : class SgRenamePairStorageClass  : public SgLocatedNodeSupportStorageClass
    5230             :    {
    5231             : 
    5232             :     protected: 
    5233             : 
    5234             : 
    5235             : /* #line 5236 "../../../src/frontend/SageIII//StorageClasses.h" */
    5236             : 
    5237             :       SgNameStorageClass storageOf_local_name;
    5238             :       SgNameStorageClass storageOf_use_name;
    5239             : 
    5240             : 
    5241             : /* #line 10 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarStorageClassDeclatationMacros.macro" */
    5242             : 
    5243             : 
    5244             :     public:
    5245             :       void pickOutIRNodeData ( SgRenamePair* source );
    5246             :       static void arrangeStaticDataOfEasyStorageClassesInOneBlock ( );
    5247             :       static void deleteStaticDataOfEasyStorageClasses ( );
    5248             :       static void pickOutStaticDataMembers ( );
    5249             :       static void rebuildStaticDataMembers ( );
    5250             :       static void writeEasyStorageDataToFile (std::ostream& out);
    5251             :       static void readEasyStorageDataFromFile (std::istream& in);
    5252             :       static void writeStaticDataToFile (std::ostream& out );
    5253             :       static void readStaticDataFromFile (std::istream& in );
    5254             :       friend class SgRenamePair;
    5255             :    };
    5256             : /* #line 5257 "../../../src/frontend/SageIII//StorageClasses.h" */
    5257             : 
    5258             : 
    5259             : 
    5260             : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarStorageClassDeclatationMacros.macro" */
    5261             : /* 
    5262             :    JH (01/01/2006) ROSETTA generated class declarations for SgOmpClauseStorageClass 
    5263             :    used for the ast file IO. Do not chance by hand! 
    5264             : */
    5265           0 : class SgOmpClauseStorageClass  : public SgLocatedNodeSupportStorageClass
    5266             :    {
    5267             : 
    5268             :     protected: 
    5269             : 
    5270             : 
    5271             : /* #line 5272 "../../../src/frontend/SageIII//StorageClasses.h" */
    5272             : 
    5273             : 
    5274             : 
    5275             : /* #line 10 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarStorageClassDeclatationMacros.macro" */
    5276             : 
    5277             : 
    5278             :     public:
    5279             :       void pickOutIRNodeData ( SgOmpClause* source );
    5280             :       static void arrangeStaticDataOfEasyStorageClassesInOneBlock ( );
    5281             :       static void deleteStaticDataOfEasyStorageClasses ( );
    5282             :       static void pickOutStaticDataMembers ( );
    5283             :       static void rebuildStaticDataMembers ( );
    5284             :       static void writeEasyStorageDataToFile (std::ostream& out);
    5285             :       static void readEasyStorageDataFromFile (std::istream& in);
    5286             :       static void writeStaticDataToFile (std::ostream& out );
    5287             :       static void readStaticDataFromFile (std::istream& in );
    5288             :       friend class SgOmpClause;
    5289             :    };
    5290             : /* #line 5291 "../../../src/frontend/SageIII//StorageClasses.h" */
    5291             : 
    5292             : 
    5293             : 
    5294             : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarStorageClassDeclatationMacros.macro" */
    5295             : /* 
    5296             :    JH (01/01/2006) ROSETTA generated class declarations for SgOmpNowaitClauseStorageClass 
    5297             :    used for the ast file IO. Do not chance by hand! 
    5298             : */
    5299           0 : class SgOmpNowaitClauseStorageClass  : public SgOmpClauseStorageClass
    5300             :    {
    5301             : 
    5302             :     protected: 
    5303             : 
    5304             : 
    5305             : /* #line 5306 "../../../src/frontend/SageIII//StorageClasses.h" */
    5306             : 
    5307             : 
    5308             : 
    5309             : /* #line 10 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarStorageClassDeclatationMacros.macro" */
    5310             : 
    5311             : 
    5312             :     public:
    5313             :       void pickOutIRNodeData ( SgOmpNowaitClause* source );
    5314             :       static void arrangeStaticDataOfEasyStorageClassesInOneBlock ( );
    5315             :       static void deleteStaticDataOfEasyStorageClasses ( );
    5316             :       static void pickOutStaticDataMembers ( );
    5317             :       static void rebuildStaticDataMembers ( );
    5318             :       static void writeEasyStorageDataToFile (std::ostream& out);
    5319             :       static void readEasyStorageDataFromFile (std::istream& in);
    5320             :       static void writeStaticDataToFile (std::ostream& out );
    5321             :       static void readStaticDataFromFile (std::istream& in );
    5322             :       friend class SgOmpNowaitClause;
    5323             :    };
    5324             : /* #line 5325 "../../../src/frontend/SageIII//StorageClasses.h" */
    5325             : 
    5326             : 
    5327             : 
    5328             : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarStorageClassDeclatationMacros.macro" */
    5329             : /* 
    5330             :    JH (01/01/2006) ROSETTA generated class declarations for SgOmpReadClauseStorageClass 
    5331             :    used for the ast file IO. Do not chance by hand! 
    5332             : */
    5333           0 : class SgOmpReadClauseStorageClass  : public SgOmpClauseStorageClass
    5334             :    {
    5335             : 
    5336             :     protected: 
    5337             : 
    5338             : 
    5339             : /* #line 5340 "../../../src/frontend/SageIII//StorageClasses.h" */
    5340             : 
    5341             : 
    5342             : 
    5343             : /* #line 10 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarStorageClassDeclatationMacros.macro" */
    5344             : 
    5345             : 
    5346             :     public:
    5347             :       void pickOutIRNodeData ( SgOmpReadClause* source );
    5348             :       static void arrangeStaticDataOfEasyStorageClassesInOneBlock ( );
    5349             :       static void deleteStaticDataOfEasyStorageClasses ( );
    5350             :       static void pickOutStaticDataMembers ( );
    5351             :       static void rebuildStaticDataMembers ( );
    5352             :       static void writeEasyStorageDataToFile (std::ostream& out);
    5353             :       static void readEasyStorageDataFromFile (std::istream& in);
    5354             :       static void writeStaticDataToFile (std::ostream& out );
    5355             :       static void readStaticDataFromFile (std::istream& in );
    5356             :       friend class SgOmpReadClause;
    5357             :    };
    5358             : /* #line 5359 "../../../src/frontend/SageIII//StorageClasses.h" */
    5359             : 
    5360             : 
    5361             : 
    5362             : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarStorageClassDeclatationMacros.macro" */
    5363             : /* 
    5364             :    JH (01/01/2006) ROSETTA generated class declarations for SgOmpThreadsClauseStorageClass 
    5365             :    used for the ast file IO. Do not chance by hand! 
    5366             : */
    5367           0 : class SgOmpThreadsClauseStorageClass  : public SgOmpClauseStorageClass
    5368             :    {
    5369             : 
    5370             :     protected: 
    5371             : 
    5372             : 
    5373             : /* #line 5374 "../../../src/frontend/SageIII//StorageClasses.h" */
    5374             : 
    5375             : 
    5376             : 
    5377             : /* #line 10 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarStorageClassDeclatationMacros.macro" */
    5378             : 
    5379             : 
    5380             :     public:
    5381             :       void pickOutIRNodeData ( SgOmpThreadsClause* source );
    5382             :       static void arrangeStaticDataOfEasyStorageClassesInOneBlock ( );
    5383             :       static void deleteStaticDataOfEasyStorageClasses ( );
    5384             :       static void pickOutStaticDataMembers ( );
    5385             :       static void rebuildStaticDataMembers ( );
    5386             :       static void writeEasyStorageDataToFile (std::ostream& out);
    5387             :       static void readEasyStorageDataFromFile (std::istream& in);
    5388             :       static void writeStaticDataToFile (std::ostream& out );
    5389             :       static void readStaticDataFromFile (std::istream& in );
    5390             :       friend class SgOmpThreadsClause;
    5391             :    };
    5392             : /* #line 5393 "../../../src/frontend/SageIII//StorageClasses.h" */
    5393             : 
    5394             : 
    5395             : 
    5396             : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarStorageClassDeclatationMacros.macro" */
    5397             : /* 
    5398             :    JH (01/01/2006) ROSETTA generated class declarations for SgOmpSimdClauseStorageClass 
    5399             :    used for the ast file IO. Do not chance by hand! 
    5400             : */
    5401           0 : class SgOmpSimdClauseStorageClass  : public SgOmpClauseStorageClass
    5402             :    {
    5403             : 
    5404             :     protected: 
    5405             : 
    5406             : 
    5407             : /* #line 5408 "../../../src/frontend/SageIII//StorageClasses.h" */
    5408             : 
    5409             : 
    5410             : 
    5411             : /* #line 10 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarStorageClassDeclatationMacros.macro" */
    5412             : 
    5413             : 
    5414             :     public:
    5415             :       void pickOutIRNodeData ( SgOmpSimdClause* source );
    5416             :       static void arrangeStaticDataOfEasyStorageClassesInOneBlock ( );
    5417             :       static void deleteStaticDataOfEasyStorageClasses ( );
    5418             :       static void pickOutStaticDataMembers ( );
    5419             :       static void rebuildStaticDataMembers ( );
    5420             :       static void writeEasyStorageDataToFile (std::ostream& out);
    5421             :       static void readEasyStorageDataFromFile (std::istream& in);
    5422             :       static void writeStaticDataToFile (std::ostream& out );
    5423             :       static void readStaticDataFromFile (std::istream& in );
    5424             :       friend class SgOmpSimdClause;
    5425             :    };
    5426             : /* #line 5427 "../../../src/frontend/SageIII//StorageClasses.h" */
    5427             : 
    5428             : 
    5429             : 
    5430             : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarStorageClassDeclatationMacros.macro" */
    5431             : /* 
    5432             :    JH (01/01/2006) ROSETTA generated class declarations for SgOmpWriteClauseStorageClass 
    5433             :    used for the ast file IO. Do not chance by hand! 
    5434             : */
    5435           0 : class SgOmpWriteClauseStorageClass  : public SgOmpClauseStorageClass
    5436             :    {
    5437             : 
    5438             :     protected: 
    5439             : 
    5440             : 
    5441             : /* #line 5442 "../../../src/frontend/SageIII//StorageClasses.h" */
    5442             : 
    5443             : 
    5444             : 
    5445             : /* #line 10 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarStorageClassDeclatationMacros.macro" */
    5446             : 
    5447             : 
    5448             :     public:
    5449             :       void pickOutIRNodeData ( SgOmpWriteClause* source );
    5450             :       static void arrangeStaticDataOfEasyStorageClassesInOneBlock ( );
    5451             :       static void deleteStaticDataOfEasyStorageClasses ( );
    5452             :       static void pickOutStaticDataMembers ( );
    5453             :       static void rebuildStaticDataMembers ( );
    5454             :       static void writeEasyStorageDataToFile (std::ostream& out);
    5455             :       static void readEasyStorageDataFromFile (std::istream& in);
    5456             :       static void writeStaticDataToFile (std::ostream& out );
    5457             :       static void readStaticDataFromFile (std::istream& in );
    5458             :       friend class SgOmpWriteClause;
    5459             :    };
    5460             : /* #line 5461 "../../../src/frontend/SageIII//StorageClasses.h" */
    5461             : 
    5462             : 
    5463             : 
    5464             : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarStorageClassDeclatationMacros.macro" */
    5465             : /* 
    5466             :    JH (01/01/2006) ROSETTA generated class declarations for SgOmpUpdateClauseStorageClass 
    5467             :    used for the ast file IO. Do not chance by hand! 
    5468             : */
    5469           0 : class SgOmpUpdateClauseStorageClass  : public SgOmpClauseStorageClass
    5470             :    {
    5471             : 
    5472             :     protected: 
    5473             : 
    5474             : 
    5475             : /* #line 5476 "../../../src/frontend/SageIII//StorageClasses.h" */
    5476             : 
    5477             : 
    5478             : 
    5479             : /* #line 10 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarStorageClassDeclatationMacros.macro" */
    5480             : 
    5481             : 
    5482             :     public:
    5483             :       void pickOutIRNodeData ( SgOmpUpdateClause* source );
    5484             :       static void arrangeStaticDataOfEasyStorageClassesInOneBlock ( );
    5485             :       static void deleteStaticDataOfEasyStorageClasses ( );
    5486             :       static void pickOutStaticDataMembers ( );
    5487             :       static void rebuildStaticDataMembers ( );
    5488             :       static void writeEasyStorageDataToFile (std::ostream& out);
    5489             :       static void readEasyStorageDataFromFile (std::istream& in);
    5490             :       static void writeStaticDataToFile (std::ostream& out );
    5491             :       static void readStaticDataFromFile (std::istream& in );
    5492             :       friend class SgOmpUpdateClause;
    5493             :    };
    5494             : /* #line 5495 "../../../src/frontend/SageIII//StorageClasses.h" */
    5495             : 
    5496             : 
    5497             : 
    5498             : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarStorageClassDeclatationMacros.macro" */
    5499             : /* 
    5500             :    JH (01/01/2006) ROSETTA generated class declarations for SgOmpDepobjUpdateClauseStorageClass 
    5501             :    used for the ast file IO. Do not chance by hand! 
    5502             : */
    5503           0 : class SgOmpDepobjUpdateClauseStorageClass  : public SgOmpClauseStorageClass
    5504             :    {
    5505             : 
    5506             :     protected: 
    5507             : 
    5508             : 
    5509             : /* #line 5510 "../../../src/frontend/SageIII//StorageClasses.h" */
    5510             : 
    5511             :       SgOmpClause::omp_depobj_modifier_enum storageOf_modifier;
    5512             : 
    5513             : 
    5514             : /* #line 10 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarStorageClassDeclatationMacros.macro" */
    5515             : 
    5516             : 
    5517             :     public:
    5518             :       void pickOutIRNodeData ( SgOmpDepobjUpdateClause* source );
    5519             :       static void arrangeStaticDataOfEasyStorageClassesInOneBlock ( );
    5520             :       static void deleteStaticDataOfEasyStorageClasses ( );
    5521             :       static void pickOutStaticDataMembers ( );
    5522             :       static void rebuildStaticDataMembers ( );
    5523             :       static void writeEasyStorageDataToFile (std::ostream& out);
    5524             :       static void readEasyStorageDataFromFile (std::istream& in);
    5525             :       static void writeStaticDataToFile (std::ostream& out );
    5526             :       static void readStaticDataFromFile (std::istream& in );
    5527             :       friend class SgOmpDepobjUpdateClause;
    5528             :    };
    5529             : /* #line 5530 "../../../src/frontend/SageIII//StorageClasses.h" */
    5530             : 
    5531             : 
    5532             : 
    5533             : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarStorageClassDeclatationMacros.macro" */
    5534             : /* 
    5535             :    JH (01/01/2006) ROSETTA generated class declarations for SgOmpDestroyClauseStorageClass 
    5536             :    used for the ast file IO. Do not chance by hand! 
    5537             : */
    5538           0 : class SgOmpDestroyClauseStorageClass  : public SgOmpClauseStorageClass
    5539             :    {
    5540             : 
    5541             :     protected: 
    5542             : 
    5543             : 
    5544             : /* #line 5545 "../../../src/frontend/SageIII//StorageClasses.h" */
    5545             : 
    5546             : 
    5547             : 
    5548             : /* #line 10 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarStorageClassDeclatationMacros.macro" */
    5549             : 
    5550             : 
    5551             :     public:
    5552             :       void pickOutIRNodeData ( SgOmpDestroyClause* source );
    5553             :       static void arrangeStaticDataOfEasyStorageClassesInOneBlock ( );
    5554             :       static void deleteStaticDataOfEasyStorageClasses ( );
    5555             :       static void pickOutStaticDataMembers ( );
    5556             :       static void rebuildStaticDataMembers ( );
    5557             :       static void writeEasyStorageDataToFile (std::ostream& out);
    5558             :       static void readEasyStorageDataFromFile (std::istream& in);
    5559             :       static void writeStaticDataToFile (std::ostream& out );
    5560             :       static void readStaticDataFromFile (std::istream& in );
    5561             :       friend class SgOmpDestroyClause;
    5562             :    };
    5563             : /* #line 5564 "../../../src/frontend/SageIII//StorageClasses.h" */
    5564             : 
    5565             : 
    5566             : 
    5567             : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarStorageClassDeclatationMacros.macro" */
    5568             : /* 
    5569             :    JH (01/01/2006) ROSETTA generated class declarations for SgOmpCaptureClauseStorageClass 
    5570             :    used for the ast file IO. Do not chance by hand! 
    5571             : */
    5572           0 : class SgOmpCaptureClauseStorageClass  : public SgOmpClauseStorageClass
    5573             :    {
    5574             : 
    5575             :     protected: 
    5576             : 
    5577             : 
    5578             : /* #line 5579 "../../../src/frontend/SageIII//StorageClasses.h" */
    5579             : 
    5580             : 
    5581             : 
    5582             : /* #line 10 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarStorageClassDeclatationMacros.macro" */
    5583             : 
    5584             : 
    5585             :     public:
    5586             :       void pickOutIRNodeData ( SgOmpCaptureClause* source );
    5587             :       static void arrangeStaticDataOfEasyStorageClassesInOneBlock ( );
    5588             :       static void deleteStaticDataOfEasyStorageClasses ( );
    5589             :       static void pickOutStaticDataMembers ( );
    5590             :       static void rebuildStaticDataMembers ( );
    5591             :       static void writeEasyStorageDataToFile (std::ostream& out);
    5592             :       static void readEasyStorageDataFromFile (std::istream& in);
    5593             :       static void writeStaticDataToFile (std::ostream& out );
    5594             :       static void readStaticDataFromFile (std::istream& in );
    5595             :       friend class SgOmpCaptureClause;
    5596             :    };
    5597             : /* #line 5598 "../../../src/frontend/SageIII//StorageClasses.h" */
    5598             : 
    5599             : 
    5600             : 
    5601             : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarStorageClassDeclatationMacros.macro" */
    5602             : /* 
    5603             :    JH (01/01/2006) ROSETTA generated class declarations for SgOmpBeginClauseStorageClass 
    5604             :    used for the ast file IO. Do not chance by hand! 
    5605             : */
    5606           0 : class SgOmpBeginClauseStorageClass  : public SgOmpClauseStorageClass
    5607             :    {
    5608             : 
    5609             :     protected: 
    5610             : 
    5611             : 
    5612             : /* #line 5613 "../../../src/frontend/SageIII//StorageClasses.h" */
    5613             : 
    5614             : 
    5615             : 
    5616             : /* #line 10 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarStorageClassDeclatationMacros.macro" */
    5617             : 
    5618             : 
    5619             :     public:
    5620             :       void pickOutIRNodeData ( SgOmpBeginClause* source );
    5621             :       static void arrangeStaticDataOfEasyStorageClassesInOneBlock ( );
    5622             :       static void deleteStaticDataOfEasyStorageClasses ( );
    5623             :       static void pickOutStaticDataMembers ( );
    5624             :       static void rebuildStaticDataMembers ( );
    5625             :       static void writeEasyStorageDataToFile (std::ostream& out);
    5626             :       static void readEasyStorageDataFromFile (std::istream& in);
    5627             :       static void writeStaticDataToFile (std::ostream& out );
    5628             :       static void readStaticDataFromFile (std::istream& in );
    5629             :       friend class SgOmpBeginClause;
    5630             :    };
    5631             : /* #line 5632 "../../../src/frontend/SageIII//StorageClasses.h" */
    5632             : 
    5633             : 
    5634             : 
    5635             : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarStorageClassDeclatationMacros.macro" */
    5636             : /* 
    5637             :    JH (01/01/2006) ROSETTA generated class declarations for SgOmpEndClauseStorageClass 
    5638             :    used for the ast file IO. Do not chance by hand! 
    5639             : */
    5640           0 : class SgOmpEndClauseStorageClass  : public SgOmpClauseStorageClass
    5641             :    {
    5642             : 
    5643             :     protected: 
    5644             : 
    5645             : 
    5646             : /* #line 5647 "../../../src/frontend/SageIII//StorageClasses.h" */
    5647             : 
    5648             : 
    5649             : 
    5650             : /* #line 10 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarStorageClassDeclatationMacros.macro" */
    5651             : 
    5652             : 
    5653             :     public:
    5654             :       void pickOutIRNodeData ( SgOmpEndClause* source );
    5655             :       static void arrangeStaticDataOfEasyStorageClassesInOneBlock ( );
    5656             :       static void deleteStaticDataOfEasyStorageClasses ( );
    5657             :       static void pickOutStaticDataMembers ( );
    5658             :       static void rebuildStaticDataMembers ( );
    5659             :       static void writeEasyStorageDataToFile (std::ostream& out);
    5660             :       static void readEasyStorageDataFromFile (std::istream& in);
    5661             :       static void writeStaticDataToFile (std::ostream& out );
    5662             :       static void readStaticDataFromFile (std::istream& in );
    5663             :       friend class SgOmpEndClause;
    5664             :    };
    5665             : /* #line 5666 "../../../src/frontend/SageIII//StorageClasses.h" */
    5666             : 
    5667             : 
    5668             : 
    5669             : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarStorageClassDeclatationMacros.macro" */
    5670             : /* 
    5671             :    JH (01/01/2006) ROSETTA generated class declarations for SgOmpUntiedClauseStorageClass 
    5672             :    used for the ast file IO. Do not chance by hand! 
    5673             : */
    5674           0 : class SgOmpUntiedClauseStorageClass  : public SgOmpClauseStorageClass
    5675             :    {
    5676             : 
    5677             :     protected: 
    5678             : 
    5679             : 
    5680             : /* #line 5681 "../../../src/frontend/SageIII//StorageClasses.h" */
    5681             : 
    5682             : 
    5683             : 
    5684             : /* #line 10 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarStorageClassDeclatationMacros.macro" */
    5685             : 
    5686             : 
    5687             :     public:
    5688             :       void pickOutIRNodeData ( SgOmpUntiedClause* source );
    5689             :       static void arrangeStaticDataOfEasyStorageClassesInOneBlock ( );
    5690             :       static void deleteStaticDataOfEasyStorageClasses ( );
    5691             :       static void pickOutStaticDataMembers ( );
    5692             :       static void rebuildStaticDataMembers ( );
    5693             :       static void writeEasyStorageDataToFile (std::ostream& out);
    5694             :       static void readEasyStorageDataFromFile (std::istream& in);
    5695             :       static void writeStaticDataToFile (std::ostream& out );
    5696             :       static void readStaticDataFromFile (std::istream& in );
    5697             :       friend class SgOmpUntiedClause;
    5698             :    };
    5699             : /* #line 5700 "../../../src/frontend/SageIII//StorageClasses.h" */
    5700             : 
    5701             : 
    5702             : 
    5703             : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarStorageClassDeclatationMacros.macro" */
    5704             : /* 
    5705             :    JH (01/01/2006) ROSETTA generated class declarations for SgOmpSeqCstClauseStorageClass 
    5706             :    used for the ast file IO. Do not chance by hand! 
    5707             : */
    5708           0 : class SgOmpSeqCstClauseStorageClass  : public SgOmpClauseStorageClass
    5709             :    {
    5710             : 
    5711             :     protected: 
    5712             : 
    5713             : 
    5714             : /* #line 5715 "../../../src/frontend/SageIII//StorageClasses.h" */
    5715             : 
    5716             : 
    5717             : 
    5718             : /* #line 10 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarStorageClassDeclatationMacros.macro" */
    5719             : 
    5720             : 
    5721             :     public:
    5722             :       void pickOutIRNodeData ( SgOmpSeqCstClause* source );
    5723             :       static void arrangeStaticDataOfEasyStorageClassesInOneBlock ( );
    5724             :       static void deleteStaticDataOfEasyStorageClasses ( );
    5725             :       static void pickOutStaticDataMembers ( );
    5726             :       static void rebuildStaticDataMembers ( );
    5727             :       static void writeEasyStorageDataToFile (std::ostream& out);
    5728             :       static void readEasyStorageDataFromFile (std::istream& in);
    5729             :       static void writeStaticDataToFile (std::ostream& out );
    5730             :       static void readStaticDataFromFile (std::istream& in );
    5731             :       friend class SgOmpSeqCstClause;
    5732             :    };
    5733             : /* #line 5734 "../../../src/frontend/SageIII//StorageClasses.h" */
    5734             : 
    5735             : 
    5736             : 
    5737             : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarStorageClassDeclatationMacros.macro" */
    5738             : /* 
    5739             :    JH (01/01/2006) ROSETTA generated class declarations for SgOmpAcqRelClauseStorageClass 
    5740             :    used for the ast file IO. Do not chance by hand! 
    5741             : */
    5742           0 : class SgOmpAcqRelClauseStorageClass  : public SgOmpClauseStorageClass
    5743             :    {
    5744             : 
    5745             :     protected: 
    5746             : 
    5747             : 
    5748             : /* #line 5749 "../../../src/frontend/SageIII//StorageClasses.h" */
    5749             : 
    5750             : 
    5751             : 
    5752             : /* #line 10 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarStorageClassDeclatationMacros.macro" */
    5753             : 
    5754             : 
    5755             :     public:
    5756             :       void pickOutIRNodeData ( SgOmpAcqRelClause* source );
    5757             :       static void arrangeStaticDataOfEasyStorageClassesInOneBlock ( );
    5758             :       static void deleteStaticDataOfEasyStorageClasses ( );
    5759             :       static void pickOutStaticDataMembers ( );
    5760             :       static void rebuildStaticDataMembers ( );
    5761             :       static void writeEasyStorageDataToFile (std::ostream& out);
    5762             :       static void readEasyStorageDataFromFile (std::istream& in);
    5763             :       static void writeStaticDataToFile (std::ostream& out );
    5764             :       static void readStaticDataFromFile (std::istream& in );
    5765             :       friend class SgOmpAcqRelClause;
    5766             :    };
    5767             : /* #line 5768 "../../../src/frontend/SageIII//StorageClasses.h" */
    5768             : 
    5769             : 
    5770             : 
    5771             : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarStorageClassDeclatationMacros.macro" */
    5772             : /* 
    5773             :    JH (01/01/2006) ROSETTA generated class declarations for SgOmpReleaseClauseStorageClass 
    5774             :    used for the ast file IO. Do not chance by hand! 
    5775             : */
    5776           0 : class SgOmpReleaseClauseStorageClass  : public SgOmpClauseStorageClass
    5777             :    {
    5778             : 
    5779             :     protected: 
    5780             : 
    5781             : 
    5782             : /* #line 5783 "../../../src/frontend/SageIII//StorageClasses.h" */
    5783             : 
    5784             : 
    5785             : 
    5786             : /* #line 10 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarStorageClassDeclatationMacros.macro" */
    5787             : 
    5788             : 
    5789             :     public:
    5790             :       void pickOutIRNodeData ( SgOmpReleaseClause* source );
    5791             :       static void arrangeStaticDataOfEasyStorageClassesInOneBlock ( );
    5792             :       static void deleteStaticDataOfEasyStorageClasses ( );
    5793             :       static void pickOutStaticDataMembers ( );
    5794             :       static void rebuildStaticDataMembers ( );
    5795             :       static void writeEasyStorageDataToFile (std::ostream& out);
    5796             :       static void readEasyStorageDataFromFile (std::istream& in);
    5797             :       static void writeStaticDataToFile (std::ostream& out );
    5798             :       static void readStaticDataFromFile (std::istream& in );
    5799             :       friend class SgOmpReleaseClause;
    5800             :    };
    5801             : /* #line 5802 "../../../src/frontend/SageIII//StorageClasses.h" */
    5802             : 
    5803             : 
    5804             : 
    5805             : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarStorageClassDeclatationMacros.macro" */
    5806             : /* 
    5807             :    JH (01/01/2006) ROSETTA generated class declarations for SgOmpAcquireClauseStorageClass 
    5808             :    used for the ast file IO. Do not chance by hand! 
    5809             : */
    5810           0 : class SgOmpAcquireClauseStorageClass  : public SgOmpClauseStorageClass
    5811             :    {
    5812             : 
    5813             :     protected: 
    5814             : 
    5815             : 
    5816             : /* #line 5817 "../../../src/frontend/SageIII//StorageClasses.h" */
    5817             : 
    5818             : 
    5819             : 
    5820             : /* #line 10 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarStorageClassDeclatationMacros.macro" */
    5821             : 
    5822             : 
    5823             :     public:
    5824             :       void pickOutIRNodeData ( SgOmpAcquireClause* source );
    5825             :       static void arrangeStaticDataOfEasyStorageClassesInOneBlock ( );
    5826             :       static void deleteStaticDataOfEasyStorageClasses ( );
    5827             :       static void pickOutStaticDataMembers ( );
    5828             :       static void rebuildStaticDataMembers ( );
    5829             :       static void writeEasyStorageDataToFile (std::ostream& out);
    5830             :       static void readEasyStorageDataFromFile (std::istream& in);
    5831             :       static void writeStaticDataToFile (std::ostream& out );
    5832             :       static void readStaticDataFromFile (std::istream& in );
    5833             :       friend class SgOmpAcquireClause;
    5834             :    };
    5835             : /* #line 5836 "../../../src/frontend/SageIII//StorageClasses.h" */
    5836             : 
    5837             : 
    5838             : 
    5839             : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarStorageClassDeclatationMacros.macro" */
    5840             : /* 
    5841             :    JH (01/01/2006) ROSETTA generated class declarations for SgOmpRelaxedClauseStorageClass 
    5842             :    used for the ast file IO. Do not chance by hand! 
    5843             : */
    5844           0 : class SgOmpRelaxedClauseStorageClass  : public SgOmpClauseStorageClass
    5845             :    {
    5846             : 
    5847             :     protected: 
    5848             : 
    5849             : 
    5850             : /* #line 5851 "../../../src/frontend/SageIII//StorageClasses.h" */
    5851             : 
    5852             : 
    5853             : 
    5854             : /* #line 10 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarStorageClassDeclatationMacros.macro" */
    5855             : 
    5856             : 
    5857             :     public:
    5858             :       void pickOutIRNodeData ( SgOmpRelaxedClause* source );
    5859             :       static void arrangeStaticDataOfEasyStorageClassesInOneBlock ( );
    5860             :       static void deleteStaticDataOfEasyStorageClasses ( );
    5861             :       static void pickOutStaticDataMembers ( );
    5862             :       static void rebuildStaticDataMembers ( );
    5863             :       static void writeEasyStorageDataToFile (std::ostream& out);
    5864             :       static void readEasyStorageDataFromFile (std::istream& in);
    5865             :       static void writeStaticDataToFile (std::ostream& out );
    5866             :       static void readStaticDataFromFile (std::istream& in );
    5867             :       friend class SgOmpRelaxedClause;
    5868             :    };
    5869             : /* #line 5870 "../../../src/frontend/SageIII//StorageClasses.h" */
    5870             : 
    5871             : 
    5872             : 
    5873             : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarStorageClassDeclatationMacros.macro" */
    5874             : /* 
    5875             :    JH (01/01/2006) ROSETTA generated class declarations for SgOmpReverseOffloadClauseStorageClass 
    5876             :    used for the ast file IO. Do not chance by hand! 
    5877             : */
    5878           0 : class SgOmpReverseOffloadClauseStorageClass  : public SgOmpClauseStorageClass
    5879             :    {
    5880             : 
    5881             :     protected: 
    5882             : 
    5883             : 
    5884             : /* #line 5885 "../../../src/frontend/SageIII//StorageClasses.h" */
    5885             : 
    5886             : 
    5887             : 
    5888             : /* #line 10 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarStorageClassDeclatationMacros.macro" */
    5889             : 
    5890             : 
    5891             :     public:
    5892             :       void pickOutIRNodeData ( SgOmpReverseOffloadClause* source );
    5893             :       static void arrangeStaticDataOfEasyStorageClassesInOneBlock ( );
    5894             :       static void deleteStaticDataOfEasyStorageClasses ( );
    5895             :       static void pickOutStaticDataMembers ( );
    5896             :       static void rebuildStaticDataMembers ( );
    5897             :       static void writeEasyStorageDataToFile (std::ostream& out);
    5898             :       static void readEasyStorageDataFromFile (std::istream& in);
    5899             :       static void writeStaticDataToFile (std::ostream& out );
    5900             :       static void readStaticDataFromFile (std::istream& in );
    5901             :       friend class SgOmpReverseOffloadClause;
    5902             :    };
    5903             : /* #line 5904 "../../../src/frontend/SageIII//StorageClasses.h" */
    5904             : 
    5905             : 
    5906             : 
    5907             : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarStorageClassDeclatationMacros.macro" */
    5908             : /* 
    5909             :    JH (01/01/2006) ROSETTA generated class declarations for SgOmpUnifiedAddressClauseStorageClass 
    5910             :    used for the ast file IO. Do not chance by hand! 
    5911             : */
    5912           0 : class SgOmpUnifiedAddressClauseStorageClass  : public SgOmpClauseStorageClass
    5913             :    {
    5914             : 
    5915             :     protected: 
    5916             : 
    5917             : 
    5918             : /* #line 5919 "../../../src/frontend/SageIII//StorageClasses.h" */
    5919             : 
    5920             : 
    5921             : 
    5922             : /* #line 10 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarStorageClassDeclatationMacros.macro" */
    5923             : 
    5924             : 
    5925             :     public:
    5926             :       void pickOutIRNodeData ( SgOmpUnifiedAddressClause* source );
    5927             :       static void arrangeStaticDataOfEasyStorageClassesInOneBlock ( );
    5928             :       static void deleteStaticDataOfEasyStorageClasses ( );
    5929             :       static void pickOutStaticDataMembers ( );
    5930             :       static void rebuildStaticDataMembers ( );
    5931             :       static void writeEasyStorageDataToFile (std::ostream& out);
    5932             :       static void readEasyStorageDataFromFile (std::istream& in);
    5933             :       static void writeStaticDataToFile (std::ostream& out );
    5934             :       static void readStaticDataFromFile (std::istream& in );
    5935             :       friend class SgOmpUnifiedAddressClause;
    5936             :    };
    5937             : /* #line 5938 "../../../src/frontend/SageIII//StorageClasses.h" */
    5938             : 
    5939             : 
    5940             : 
    5941             : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarStorageClassDeclatationMacros.macro" */
    5942             : /* 
    5943             :    JH (01/01/2006) ROSETTA generated class declarations for SgOmpUnifiedSharedMemoryClauseStorageClass 
    5944             :    used for the ast file IO. Do not chance by hand! 
    5945             : */
    5946           0 : class SgOmpUnifiedSharedMemoryClauseStorageClass  : public SgOmpClauseStorageClass
    5947             :    {
    5948             : 
    5949             :     protected: 
    5950             : 
    5951             : 
    5952             : /* #line 5953 "../../../src/frontend/SageIII//StorageClasses.h" */
    5953             : 
    5954             : 
    5955             : 
    5956             : /* #line 10 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarStorageClassDeclatationMacros.macro" */
    5957             : 
    5958             : 
    5959             :     public:
    5960             :       void pickOutIRNodeData ( SgOmpUnifiedSharedMemoryClause* source );
    5961             :       static void arrangeStaticDataOfEasyStorageClassesInOneBlock ( );
    5962             :       static void deleteStaticDataOfEasyStorageClasses ( );
    5963             :       static void pickOutStaticDataMembers ( );
    5964             :       static void rebuildStaticDataMembers ( );
    5965             :       static void writeEasyStorageDataToFile (std::ostream& out);
    5966             :       static void readEasyStorageDataFromFile (std::istream& in);
    5967             :       static void writeStaticDataToFile (std::ostream& out );
    5968             :       static void readStaticDataFromFile (std::istream& in );
    5969             :       friend class SgOmpUnifiedSharedMemoryClause;
    5970             :    };
    5971             : /* #line 5972 "../../../src/frontend/SageIII//StorageClasses.h" */
    5972             : 
    5973             : 
    5974             : 
    5975             : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarStorageClassDeclatationMacros.macro" */
    5976             : /* 
    5977             :    JH (01/01/2006) ROSETTA generated class declarations for SgOmpDynamicAllocatorsClauseStorageClass 
    5978             :    used for the ast file IO. Do not chance by hand! 
    5979             : */
    5980           0 : class SgOmpDynamicAllocatorsClauseStorageClass  : public SgOmpClauseStorageClass
    5981             :    {
    5982             : 
    5983             :     protected: 
    5984             : 
    5985             : 
    5986             : /* #line 5987 "../../../src/frontend/SageIII//StorageClasses.h" */
    5987             : 
    5988             : 
    5989             : 
    5990             : /* #line 10 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarStorageClassDeclatationMacros.macro" */
    5991             : 
    5992             : 
    5993             :     public:
    5994             :       void pickOutIRNodeData ( SgOmpDynamicAllocatorsClause* source );
    5995             :       static void arrangeStaticDataOfEasyStorageClassesInOneBlock ( );
    5996             :       static void deleteStaticDataOfEasyStorageClasses ( );
    5997             :       static void pickOutStaticDataMembers ( );
    5998             :       static void rebuildStaticDataMembers ( );
    5999             :       static void writeEasyStorageDataToFile (std::ostream& out);
    6000             :       static void readEasyStorageDataFromFile (std::istream& in);
    6001             :       static void writeStaticDataToFile (std::ostream& out );
    6002             :       static void readStaticDataFromFile (std::istream& in );
    6003             :       friend class SgOmpDynamicAllocatorsClause;
    6004             :    };
    6005             : /* #line 6006 "../../../src/frontend/SageIII//StorageClasses.h" */
    6006             : 
    6007             : 
    6008             : 
    6009             : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarStorageClassDeclatationMacros.macro" */
    6010             : /* 
    6011             :    JH (01/01/2006) ROSETTA generated class declarations for SgOmpParallelClauseStorageClass 
    6012             :    used for the ast file IO. Do not chance by hand! 
    6013             : */
    6014           0 : class SgOmpParallelClauseStorageClass  : public SgOmpClauseStorageClass
    6015             :    {
    6016             : 
    6017             :     protected: 
    6018             : 
    6019             : 
    6020             : /* #line 6021 "../../../src/frontend/SageIII//StorageClasses.h" */
    6021             : 
    6022             : 
    6023             : 
    6024             : /* #line 10 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarStorageClassDeclatationMacros.macro" */
    6025             : 
    6026             : 
    6027             :     public:
    6028             :       void pickOutIRNodeData ( SgOmpParallelClause* source );
    6029             :       static void arrangeStaticDataOfEasyStorageClassesInOneBlock ( );
    6030             :       static void deleteStaticDataOfEasyStorageClasses ( );
    6031             :       static void pickOutStaticDataMembers ( );
    6032             :       static void rebuildStaticDataMembers ( );
    6033             :       static void writeEasyStorageDataToFile (std::ostream& out);
    6034             :       static void readEasyStorageDataFromFile (std::istream& in);
    6035             :       static void writeStaticDataToFile (std::ostream& out );
    6036             :       static void readStaticDataFromFile (std::istream& in );
    6037             :       friend class SgOmpParallelClause;
    6038             :    };
    6039             : /* #line 6040 "../../../src/frontend/SageIII//StorageClasses.h" */
    6040             : 
    6041             : 
    6042             : 
    6043             : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarStorageClassDeclatationMacros.macro" */
    6044             : /* 
    6045             :    JH (01/01/2006) ROSETTA generated class declarations for SgOmpSectionsClauseStorageClass 
    6046             :    used for the ast file IO. Do not chance by hand! 
    6047             : */
    6048           0 : class SgOmpSectionsClauseStorageClass  : public SgOmpClauseStorageClass
    6049             :    {
    6050             : 
    6051             :     protected: 
    6052             : 
    6053             : 
    6054             : /* #line 6055 "../../../src/frontend/SageIII//StorageClasses.h" */
    6055             : 
    6056             : 
    6057             : 
    6058             : /* #line 10 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarStorageClassDeclatationMacros.macro" */
    6059             : 
    6060             : 
    6061             :     public:
    6062             :       void pickOutIRNodeData ( SgOmpSectionsClause* source );
    6063             :       static void arrangeStaticDataOfEasyStorageClassesInOneBlock ( );
    6064             :       static void deleteStaticDataOfEasyStorageClasses ( );
    6065             :       static void pickOutStaticDataMembers ( );
    6066             :       static void rebuildStaticDataMembers ( );
    6067             :       static void writeEasyStorageDataToFile (std::ostream& out);
    6068             :       static void readEasyStorageDataFromFile (std::istream& in);
    6069             :       static void writeStaticDataToFile (std::ostream& out );
    6070             :       static void readStaticDataFromFile (std::istream& in );
    6071             :       friend class SgOmpSectionsClause;
    6072             :    };
    6073             : /* #line 6074 "../../../src/frontend/SageIII//StorageClasses.h" */
    6074             : 
    6075             : 
    6076             : 
    6077             : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarStorageClassDeclatationMacros.macro" */
    6078             : /* 
    6079             :    JH (01/01/2006) ROSETTA generated class declarations for SgOmpForClauseStorageClass 
    6080             :    used for the ast file IO. Do not chance by hand! 
    6081             : */
    6082           0 : class SgOmpForClauseStorageClass  : public SgOmpClauseStorageClass
    6083             :    {
    6084             : 
    6085             :     protected: 
    6086             : 
    6087             : 
    6088             : /* #line 6089 "../../../src/frontend/SageIII//StorageClasses.h" */
    6089             : 
    6090             : 
    6091             : 
    6092             : /* #line 10 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarStorageClassDeclatationMacros.macro" */
    6093             : 
    6094             : 
    6095             :     public:
    6096             :       void pickOutIRNodeData ( SgOmpForClause* source );
    6097             :       static void arrangeStaticDataOfEasyStorageClassesInOneBlock ( );
    6098             :       static void deleteStaticDataOfEasyStorageClasses ( );
    6099             :       static void pickOutStaticDataMembers ( );
    6100             :       static void rebuildStaticDataMembers ( );
    6101             :       static void writeEasyStorageDataToFile (std::ostream& out);
    6102             :       static void readEasyStorageDataFromFile (std::istream& in);
    6103             :       static void writeStaticDataToFile (std::ostream& out );
    6104             :       static void readStaticDataFromFile (std::istream& in );
    6105             :       friend class SgOmpForClause;
    6106             :    };
    6107             : /* #line 6108 "../../../src/frontend/SageIII//StorageClasses.h" */
    6108             : 
    6109             : 
    6110             : 
    6111             : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarStorageClassDeclatationMacros.macro" */
    6112             : /* 
    6113             :    JH (01/01/2006) ROSETTA generated class declarations for SgOmpTaskgroupClauseStorageClass 
    6114             :    used for the ast file IO. Do not chance by hand! 
    6115             : */
    6116           0 : class SgOmpTaskgroupClauseStorageClass  : public SgOmpClauseStorageClass
    6117             :    {
    6118             : 
    6119             :     protected: 
    6120             : 
    6121             : 
    6122             : /* #line 6123 "../../../src/frontend/SageIII//StorageClasses.h" */
    6123             : 
    6124             : 
    6125             : 
    6126             : /* #line 10 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarStorageClassDeclatationMacros.macro" */
    6127             : 
    6128             : 
    6129             :     public:
    6130             :       void pickOutIRNodeData ( SgOmpTaskgroupClause* source );
    6131             :       static void arrangeStaticDataOfEasyStorageClassesInOneBlock ( );
    6132             :       static void deleteStaticDataOfEasyStorageClasses ( );
    6133             :       static void pickOutStaticDataMembers ( );
    6134             :       static void rebuildStaticDataMembers ( );
    6135             :       static void writeEasyStorageDataToFile (std::ostream& out);
    6136             :       static void readEasyStorageDataFromFile (std::istream& in);
    6137             :       static void writeStaticDataToFile (std::ostream& out );
    6138             :       static void readStaticDataFromFile (std::istream& in );
    6139             :       friend class SgOmpTaskgroupClause;
    6140             :    };
    6141             : /* #line 6142 "../../../src/frontend/SageIII//StorageClasses.h" */
    6142             : 
    6143             : 
    6144             : 
    6145             : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarStorageClassDeclatationMacros.macro" */
    6146             : /* 
    6147             :    JH (01/01/2006) ROSETTA generated class declarations for SgOmpNogroupClauseStorageClass 
    6148             :    used for the ast file IO. Do not chance by hand! 
    6149             : */
    6150           0 : class SgOmpNogroupClauseStorageClass  : public SgOmpClauseStorageClass
    6151             :    {
    6152             : 
    6153             :     protected: 
    6154             : 
    6155             : 
    6156             : /* #line 6157 "../../../src/frontend/SageIII//StorageClasses.h" */
    6157             : 
    6158             : 
    6159             : 
    6160             : /* #line 10 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarStorageClassDeclatationMacros.macro" */
    6161             : 
    6162             : 
    6163             :     public:
    6164             :       void pickOutIRNodeData ( SgOmpNogroupClause* source );
    6165             :       static void arrangeStaticDataOfEasyStorageClassesInOneBlock ( );
    6166             :       static void deleteStaticDataOfEasyStorageClasses ( );
    6167             :       static void pickOutStaticDataMembers ( );
    6168             :       static void rebuildStaticDataMembers ( );
    6169             :       static void writeEasyStorageDataToFile (std::ostream& out);
    6170             :       static void readEasyStorageDataFromFile (std::istream& in);
    6171             :       static void writeStaticDataToFile (std::ostream& out );
    6172             :       static void readStaticDataFromFile (std::istream& in );
    6173             :       friend class SgOmpNogroupClause;
    6174             :    };
    6175             : /* #line 6176 "../../../src/frontend/SageIII//StorageClasses.h" */
    6176             : 
    6177             : 
    6178             : 
    6179             : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarStorageClassDeclatationMacros.macro" */
    6180             : /* 
    6181             :    JH (01/01/2006) ROSETTA generated class declarations for SgOmpDefaultClauseStorageClass 
    6182             :    used for the ast file IO. Do not chance by hand! 
    6183             : */
    6184           0 : class SgOmpDefaultClauseStorageClass  : public SgOmpClauseStorageClass
    6185             :    {
    6186             : 
    6187             :     protected: 
    6188             : 
    6189             : 
    6190             : /* #line 6191 "../../../src/frontend/SageIII//StorageClasses.h" */
    6191             : 
    6192             :       SgOmpClause::omp_default_option_enum storageOf_data_sharing;
    6193             :      unsigned long storageOf_variant_directive;
    6194             : 
    6195             : 
    6196             : /* #line 10 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarStorageClassDeclatationMacros.macro" */
    6197             : 
    6198             : 
    6199             :     public:
    6200             :       void pickOutIRNodeData ( SgOmpDefaultClause* source );
    6201             :       static void arrangeStaticDataOfEasyStorageClassesInOneBlock ( );
    6202             :       static void deleteStaticDataOfEasyStorageClasses ( );
    6203             :       static void pickOutStaticDataMembers ( );
    6204             :       static void rebuildStaticDataMembers ( );
    6205             :       static void writeEasyStorageDataToFile (std::ostream& out);
    6206             :       static void readEasyStorageDataFromFile (std::istream& in);
    6207             :       static void writeStaticDataToFile (std::ostream& out );
    6208             :       static void readStaticDataFromFile (std::istream& in );
    6209             :       friend class SgOmpDefaultClause;
    6210             :    };
    6211             : /* #line 6212 "../../../src/frontend/SageIII//StorageClasses.h" */
    6212             : 
    6213             : 
    6214             : 
    6215             : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarStorageClassDeclatationMacros.macro" */
    6216             : /* 
    6217             :    JH (01/01/2006) ROSETTA generated class declarations for SgOmpAllocatorClauseStorageClass 
    6218             :    used for the ast file IO. Do not chance by hand! 
    6219             : */
    6220           0 : class SgOmpAllocatorClauseStorageClass  : public SgOmpClauseStorageClass
    6221             :    {
    6222             : 
    6223             :     protected: 
    6224             : 
    6225             : 
    6226             : /* #line 6227 "../../../src/frontend/SageIII//StorageClasses.h" */
    6227             : 
    6228             :       SgOmpClause::omp_allocator_modifier_enum storageOf_modifier;
    6229             :      unsigned long storageOf_user_defined_modifier;
    6230             : 
    6231             : 
    6232             : /* #line 10 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarStorageClassDeclatationMacros.macro" */
    6233             : 
    6234             : 
    6235             :     public:
    6236             :       void pickOutIRNodeData ( SgOmpAllocatorClause* source );
    6237             :       static void arrangeStaticDataOfEasyStorageClassesInOneBlock ( );
    6238             :       static void deleteStaticDataOfEasyStorageClasses ( );
    6239             :       static void pickOutStaticDataMembers ( );
    6240             :       static void rebuildStaticDataMembers ( );
    6241             :       static void writeEasyStorageDataToFile (std::ostream& out);
    6242             :       static void readEasyStorageDataFromFile (std::istream& in);
    6243             :       static void writeStaticDataToFile (std::ostream& out );
    6244             :       static void readStaticDataFromFile (std::istream& in );
    6245             :       friend class SgOmpAllocatorClause;
    6246             :    };
    6247             : /* #line 6248 "../../../src/frontend/SageIII//StorageClasses.h" */
    6248             : 
    6249             : 
    6250             : 
    6251             : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarStorageClassDeclatationMacros.macro" */
    6252             : /* 
    6253             :    JH (01/01/2006) ROSETTA generated class declarations for SgOmpAtomicClauseStorageClass 
    6254             :    used for the ast file IO. Do not chance by hand! 
    6255             : */
    6256           0 : class SgOmpAtomicClauseStorageClass  : public SgOmpClauseStorageClass
    6257             :    {
    6258             : 
    6259             :     protected: 
    6260             : 
    6261             : 
    6262             : /* #line 6263 "../../../src/frontend/SageIII//StorageClasses.h" */
    6263             : 
    6264             :       SgOmpClause::omp_atomic_clause_enum storageOf_atomicity;
    6265             : 
    6266             : 
    6267             : /* #line 10 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarStorageClassDeclatationMacros.macro" */
    6268             : 
    6269             : 
    6270             :     public:
    6271             :       void pickOutIRNodeData ( SgOmpAtomicClause* source );
    6272             :       static void arrangeStaticDataOfEasyStorageClassesInOneBlock ( );
    6273             :       static void deleteStaticDataOfEasyStorageClasses ( );
    6274             :       static void pickOutStaticDataMembers ( );
    6275             :       static void rebuildStaticDataMembers ( );
    6276             :       static void writeEasyStorageDataToFile (std::ostream& out);
    6277             :       static void readEasyStorageDataFromFile (std::istream& in);
    6278             :       static void writeStaticDataToFile (std::ostream& out );
    6279             :       static void readStaticDataFromFile (std::istream& in );
    6280             :       friend class SgOmpAtomicClause;
    6281             :    };
    6282             : /* #line 6283 "../../../src/frontend/SageIII//StorageClasses.h" */
    6283             : 
    6284             : 
    6285             : 
    6286             : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarStorageClassDeclatationMacros.macro" */
    6287             : /* 
    6288             :    JH (01/01/2006) ROSETTA generated class declarations for SgOmpProcBindClauseStorageClass 
    6289             :    used for the ast file IO. Do not chance by hand! 
    6290             : */
    6291           0 : class SgOmpProcBindClauseStorageClass  : public SgOmpClauseStorageClass
    6292             :    {
    6293             : 
    6294             :     protected: 
    6295             : 
    6296             : 
    6297             : /* #line 6298 "../../../src/frontend/SageIII//StorageClasses.h" */
    6298             : 
    6299             :       SgOmpClause::omp_proc_bind_policy_enum storageOf_policy;
    6300             : 
    6301             : 
    6302             : /* #line 10 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarStorageClassDeclatationMacros.macro" */
    6303             : 
    6304             : 
    6305             :     public:
    6306             :       void pickOutIRNodeData ( SgOmpProcBindClause* source );
    6307             :       static void arrangeStaticDataOfEasyStorageClassesInOneBlock ( );
    6308             :       static void deleteStaticDataOfEasyStorageClasses ( );
    6309             :       static void pickOutStaticDataMembers ( );
    6310             :       static void rebuildStaticDataMembers ( );
    6311             :       static void writeEasyStorageDataToFile (std::ostream& out);
    6312             :       static void readEasyStorageDataFromFile (std::istream& in);
    6313             :       static void writeStaticDataToFile (std::ostream& out );
    6314             :       static void readStaticDataFromFile (std::istream& in );
    6315             :       friend class SgOmpProcBindClause;
    6316             :    };
    6317             : /* #line 6318 "../../../src/frontend/SageIII//StorageClasses.h" */
    6318             : 
    6319             : 
    6320             : 
    6321             : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarStorageClassDeclatationMacros.macro" */
    6322             : /* 
    6323             :    JH (01/01/2006) ROSETTA generated class declarations for SgOmpBindClauseStorageClass 
    6324             :    used for the ast file IO. Do not chance by hand! 
    6325             : */
    6326           0 : class SgOmpBindClauseStorageClass  : public SgOmpClauseStorageClass
    6327             :    {
    6328             : 
    6329             :     protected: 
    6330             : 
    6331             : 
    6332             : /* #line 6333 "../../../src/frontend/SageIII//StorageClasses.h" */
    6333             : 
    6334             :       SgOmpClause::omp_bind_binding_enum storageOf_binding;
    6335             : 
    6336             : 
    6337             : /* #line 10 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarStorageClassDeclatationMacros.macro" */
    6338             : 
    6339             : 
    6340             :     public:
    6341             :       void pickOutIRNodeData ( SgOmpBindClause* source );
    6342             :       static void arrangeStaticDataOfEasyStorageClassesInOneBlock ( );
    6343             :       static void deleteStaticDataOfEasyStorageClasses ( );
    6344             :       static void pickOutStaticDataMembers ( );
    6345             :       static void rebuildStaticDataMembers ( );
    6346             :       static void writeEasyStorageDataToFile (std::ostream& out);
    6347             :       static void readEasyStorageDataFromFile (std::istream& in);
    6348             :       static void writeStaticDataToFile (std::ostream& out );
    6349             :       static void readStaticDataFromFile (std::istream& in );
    6350             :       friend class SgOmpBindClause;
    6351             :    };
    6352             : /* #line 6353 "../../../src/frontend/SageIII//StorageClasses.h" */
    6353             : 
    6354             : 
    6355             : 
    6356             : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarStorageClassDeclatationMacros.macro" */
    6357             : /* 
    6358             :    JH (01/01/2006) ROSETTA generated class declarations for SgOmpOrderClauseStorageClass 
    6359             :    used for the ast file IO. Do not chance by hand! 
    6360             : */
    6361           0 : class SgOmpOrderClauseStorageClass  : public SgOmpClauseStorageClass
    6362             :    {
    6363             : 
    6364             :     protected: 
    6365             : 
    6366             : 
    6367             : /* #line 6368 "../../../src/frontend/SageIII//StorageClasses.h" */
    6368             : 
    6369             :       SgOmpClause::omp_order_kind_enum storageOf_kind;
    6370             : 
    6371             : 
    6372             : /* #line 10 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarStorageClassDeclatationMacros.macro" */
    6373             : 
    6374             : 
    6375             :     public:
    6376             :       void pickOutIRNodeData ( SgOmpOrderClause* source );
    6377             :       static void arrangeStaticDataOfEasyStorageClassesInOneBlock ( );
    6378             :       static void deleteStaticDataOfEasyStorageClasses ( );
    6379             :       static void pickOutStaticDataMembers ( );
    6380             :       static void rebuildStaticDataMembers ( );
    6381             :       static void writeEasyStorageDataToFile (std::ostream& out);
    6382             :       static void readEasyStorageDataFromFile (std::istream& in);
    6383             :       static void writeStaticDataToFile (std::ostream& out );
    6384             :       static void readStaticDataFromFile (std::istream& in );
    6385             :       friend class SgOmpOrderClause;
    6386             :    };
    6387             : /* #line 6388 "../../../src/frontend/SageIII//StorageClasses.h" */
    6388             : 
    6389             : 
    6390             : 
    6391             : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarStorageClassDeclatationMacros.macro" */
    6392             : /* 
    6393             :    JH (01/01/2006) ROSETTA generated class declarations for SgOmpDistScheduleClauseStorageClass 
    6394             :    used for the ast file IO. Do not chance by hand! 
    6395             : */
    6396           0 : class SgOmpDistScheduleClauseStorageClass  : public SgOmpClauseStorageClass
    6397             :    {
    6398             : 
    6399             :     protected: 
    6400             : 
    6401             : 
    6402             : /* #line 6403 "../../../src/frontend/SageIII//StorageClasses.h" */
    6403             : 
    6404             :       SgOmpClause::omp_dist_schedule_kind_enum storageOf_kind;
    6405             :      unsigned long storageOf_chunk_size;
    6406             : 
    6407             : 
    6408             : /* #line 10 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarStorageClassDeclatationMacros.macro" */
    6409             : 
    6410             : 
    6411             :     public:
    6412             :       void pickOutIRNodeData ( SgOmpDistScheduleClause* source );
    6413             :       static void arrangeStaticDataOfEasyStorageClassesInOneBlock ( );
    6414             :       static void deleteStaticDataOfEasyStorageClasses ( );
    6415             :       static void pickOutStaticDataMembers ( );
    6416             :       static void rebuildStaticDataMembers ( );
    6417             :       static void writeEasyStorageDataToFile (std::ostream& out);
    6418             :       static void readEasyStorageDataFromFile (std::istream& in);
    6419             :       static void writeStaticDataToFile (std::ostream& out );
    6420             :       static void readStaticDataFromFile (std::istream& in );
    6421             :       friend class SgOmpDistScheduleClause;
    6422             :    };
    6423             : /* #line 6424 "../../../src/frontend/SageIII//StorageClasses.h" */
    6424             : 
    6425             : 
    6426             : 
    6427             : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarStorageClassDeclatationMacros.macro" */
    6428             : /* 
    6429             :    JH (01/01/2006) ROSETTA generated class declarations for SgOmpExpressionClauseStorageClass 
    6430             :    used for the ast file IO. Do not chance by hand! 
    6431             : */
    6432           0 : class SgOmpExpressionClauseStorageClass  : public SgOmpClauseStorageClass
    6433             :    {
    6434             : 
    6435             :     protected: 
    6436             : 
    6437             : 
    6438             : /* #line 6439 "../../../src/frontend/SageIII//StorageClasses.h" */
    6439             : 
    6440             :      unsigned long storageOf_expression;
    6441             : 
    6442             : 
    6443             : /* #line 10 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarStorageClassDeclatationMacros.macro" */
    6444             : 
    6445             : 
    6446             :     public:
    6447             :       void pickOutIRNodeData ( SgOmpExpressionClause* source );
    6448             :       static void arrangeStaticDataOfEasyStorageClassesInOneBlock ( );
    6449             :       static void deleteStaticDataOfEasyStorageClasses ( );
    6450             :       static void pickOutStaticDataMembers ( );
    6451             :       static void rebuildStaticDataMembers ( );
    6452             :       static void writeEasyStorageDataToFile (std::ostream& out);
    6453             :       static void readEasyStorageDataFromFile (std::istream& in);
    6454             :       static void writeStaticDataToFile (std::ostream& out );
    6455             :       static void readStaticDataFromFile (std::istream& in );
    6456             :       friend class SgOmpExpressionClause;
    6457             :    };
    6458             : /* #line 6459 "../../../src/frontend/SageIII//StorageClasses.h" */
    6459             : 
    6460             : 
    6461             : 
    6462             : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarStorageClassDeclatationMacros.macro" */
    6463             : /* 
    6464             :    JH (01/01/2006) ROSETTA generated class declarations for SgOmpOrderedClauseStorageClass 
    6465             :    used for the ast file IO. Do not chance by hand! 
    6466             : */
    6467           0 : class SgOmpOrderedClauseStorageClass  : public SgOmpExpressionClauseStorageClass
    6468             :    {
    6469             : 
    6470             :     protected: 
    6471             : 
    6472             : 
    6473             : /* #line 6474 "../../../src/frontend/SageIII//StorageClasses.h" */
    6474             : 
    6475             : 
    6476             : 
    6477             : /* #line 10 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarStorageClassDeclatationMacros.macro" */
    6478             : 
    6479             : 
    6480             :     public:
    6481             :       void pickOutIRNodeData ( SgOmpOrderedClause* source );
    6482             :       static void arrangeStaticDataOfEasyStorageClassesInOneBlock ( );
    6483             :       static void deleteStaticDataOfEasyStorageClasses ( );
    6484             :       static void pickOutStaticDataMembers ( );
    6485             :       static void rebuildStaticDataMembers ( );
    6486             :       static void writeEasyStorageDataToFile (std::ostream& out);
    6487             :       static void readEasyStorageDataFromFile (std::istream& in);
    6488             :       static void writeStaticDataToFile (std::ostream& out );
    6489             :       static void readStaticDataFromFile (std::istream& in );
    6490             :       friend class SgOmpOrderedClause;
    6491             :    };
    6492             : /* #line 6493 "../../../src/frontend/SageIII//StorageClasses.h" */
    6493             : 
    6494             : 
    6495             : 
    6496             : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarStorageClassDeclatationMacros.macro" */
    6497             : /* 
    6498             :    JH (01/01/2006) ROSETTA generated class declarations for SgOmpCollapseClauseStorageClass 
    6499             :    used for the ast file IO. Do not chance by hand! 
    6500             : */
    6501           0 : class SgOmpCollapseClauseStorageClass  : public SgOmpExpressionClauseStorageClass
    6502             :    {
    6503             : 
    6504             :     protected: 
    6505             : 
    6506             : 
    6507             : /* #line 6508 "../../../src/frontend/SageIII//StorageClasses.h" */
    6508             : 
    6509             : 
    6510             : 
    6511             : /* #line 10 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarStorageClassDeclatationMacros.macro" */
    6512             : 
    6513             : 
    6514             :     public:
    6515             :       void pickOutIRNodeData ( SgOmpCollapseClause* source );
    6516             :       static void arrangeStaticDataOfEasyStorageClassesInOneBlock ( );
    6517             :       static void deleteStaticDataOfEasyStorageClasses ( );
    6518             :       static void pickOutStaticDataMembers ( );
    6519             :       static void rebuildStaticDataMembers ( );
    6520             :       static void writeEasyStorageDataToFile (std::ostream& out);
    6521             :       static void readEasyStorageDataFromFile (std::istream& in);
    6522             :       static void writeStaticDataToFile (std::ostream& out );
    6523             :       static void readStaticDataFromFile (std::istream& in );
    6524             :       friend class SgOmpCollapseClause;
    6525             :    };
    6526             : /* #line 6527 "../../../src/frontend/SageIII//StorageClasses.h" */
    6527             : 
    6528             : 
    6529             : 
    6530             : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarStorageClassDeclatationMacros.macro" */
    6531             : /* 
    6532             :    JH (01/01/2006) ROSETTA generated class declarations for SgOmpIfClauseStorageClass 
    6533             :    used for the ast file IO. Do not chance by hand! 
    6534             : */
    6535           0 : class SgOmpIfClauseStorageClass  : public SgOmpExpressionClauseStorageClass
    6536             :    {
    6537             : 
    6538             :     protected: 
    6539             : 
    6540             : 
    6541             : /* #line 6542 "../../../src/frontend/SageIII//StorageClasses.h" */
    6542             : 
    6543             :       SgOmpClause::omp_if_modifier_enum storageOf_modifier;
    6544             : 
    6545             : 
    6546             : /* #line 10 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarStorageClassDeclatationMacros.macro" */
    6547             : 
    6548             : 
    6549             :     public:
    6550             :       void pickOutIRNodeData ( SgOmpIfClause* source );
    6551             :       static void arrangeStaticDataOfEasyStorageClassesInOneBlock ( );
    6552             :       static void deleteStaticDataOfEasyStorageClasses ( );
    6553             :       static void pickOutStaticDataMembers ( );
    6554             :       static void rebuildStaticDataMembers ( );
    6555             :       static void writeEasyStorageDataToFile (std::ostream& out);
    6556             :       static void readEasyStorageDataFromFile (std::istream& in);
    6557             :       static void writeStaticDataToFile (std::ostream& out );
    6558             :       static void readStaticDataFromFile (std::istream& in );
    6559             :       friend class SgOmpIfClause;
    6560             :    };
    6561             : /* #line 6562 "../../../src/frontend/SageIII//StorageClasses.h" */
    6562             : 
    6563             : 
    6564             : 
    6565             : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarStorageClassDeclatationMacros.macro" */
    6566             : /* 
    6567             :    JH (01/01/2006) ROSETTA generated class declarations for SgUpirNumUnitsFieldStorageClass 
    6568             :    used for the ast file IO. Do not chance by hand! 
    6569             : */
    6570           0 : class SgUpirNumUnitsFieldStorageClass  : public SgOmpExpressionClauseStorageClass
    6571             :    {
    6572             : 
    6573             :     protected: 
    6574             : 
    6575             : 
    6576             : /* #line 6577 "../../../src/frontend/SageIII//StorageClasses.h" */
    6577             : 
    6578             : 
    6579             : 
    6580             : /* #line 10 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarStorageClassDeclatationMacros.macro" */
    6581             : 
    6582             : 
    6583             :     public:
    6584             :       void pickOutIRNodeData ( SgUpirNumUnitsField* source );
    6585             :       static void arrangeStaticDataOfEasyStorageClassesInOneBlock ( );
    6586             :       static void deleteStaticDataOfEasyStorageClasses ( );
    6587             :       static void pickOutStaticDataMembers ( );
    6588             :       static void rebuildStaticDataMembers ( );
    6589             :       static void writeEasyStorageDataToFile (std::ostream& out);
    6590             :       static void readEasyStorageDataFromFile (std::istream& in);
    6591             :       static void writeStaticDataToFile (std::ostream& out );
    6592             :       static void readStaticDataFromFile (std::istream& in );
    6593             :       friend class SgUpirNumUnitsField;
    6594             :    };
    6595             : /* #line 6596 "../../../src/frontend/SageIII//StorageClasses.h" */
    6596             : 
    6597             : 
    6598             : 
    6599             : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarStorageClassDeclatationMacros.macro" */
    6600             : /* 
    6601             :    JH (01/01/2006) ROSETTA generated class declarations for SgOmpNumTeamsClauseStorageClass 
    6602             :    used for the ast file IO. Do not chance by hand! 
    6603             : */
    6604           0 : class SgOmpNumTeamsClauseStorageClass  : public SgOmpExpressionClauseStorageClass
    6605             :    {
    6606             : 
    6607             :     protected: 
    6608             : 
    6609             : 
    6610             : /* #line 6611 "../../../src/frontend/SageIII//StorageClasses.h" */
    6611             : 
    6612             : 
    6613             : 
    6614             : /* #line 10 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarStorageClassDeclatationMacros.macro" */
    6615             : 
    6616             : 
    6617             :     public:
    6618             :       void pickOutIRNodeData ( SgOmpNumTeamsClause* source );
    6619             :       static void arrangeStaticDataOfEasyStorageClassesInOneBlock ( );
    6620             :       static void deleteStaticDataOfEasyStorageClasses ( );
    6621             :       static void pickOutStaticDataMembers ( );
    6622             :       static void rebuildStaticDataMembers ( );
    6623             :       static void writeEasyStorageDataToFile (std::ostream& out);
    6624             :       static void readEasyStorageDataFromFile (std::istream& in);
    6625             :       static void writeStaticDataToFile (std::ostream& out );
    6626             :       static void readStaticDataFromFile (std::istream& in );
    6627             :       friend class SgOmpNumTeamsClause;
    6628             :    };
    6629             : /* #line 6630 "../../../src/frontend/SageIII//StorageClasses.h" */
    6630             : 
    6631             : 
    6632             : 
    6633             : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarStorageClassDeclatationMacros.macro" */
    6634             : /* 
    6635             :    JH (01/01/2006) ROSETTA generated class declarations for SgOmpThreadLimitClauseStorageClass 
    6636             :    used for the ast file IO. Do not chance by hand! 
    6637             : */
    6638           0 : class SgOmpThreadLimitClauseStorageClass  : public SgOmpExpressionClauseStorageClass
    6639             :    {
    6640             : 
    6641             :     protected: 
    6642             : 
    6643             : 
    6644             : /* #line 6645 "../../../src/frontend/SageIII//StorageClasses.h" */
    6645             : 
    6646             : 
    6647             : 
    6648             : /* #line 10 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarStorageClassDeclatationMacros.macro" */
    6649             : 
    6650             : 
    6651             :     public:
    6652             :       void pickOutIRNodeData ( SgOmpThreadLimitClause* source );
    6653             :       static void arrangeStaticDataOfEasyStorageClassesInOneBlock ( );
    6654             :       static void deleteStaticDataOfEasyStorageClasses ( );
    6655             :       static void pickOutStaticDataMembers ( );
    6656             :       static void rebuildStaticDataMembers ( );
    6657             :       static void writeEasyStorageDataToFile (std::ostream& out);
    6658             :       static void readEasyStorageDataFromFile (std::istream& in);
    6659             :       static void writeStaticDataToFile (std::ostream& out );
    6660             :       static void readStaticDataFromFile (std::istream& in );
    6661             :       friend class SgOmpThreadLimitClause;
    6662             :    };
    6663             : /* #line 6664 "../../../src/frontend/SageIII//StorageClasses.h" */
    6664             : 
    6665             : 
    6666             : 
    6667             : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarStorageClassDeclatationMacros.macro" */
    6668             : /* 
    6669             :    JH (01/01/2006) ROSETTA generated class declarations for SgOmpDeviceClauseStorageClass 
    6670             :    used for the ast file IO. Do not chance by hand! 
    6671             : */
    6672           0 : class SgOmpDeviceClauseStorageClass  : public SgOmpExpressionClauseStorageClass
    6673             :    {
    6674             : 
    6675             :     protected: 
    6676             : 
    6677             : 
    6678             : /* #line 6679 "../../../src/frontend/SageIII//StorageClasses.h" */
    6679             : 
    6680             :       SgOmpClause::omp_device_modifier_enum storageOf_modifier;
    6681             : 
    6682             : 
    6683             : /* #line 10 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarStorageClassDeclatationMacros.macro" */
    6684             : 
    6685             : 
    6686             :     public:
    6687             :       void pickOutIRNodeData ( SgOmpDeviceClause* source );
    6688             :       static void arrangeStaticDataOfEasyStorageClassesInOneBlock ( );
    6689             :       static void deleteStaticDataOfEasyStorageClasses ( );
    6690             :       static void pickOutStaticDataMembers ( );
    6691             :       static void rebuildStaticDataMembers ( );
    6692             :       static void writeEasyStorageDataToFile (std::ostream& out);
    6693             :       static void readEasyStorageDataFromFile (std::istream& in);
    6694             :       static void writeStaticDataToFile (std::ostream& out );
    6695             :       static void readStaticDataFromFile (std::istream& in );
    6696             :       friend class SgOmpDeviceClause;
    6697             :    };
    6698             : /* #line 6699 "../../../src/frontend/SageIII//StorageClasses.h" */
    6699             : 
    6700             : 
    6701             : 
    6702             : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarStorageClassDeclatationMacros.macro" */
    6703             : /* 
    6704             :    JH (01/01/2006) ROSETTA generated class declarations for SgOmpHintClauseStorageClass 
    6705             :    used for the ast file IO. Do not chance by hand! 
    6706             : */
    6707           0 : class SgOmpHintClauseStorageClass  : public SgOmpExpressionClauseStorageClass
    6708             :    {
    6709             : 
    6710             :     protected: 
    6711             : 
    6712             : 
    6713             : /* #line 6714 "../../../src/frontend/SageIII//StorageClasses.h" */
    6714             : 
    6715             : 
    6716             : 
    6717             : /* #line 10 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarStorageClassDeclatationMacros.macro" */
    6718             : 
    6719             : 
    6720             :     public:
    6721             :       void pickOutIRNodeData ( SgOmpHintClause* source );
    6722             :       static void arrangeStaticDataOfEasyStorageClassesInOneBlock ( );
    6723             :       static void deleteStaticDataOfEasyStorageClasses ( );
    6724             :       static void pickOutStaticDataMembers ( );
    6725             :       static void rebuildStaticDataMembers ( );
    6726             :       static void writeEasyStorageDataToFile (std::ostream& out);
    6727             :       static void readEasyStorageDataFromFile (std::istream& in);
    6728             :       static void writeStaticDataToFile (std::ostream& out );
    6729             :       static void readStaticDataFromFile (std::istream& in );
    6730             :       friend class SgOmpHintClause;
    6731             :    };
    6732             : /* #line 6733 "../../../src/frontend/SageIII//StorageClasses.h" */
    6733             : 
    6734             : 
    6735             : 
    6736             : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarStorageClassDeclatationMacros.macro" */
    6737             : /* 
    6738             :    JH (01/01/2006) ROSETTA generated class declarations for SgOmpGrainsizeClauseStorageClass 
    6739             :    used for the ast file IO. Do not chance by hand! 
    6740             : */
    6741           0 : class SgOmpGrainsizeClauseStorageClass  : public SgOmpExpressionClauseStorageClass
    6742             :    {
    6743             : 
    6744             :     protected: 
    6745             : 
    6746             : 
    6747             : /* #line 6748 "../../../src/frontend/SageIII//StorageClasses.h" */
    6748             : 
    6749             : 
    6750             : 
    6751             : /* #line 10 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarStorageClassDeclatationMacros.macro" */
    6752             : 
    6753             : 
    6754             :     public:
    6755             :       void pickOutIRNodeData ( SgOmpGrainsizeClause* source );
    6756             :       static void arrangeStaticDataOfEasyStorageClassesInOneBlock ( );
    6757             :       static void deleteStaticDataOfEasyStorageClasses ( );
    6758             :       static void pickOutStaticDataMembers ( );
    6759             :       static void rebuildStaticDataMembers ( );
    6760             :       static void writeEasyStorageDataToFile (std::ostream& out);
    6761             :       static void readEasyStorageDataFromFile (std::istream& in);
    6762             :       static void writeStaticDataToFile (std::ostream& out );
    6763             :       static void readStaticDataFromFile (std::istream& in );
    6764             :       friend class SgOmpGrainsizeClause;
    6765             :    };
    6766             : /* #line 6767 "../../../src/frontend/SageIII//StorageClasses.h" */
    6767             : 
    6768             : 
    6769             : 
    6770             : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarStorageClassDeclatationMacros.macro" */
    6771             : /* 
    6772             :    JH (01/01/2006) ROSETTA generated class declarations for SgOmpNumTasksClauseStorageClass 
    6773             :    used for the ast file IO. Do not chance by hand! 
    6774             : */
    6775           0 : class SgOmpNumTasksClauseStorageClass  : public SgOmpExpressionClauseStorageClass
    6776             :    {
    6777             : 
    6778             :     protected: 
    6779             : 
    6780             : 
    6781             : /* #line 6782 "../../../src/frontend/SageIII//StorageClasses.h" */
    6782             : 
    6783             : 
    6784             : 
    6785             : /* #line 10 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarStorageClassDeclatationMacros.macro" */
    6786             : 
    6787             : 
    6788             :     public:
    6789             :       void pickOutIRNodeData ( SgOmpNumTasksClause* source );
    6790             :       static void arrangeStaticDataOfEasyStorageClassesInOneBlock ( );
    6791             :       static void deleteStaticDataOfEasyStorageClasses ( );
    6792             :       static void pickOutStaticDataMembers ( );
    6793             :       static void rebuildStaticDataMembers ( );
    6794             :       static void writeEasyStorageDataToFile (std::ostream& out);
    6795             :       static void readEasyStorageDataFromFile (std::istream& in);
    6796             :       static void writeStaticDataToFile (std::ostream& out );
    6797             :       static void readStaticDataFromFile (std::istream& in );
    6798             :       friend class SgOmpNumTasksClause;
    6799             :    };
    6800             : /* #line 6801 "../../../src/frontend/SageIII//StorageClasses.h" */
    6801             : 
    6802             : 
    6803             : 
    6804             : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarStorageClassDeclatationMacros.macro" */
    6805             : /* 
    6806             :    JH (01/01/2006) ROSETTA generated class declarations for SgOmpDetachClauseStorageClass 
    6807             :    used for the ast file IO. Do not chance by hand! 
    6808             : */
    6809           0 : class SgOmpDetachClauseStorageClass  : public SgOmpExpressionClauseStorageClass
    6810             :    {
    6811             : 
    6812             :     protected: 
    6813             : 
    6814             : 
    6815             : /* #line 6816 "../../../src/frontend/SageIII//StorageClasses.h" */
    6816             : 
    6817             : 
    6818             : 
    6819             : /* #line 10 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarStorageClassDeclatationMacros.macro" */
    6820             : 
    6821             : 
    6822             :     public:
    6823             :       void pickOutIRNodeData ( SgOmpDetachClause* source );
    6824             :       static void arrangeStaticDataOfEasyStorageClassesInOneBlock ( );
    6825             :       static void deleteStaticDataOfEasyStorageClasses ( );
    6826             :       static void pickOutStaticDataMembers ( );
    6827             :       static void rebuildStaticDataMembers ( );
    6828             :       static void writeEasyStorageDataToFile (std::ostream& out);
    6829             :       static void readEasyStorageDataFromFile (std::istream& in);
    6830             :       static void writeStaticDataToFile (std::ostream& out );
    6831             :       static void readStaticDataFromFile (std::istream& in );
    6832             :       friend class SgOmpDetachClause;
    6833             :    };
    6834             : /* #line 6835 "../../../src/frontend/SageIII//StorageClasses.h" */
    6835             : 
    6836             : 
    6837             : 
    6838             : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarStorageClassDeclatationMacros.macro" */
    6839             : /* 
    6840             :    JH (01/01/2006) ROSETTA generated class declarations for SgOmpSafelenClauseStorageClass 
    6841             :    used for the ast file IO. Do not chance by hand! 
    6842             : */
    6843           0 : class SgOmpSafelenClauseStorageClass  : public SgOmpExpressionClauseStorageClass
    6844             :    {
    6845             : 
    6846             :     protected: 
    6847             : 
    6848             : 
    6849             : /* #line 6850 "../../../src/frontend/SageIII//StorageClasses.h" */
    6850             : 
    6851             : 
    6852             : 
    6853             : /* #line 10 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarStorageClassDeclatationMacros.macro" */
    6854             : 
    6855             : 
    6856             :     public:
    6857             :       void pickOutIRNodeData ( SgOmpSafelenClause* source );
    6858             :       static void arrangeStaticDataOfEasyStorageClassesInOneBlock ( );
    6859             :       static void deleteStaticDataOfEasyStorageClasses ( );
    6860             :       static void pickOutStaticDataMembers ( );
    6861             :       static void rebuildStaticDataMembers ( );
    6862             :       static void writeEasyStorageDataToFile (std::ostream& out);
    6863             :       static void readEasyStorageDataFromFile (std::istream& in);
    6864             :       static void writeStaticDataToFile (std::ostream& out );
    6865             :       static void readStaticDataFromFile (std::istream& in );
    6866             :       friend class SgOmpSafelenClause;
    6867             :    };
    6868             : /* #line 6869 "../../../src/frontend/SageIII//StorageClasses.h" */
    6869             : 
    6870             : 
    6871             : 
    6872             : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarStorageClassDeclatationMacros.macro" */
    6873             : /* 
    6874             :    JH (01/01/2006) ROSETTA generated class declarations for SgOmpSimdlenClauseStorageClass 
    6875             :    used for the ast file IO. Do not chance by hand! 
    6876             : */
    6877           0 : class SgOmpSimdlenClauseStorageClass  : public SgOmpExpressionClauseStorageClass
    6878             :    {
    6879             : 
    6880             :     protected: 
    6881             : 
    6882             : 
    6883             : /* #line 6884 "../../../src/frontend/SageIII//StorageClasses.h" */
    6884             : 
    6885             : 
    6886             : 
    6887             : /* #line 10 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarStorageClassDeclatationMacros.macro" */
    6888             : 
    6889             : 
    6890             :     public:
    6891             :       void pickOutIRNodeData ( SgOmpSimdlenClause* source );
    6892             :       static void arrangeStaticDataOfEasyStorageClassesInOneBlock ( );
    6893             :       static void deleteStaticDataOfEasyStorageClasses ( );
    6894             :       static void pickOutStaticDataMembers ( );
    6895             :       static void rebuildStaticDataMembers ( );
    6896             :       static void writeEasyStorageDataToFile (std::ostream& out);
    6897             :       static void readEasyStorageDataFromFile (std::istream& in);
    6898             :       static void writeStaticDataToFile (std::ostream& out );
    6899             :       static void readStaticDataFromFile (std::istream& in );
    6900             :       friend class SgOmpSimdlenClause;
    6901             :    };
    6902             : /* #line 6903 "../../../src/frontend/SageIII//StorageClasses.h" */
    6903             : 
    6904             : 
    6905             : 
    6906             : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarStorageClassDeclatationMacros.macro" */
    6907             : /* 
    6908             :    JH (01/01/2006) ROSETTA generated class declarations for SgOmpFinalClauseStorageClass 
    6909             :    used for the ast file IO. Do not chance by hand! 
    6910             : */
    6911           0 : class SgOmpFinalClauseStorageClass  : public SgOmpExpressionClauseStorageClass
    6912             :    {
    6913             : 
    6914             :     protected: 
    6915             : 
    6916             : 
    6917             : /* #line 6918 "../../../src/frontend/SageIII//StorageClasses.h" */
    6918             : 
    6919             : 
    6920             : 
    6921             : /* #line 10 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarStorageClassDeclatationMacros.macro" */
    6922             : 
    6923             : 
    6924             :     public:
    6925             :       void pickOutIRNodeData ( SgOmpFinalClause* source );
    6926             :       static void arrangeStaticDataOfEasyStorageClassesInOneBlock ( );
    6927             :       static void deleteStaticDataOfEasyStorageClasses ( );
    6928             :       static void pickOutStaticDataMembers ( );
    6929             :       static void rebuildStaticDataMembers ( );
    6930             :       static void writeEasyStorageDataToFile (std::ostream& out);
    6931             :       static void readEasyStorageDataFromFile (std::istream& in);
    6932             :       static void writeStaticDataToFile (std::ostream& out );
    6933             :       static void readStaticDataFromFile (std::istream& in );
    6934             :       friend class SgOmpFinalClause;
    6935             :    };
    6936             : /* #line 6937 "../../../src/frontend/SageIII//StorageClasses.h" */
    6937             : 
    6938             : 
    6939             : 
    6940             : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarStorageClassDeclatationMacros.macro" */
    6941             : /* 
    6942             :    JH (01/01/2006) ROSETTA generated class declarations for SgOmpPriorityClauseStorageClass 
    6943             :    used for the ast file IO. Do not chance by hand! 
    6944             : */
    6945           0 : class SgOmpPriorityClauseStorageClass  : public SgOmpExpressionClauseStorageClass
    6946             :    {
    6947             : 
    6948             :     protected: 
    6949             : 
    6950             : 
    6951             : /* #line 6952 "../../../src/frontend/SageIII//StorageClasses.h" */
    6952             : 
    6953             : 
    6954             : 
    6955             : /* #line 10 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarStorageClassDeclatationMacros.macro" */
    6956             : 
    6957             : 
    6958             :     public:
    6959             :       void pickOutIRNodeData ( SgOmpPriorityClause* source );
    6960             :       static void arrangeStaticDataOfEasyStorageClassesInOneBlock ( );
    6961             :       static void deleteStaticDataOfEasyStorageClasses ( );
    6962             :       static void pickOutStaticDataMembers ( );
    6963             :       static void rebuildStaticDataMembers ( );
    6964             :       static void writeEasyStorageDataToFile (std::ostream& out);
    6965             :       static void readEasyStorageDataFromFile (std::istream& in);
    6966             :       static void writeStaticDataToFile (std::ostream& out );
    6967             :       static void readStaticDataFromFile (std::istream& in );
    6968             :       friend class SgOmpPriorityClause;
    6969             :    };
    6970             : /* #line 6971 "../../../src/frontend/SageIII//StorageClasses.h" */
    6971             : 
    6972             : 
    6973             : 
    6974             : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarStorageClassDeclatationMacros.macro" */
    6975             : /* 
    6976             :    JH (01/01/2006) ROSETTA generated class declarations for SgOmpPartialClauseStorageClass 
    6977             :    used for the ast file IO. Do not chance by hand! 
    6978             : */
    6979           0 : class SgOmpPartialClauseStorageClass  : public SgOmpExpressionClauseStorageClass
    6980             :    {
    6981             : 
    6982             :     protected: 
    6983             : 
    6984             : 
    6985             : /* #line 6986 "../../../src/frontend/SageIII//StorageClasses.h" */
    6986             : 
    6987             : 
    6988             : 
    6989             : /* #line 10 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarStorageClassDeclatationMacros.macro" */
    6990             : 
    6991             : 
    6992             :     public:
    6993             :       void pickOutIRNodeData ( SgOmpPartialClause* source );
    6994             :       static void arrangeStaticDataOfEasyStorageClassesInOneBlock ( );
    6995             :       static void deleteStaticDataOfEasyStorageClasses ( );
    6996             :       static void pickOutStaticDataMembers ( );
    6997             :       static void rebuildStaticDataMembers ( );
    6998             :       static void writeEasyStorageDataToFile (std::ostream& out);
    6999             :       static void readEasyStorageDataFromFile (std::istream& in);
    7000             :       static void writeStaticDataToFile (std::ostream& out );
    7001             :       static void readStaticDataFromFile (std::istream& in );
    7002             :       friend class SgOmpPartialClause;
    7003             :    };
    7004             : /* #line 7005 "../../../src/frontend/SageIII//StorageClasses.h" */
    7005             : 
    7006             : 
    7007             : 
    7008             : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarStorageClassDeclatationMacros.macro" */
    7009             : /* 
    7010             :    JH (01/01/2006) ROSETTA generated class declarations for SgOmpSizesClauseStorageClass 
    7011             :    used for the ast file IO. Do not chance by hand! 
    7012             : */
    7013           0 : class SgOmpSizesClauseStorageClass  : public SgOmpExpressionClauseStorageClass
    7014             :    {
    7015             : 
    7016             :     protected: 
    7017             : 
    7018             : 
    7019             : /* #line 7020 "../../../src/frontend/SageIII//StorageClasses.h" */
    7020             : 
    7021             : 
    7022             : 
    7023             : /* #line 10 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarStorageClassDeclatationMacros.macro" */
    7024             : 
    7025             : 
    7026             :     public:
    7027             :       void pickOutIRNodeData ( SgOmpSizesClause* source );
    7028             :       static void arrangeStaticDataOfEasyStorageClassesInOneBlock ( );
    7029             :       static void deleteStaticDataOfEasyStorageClasses ( );
    7030             :       static void pickOutStaticDataMembers ( );
    7031             :       static void rebuildStaticDataMembers ( );
    7032             :       static void writeEasyStorageDataToFile (std::ostream& out);
    7033             :       static void readEasyStorageDataFromFile (std::istream& in);
    7034             :       static void writeStaticDataToFile (std::ostream& out );
    7035             :       static void readStaticDataFromFile (std::istream& in );
    7036             :       friend class SgOmpSizesClause;
    7037             :    };
    7038             : /* #line 7039 "../../../src/frontend/SageIII//StorageClasses.h" */
    7039             : 
    7040             : 
    7041             : 
    7042             : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarStorageClassDeclatationMacros.macro" */
    7043             : /* 
    7044             :    JH (01/01/2006) ROSETTA generated class declarations for SgOmpInbranchClauseStorageClass 
    7045             :    used for the ast file IO. Do not chance by hand! 
    7046             : */
    7047           0 : class SgOmpInbranchClauseStorageClass  : public SgOmpClauseStorageClass
    7048             :    {
    7049             : 
    7050             :     protected: 
    7051             : 
    7052             : 
    7053             : /* #line 7054 "../../../src/frontend/SageIII//StorageClasses.h" */
    7054             : 
    7055             : 
    7056             : 
    7057             : /* #line 10 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarStorageClassDeclatationMacros.macro" */
    7058             : 
    7059             : 
    7060             :     public:
    7061             :       void pickOutIRNodeData ( SgOmpInbranchClause* source );
    7062             :       static void arrangeStaticDataOfEasyStorageClassesInOneBlock ( );
    7063             :       static void deleteStaticDataOfEasyStorageClasses ( );
    7064             :       static void pickOutStaticDataMembers ( );
    7065             :       static void rebuildStaticDataMembers ( );
    7066             :       static void writeEasyStorageDataToFile (std::ostream& out);
    7067             :       static void readEasyStorageDataFromFile (std::istream& in);
    7068             :       static void writeStaticDataToFile (std::ostream& out );
    7069             :       static void readStaticDataFromFile (std::istream& in );
    7070             :       friend class SgOmpInbranchClause;
    7071             :    };
    7072             : /* #line 7073 "../../../src/frontend/SageIII//StorageClasses.h" */
    7073             : 
    7074             : 
    7075             : 
    7076             : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarStorageClassDeclatationMacros.macro" */
    7077             : /* 
    7078             :    JH (01/01/2006) ROSETTA generated class declarations for SgOmpNotinbranchClauseStorageClass 
    7079             :    used for the ast file IO. Do not chance by hand! 
    7080             : */
    7081           0 : class SgOmpNotinbranchClauseStorageClass  : public SgOmpClauseStorageClass
    7082             :    {
    7083             : 
    7084             :     protected: 
    7085             : 
    7086             : 
    7087             : /* #line 7088 "../../../src/frontend/SageIII//StorageClasses.h" */
    7088             : 
    7089             : 
    7090             : 
    7091             : /* #line 10 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarStorageClassDeclatationMacros.macro" */
    7092             : 
    7093             : 
    7094             :     public:
    7095             :       void pickOutIRNodeData ( SgOmpNotinbranchClause* source );
    7096             :       static void arrangeStaticDataOfEasyStorageClassesInOneBlock ( );
    7097             :       static void deleteStaticDataOfEasyStorageClasses ( );
    7098             :       static void pickOutStaticDataMembers ( );
    7099             :       static void rebuildStaticDataMembers ( );
    7100             :       static void writeEasyStorageDataToFile (std::ostream& out);
    7101             :       static void readEasyStorageDataFromFile (std::istream& in);
    7102             :       static void writeStaticDataToFile (std::ostream& out );
    7103             :       static void readStaticDataFromFile (std::istream& in );
    7104             :       friend class SgOmpNotinbranchClause;
    7105             :    };
    7106             : /* #line 7107 "../../../src/frontend/SageIII//StorageClasses.h" */
    7107             : 
    7108             : 
    7109             : 
    7110             : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarStorageClassDeclatationMacros.macro" */
    7111             : /* 
    7112             :    JH (01/01/2006) ROSETTA generated class declarations for SgOmpDefaultmapClauseStorageClass 
    7113             :    used for the ast file IO. Do not chance by hand! 
    7114             : */
    7115           0 : class SgOmpDefaultmapClauseStorageClass  : public SgOmpClauseStorageClass
    7116             :    {
    7117             : 
    7118             :     protected: 
    7119             : 
    7120             : 
    7121             : /* #line 7122 "../../../src/frontend/SageIII//StorageClasses.h" */
    7122             : 
    7123             :       SgOmpClause::omp_defaultmap_behavior_enum storageOf_behavior;
    7124             :       SgOmpClause::omp_defaultmap_category_enum storageOf_category;
    7125             : 
    7126             : 
    7127             : /* #line 10 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarStorageClassDeclatationMacros.macro" */
    7128             : 
    7129             : 
    7130             :     public:
    7131             :       void pickOutIRNodeData ( SgOmpDefaultmapClause* source );
    7132             :       static void arrangeStaticDataOfEasyStorageClassesInOneBlock ( );
    7133             :       static void deleteStaticDataOfEasyStorageClasses ( );
    7134             :       static void pickOutStaticDataMembers ( );
    7135             :       static void rebuildStaticDataMembers ( );
    7136             :       static void writeEasyStorageDataToFile (std::ostream& out);
    7137             :       static void readEasyStorageDataFromFile (std::istream& in);
    7138             :       static void writeStaticDataToFile (std::ostream& out );
    7139             :       static void readStaticDataFromFile (std::istream& in );
    7140             :       friend class SgOmpDefaultmapClause;
    7141             :    };
    7142             : /* #line 7143 "../../../src/frontend/SageIII//StorageClasses.h" */
    7143             : 
    7144             : 
    7145             : 
    7146             : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarStorageClassDeclatationMacros.macro" */
    7147             : /* 
    7148             :    JH (01/01/2006) ROSETTA generated class declarations for SgOmpAtomicDefaultMemOrderClauseStorageClass 
    7149             :    used for the ast file IO. Do not chance by hand! 
    7150             : */
    7151           0 : class SgOmpAtomicDefaultMemOrderClauseStorageClass  : public SgOmpClauseStorageClass
    7152             :    {
    7153             : 
    7154             :     protected: 
    7155             : 
    7156             : 
    7157             : /* #line 7158 "../../../src/frontend/SageIII//StorageClasses.h" */
    7158             : 
    7159             :       SgOmpClause::omp_atomic_default_mem_order_kind_enum storageOf_kind;
    7160             : 
    7161             : 
    7162             : /* #line 10 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarStorageClassDeclatationMacros.macro" */
    7163             : 
    7164             : 
    7165             :     public:
    7166             :       void pickOutIRNodeData ( SgOmpAtomicDefaultMemOrderClause* source );
    7167             :       static void arrangeStaticDataOfEasyStorageClassesInOneBlock ( );
    7168             :       static void deleteStaticDataOfEasyStorageClasses ( );
    7169             :       static void pickOutStaticDataMembers ( );
    7170             :       static void rebuildStaticDataMembers ( );
    7171             :       static void writeEasyStorageDataToFile (std::ostream& out);
    7172             :       static void readEasyStorageDataFromFile (std::istream& in);
    7173             :       static void writeStaticDataToFile (std::ostream& out );
    7174             :       static void readStaticDataFromFile (std::istream& in );
    7175             :       friend class SgOmpAtomicDefaultMemOrderClause;
    7176             :    };
    7177             : /* #line 7178 "../../../src/frontend/SageIII//StorageClasses.h" */
    7178             : 
    7179             : 
    7180             : 
    7181             : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarStorageClassDeclatationMacros.macro" */
    7182             : /* 
    7183             :    JH (01/01/2006) ROSETTA generated class declarations for SgOmpExtImplementationDefinedRequirementClauseStorageClass 
    7184             :    used for the ast file IO. Do not chance by hand! 
    7185             : */
    7186           0 : class SgOmpExtImplementationDefinedRequirementClauseStorageClass  : public SgOmpClauseStorageClass
    7187             :    {
    7188             : 
    7189             :     protected: 
    7190             : 
    7191             : 
    7192             : /* #line 7193 "../../../src/frontend/SageIII//StorageClasses.h" */
    7193             : 
    7194             :      unsigned long storageOf_implementation_defined_requirement;
    7195             : 
    7196             : 
    7197             : /* #line 10 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarStorageClassDeclatationMacros.macro" */
    7198             : 
    7199             : 
    7200             :     public:
    7201             :       void pickOutIRNodeData ( SgOmpExtImplementationDefinedRequirementClause* source );
    7202             :       static void arrangeStaticDataOfEasyStorageClassesInOneBlock ( );
    7203             :       static void deleteStaticDataOfEasyStorageClasses ( );
    7204             :       static void pickOutStaticDataMembers ( );
    7205             :       static void rebuildStaticDataMembers ( );
    7206             :       static void writeEasyStorageDataToFile (std::ostream& out);
    7207             :       static void readEasyStorageDataFromFile (std::istream& in);
    7208             :       static void writeStaticDataToFile (std::ostream& out );
    7209             :       static void readStaticDataFromFile (std::istream& in );
    7210             :       friend class SgOmpExtImplementationDefinedRequirementClause;
    7211             :    };
    7212             : /* #line 7213 "../../../src/frontend/SageIII//StorageClasses.h" */
    7213             : 
    7214             : 
    7215             : 
    7216             : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarStorageClassDeclatationMacros.macro" */
    7217             : /* 
    7218             :    JH (01/01/2006) ROSETTA generated class declarations for SgOmpUsesAllocatorsDefinationStorageClass 
    7219             :    used for the ast file IO. Do not chance by hand! 
    7220             : */
    7221           0 : class SgOmpUsesAllocatorsDefinationStorageClass  : public SgOmpClauseStorageClass
    7222             :    {
    7223             : 
    7224             :     protected: 
    7225             : 
    7226             : 
    7227             : /* #line 7228 "../../../src/frontend/SageIII//StorageClasses.h" */
    7228             : 
    7229             :       SgOmpClause::omp_uses_allocators_allocator_enum storageOf_allocator;
    7230             :      unsigned long storageOf_user_defined_allocator;
    7231             :      unsigned long storageOf_allocator_traits_array;
    7232             : 
    7233             : 
    7234             : /* #line 10 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarStorageClassDeclatationMacros.macro" */
    7235             : 
    7236             : 
    7237             :     public:
    7238             :       void pickOutIRNodeData ( SgOmpUsesAllocatorsDefination* source );
    7239             :       static void arrangeStaticDataOfEasyStorageClassesInOneBlock ( );
    7240             :       static void deleteStaticDataOfEasyStorageClasses ( );
    7241             :       static void pickOutStaticDataMembers ( );
    7242             :       static void rebuildStaticDataMembers ( );
    7243             :       static void writeEasyStorageDataToFile (std::ostream& out);
    7244             :       static void readEasyStorageDataFromFile (std::istream& in);
    7245             :       static void writeStaticDataToFile (std::ostream& out );
    7246             :       static void readStaticDataFromFile (std::istream& in );
    7247             :       friend class SgOmpUsesAllocatorsDefination;
    7248             :    };
    7249             : /* #line 7250 "../../../src/frontend/SageIII//StorageClasses.h" */
    7250             : 
    7251             : 
    7252             : 
    7253             : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarStorageClassDeclatationMacros.macro" */
    7254             : /* 
    7255             :    JH (01/01/2006) ROSETTA generated class declarations for SgOmpVariablesClauseStorageClass 
    7256             :    used for the ast file IO. Do not chance by hand! 
    7257             : */
    7258           0 : class SgOmpVariablesClauseStorageClass  : public SgOmpClauseStorageClass
    7259             :    {
    7260             : 
    7261             :     protected: 
    7262             : 
    7263             : 
    7264             : /* #line 7265 "../../../src/frontend/SageIII//StorageClasses.h" */
    7265             : 
    7266             :      unsigned long storageOf_variables;
    7267             : 
    7268             : 
    7269             : /* #line 10 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarStorageClassDeclatationMacros.macro" */
    7270             : 
    7271             : 
    7272             :     public:
    7273             :       void pickOutIRNodeData ( SgOmpVariablesClause* source );
    7274             :       static void arrangeStaticDataOfEasyStorageClassesInOneBlock ( );
    7275             :       static void deleteStaticDataOfEasyStorageClasses ( );
    7276             :       static void pickOutStaticDataMembers ( );
    7277             :       static void rebuildStaticDataMembers ( );
    7278             :       static void writeEasyStorageDataToFile (std::ostream& out);
    7279             :       static void readEasyStorageDataFromFile (std::istream& in);
    7280             :       static void writeStaticDataToFile (std::ostream& out );
    7281             :       static void readStaticDataFromFile (std::istream& in );
    7282             :       friend class SgOmpVariablesClause;
    7283             :    };
    7284             : /* #line 7285 "../../../src/frontend/SageIII//StorageClasses.h" */
    7285             : 
    7286             : 
    7287             : 
    7288             : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarStorageClassDeclatationMacros.macro" */
    7289             : /* 
    7290             :    JH (01/01/2006) ROSETTA generated class declarations for SgOmpCopyprivateClauseStorageClass 
    7291             :    used for the ast file IO. Do not chance by hand! 
    7292             : */
    7293           0 : class SgOmpCopyprivateClauseStorageClass  : public SgOmpVariablesClauseStorageClass
    7294             :    {
    7295             : 
    7296             :     protected: 
    7297             : 
    7298             : 
    7299             : /* #line 7300 "../../../src/frontend/SageIII//StorageClasses.h" */
    7300             : 
    7301             : 
    7302             : 
    7303             : /* #line 10 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarStorageClassDeclatationMacros.macro" */
    7304             : 
    7305             : 
    7306             :     public:
    7307             :       void pickOutIRNodeData ( SgOmpCopyprivateClause* source );
    7308             :       static void arrangeStaticDataOfEasyStorageClassesInOneBlock ( );
    7309             :       static void deleteStaticDataOfEasyStorageClasses ( );
    7310             :       static void pickOutStaticDataMembers ( );
    7311             :       static void rebuildStaticDataMembers ( );
    7312             :       static void writeEasyStorageDataToFile (std::ostream& out);
    7313             :       static void readEasyStorageDataFromFile (std::istream& in);
    7314             :       static void writeStaticDataToFile (std::ostream& out );
    7315             :       static void readStaticDataFromFile (std::istream& in );
    7316             :       friend class SgOmpCopyprivateClause;
    7317             :    };
    7318             : /* #line 7319 "../../../src/frontend/SageIII//StorageClasses.h" */
    7319             : 
    7320             : 
    7321             : 
    7322             : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarStorageClassDeclatationMacros.macro" */
    7323             : /* 
    7324             :    JH (01/01/2006) ROSETTA generated class declarations for SgOmpPrivateClauseStorageClass 
    7325             :    used for the ast file IO. Do not chance by hand! 
    7326             : */
    7327           0 : class SgOmpPrivateClauseStorageClass  : public SgOmpVariablesClauseStorageClass
    7328             :    {
    7329             : 
    7330             :     protected: 
    7331             : 
    7332             : 
    7333             : /* #line 7334 "../../../src/frontend/SageIII//StorageClasses.h" */
    7334             : 
    7335             : 
    7336             : 
    7337             : /* #line 10 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarStorageClassDeclatationMacros.macro" */
    7338             : 
    7339             : 
    7340             :     public:
    7341             :       void pickOutIRNodeData ( SgOmpPrivateClause* source );
    7342             :       static void arrangeStaticDataOfEasyStorageClassesInOneBlock ( );
    7343             :       static void deleteStaticDataOfEasyStorageClasses ( );
    7344             :       static void pickOutStaticDataMembers ( );
    7345             :       static void rebuildStaticDataMembers ( );
    7346             :       static void writeEasyStorageDataToFile (std::ostream& out);
    7347             :       static void readEasyStorageDataFromFile (std::istream& in);
    7348             :       static void writeStaticDataToFile (std::ostream& out );
    7349             :       static void readStaticDataFromFile (std::istream& in );
    7350             :       friend class SgOmpPrivateClause;
    7351             :    };
    7352             : /* #line 7353 "../../../src/frontend/SageIII//StorageClasses.h" */
    7353             : 
    7354             : 
    7355             : 
    7356             : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarStorageClassDeclatationMacros.macro" */
    7357             : /* 
    7358             :    JH (01/01/2006) ROSETTA generated class declarations for SgOmpFirstprivateClauseStorageClass 
    7359             :    used for the ast file IO. Do not chance by hand! 
    7360             : */
    7361           0 : class SgOmpFirstprivateClauseStorageClass  : public SgOmpVariablesClauseStorageClass
    7362             :    {
    7363             : 
    7364             :     protected: 
    7365             : 
    7366             : 
    7367             : /* #line 7368 "../../../src/frontend/SageIII//StorageClasses.h" */
    7368             : 
    7369             : 
    7370             : 
    7371             : /* #line 10 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarStorageClassDeclatationMacros.macro" */
    7372             : 
    7373             : 
    7374             :     public:
    7375             :       void pickOutIRNodeData ( SgOmpFirstprivateClause* source );
    7376             :       static void arrangeStaticDataOfEasyStorageClassesInOneBlock ( );
    7377             :       static void deleteStaticDataOfEasyStorageClasses ( );
    7378             :       static void pickOutStaticDataMembers ( );
    7379             :       static void rebuildStaticDataMembers ( );
    7380             :       static void writeEasyStorageDataToFile (std::ostream& out);
    7381             :       static void readEasyStorageDataFromFile (std::istream& in);
    7382             :       static void writeStaticDataToFile (std::ostream& out );
    7383             :       static void readStaticDataFromFile (std::istream& in );
    7384             :       friend class SgOmpFirstprivateClause;
    7385             :    };
    7386             : /* #line 7387 "../../../src/frontend/SageIII//StorageClasses.h" */
    7387             : 
    7388             : 
    7389             : 
    7390             : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarStorageClassDeclatationMacros.macro" */
    7391             : /* 
    7392             :    JH (01/01/2006) ROSETTA generated class declarations for SgOmpNontemporalClauseStorageClass 
    7393             :    used for the ast file IO. Do not chance by hand! 
    7394             : */
    7395           0 : class SgOmpNontemporalClauseStorageClass  : public SgOmpVariablesClauseStorageClass
    7396             :    {
    7397             : 
    7398             :     protected: 
    7399             : 
    7400             : 
    7401             : /* #line 7402 "../../../src/frontend/SageIII//StorageClasses.h" */
    7402             : 
    7403             : 
    7404             : 
    7405             : /* #line 10 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarStorageClassDeclatationMacros.macro" */
    7406             : 
    7407             : 
    7408             :     public:
    7409             :       void pickOutIRNodeData ( SgOmpNontemporalClause* source );
    7410             :       static void arrangeStaticDataOfEasyStorageClassesInOneBlock ( );
    7411             :       static void deleteStaticDataOfEasyStorageClasses ( );
    7412             :       static void pickOutStaticDataMembers ( );
    7413             :       static void rebuildStaticDataMembers ( );
    7414             :       static void writeEasyStorageDataToFile (std::ostream& out);
    7415             :       static void readEasyStorageDataFromFile (std::istream& in);
    7416             :       static void writeStaticDataToFile (std::ostream& out );
    7417             :       static void readStaticDataFromFile (std::istream& in );
    7418             :       friend class SgOmpNontemporalClause;
    7419             :    };
    7420             : /* #line 7421 "../../../src/frontend/SageIII//StorageClasses.h" */
    7421             : 
    7422             : 
    7423             : 
    7424             : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarStorageClassDeclatationMacros.macro" */
    7425             : /* 
    7426             :    JH (01/01/2006) ROSETTA generated class declarations for SgOmpInclusiveClauseStorageClass 
    7427             :    used for the ast file IO. Do not chance by hand! 
    7428             : */
    7429           0 : class SgOmpInclusiveClauseStorageClass  : public SgOmpVariablesClauseStorageClass
    7430             :    {
    7431             : 
    7432             :     protected: 
    7433             : 
    7434             : 
    7435             : /* #line 7436 "../../../src/frontend/SageIII//StorageClasses.h" */
    7436             : 
    7437             : 
    7438             : 
    7439             : /* #line 10 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarStorageClassDeclatationMacros.macro" */
    7440             : 
    7441             : 
    7442             :     public:
    7443             :       void pickOutIRNodeData ( SgOmpInclusiveClause* source );
    7444             :       static void arrangeStaticDataOfEasyStorageClassesInOneBlock ( );
    7445             :       static void deleteStaticDataOfEasyStorageClasses ( );
    7446             :       static void pickOutStaticDataMembers ( );
    7447             :       static void rebuildStaticDataMembers ( );
    7448             :       static void writeEasyStorageDataToFile (std::ostream& out);
    7449             :       static void readEasyStorageDataFromFile (std::istream& in);
    7450             :       static void writeStaticDataToFile (std::ostream& out );
    7451             :       static void readStaticDataFromFile (std::istream& in );
    7452             :       friend class SgOmpInclusiveClause;
    7453             :    };
    7454             : /* #line 7455 "../../../src/frontend/SageIII//StorageClasses.h" */
    7455             : 
    7456             : 
    7457             : 
    7458             : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarStorageClassDeclatationMacros.macro" */
    7459             : /* 
    7460             :    JH (01/01/2006) ROSETTA generated class declarations for SgOmpExclusiveClauseStorageClass 
    7461             :    used for the ast file IO. Do not chance by hand! 
    7462             : */
    7463           0 : class SgOmpExclusiveClauseStorageClass  : public SgOmpVariablesClauseStorageClass
    7464             :    {
    7465             : 
    7466             :     protected: 
    7467             : 
    7468             : 
    7469             : /* #line 7470 "../../../src/frontend/SageIII//StorageClasses.h" */
    7470             : 
    7471             : 
    7472             : 
    7473             : /* #line 10 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarStorageClassDeclatationMacros.macro" */
    7474             : 
    7475             : 
    7476             :     public:
    7477             :       void pickOutIRNodeData ( SgOmpExclusiveClause* source );
    7478             :       static void arrangeStaticDataOfEasyStorageClassesInOneBlock ( );
    7479             :       static void deleteStaticDataOfEasyStorageClasses ( );
    7480             :       static void pickOutStaticDataMembers ( );
    7481             :       static void rebuildStaticDataMembers ( );
    7482             :       static void writeEasyStorageDataToFile (std::ostream& out);
    7483             :       static void readEasyStorageDataFromFile (std::istream& in);
    7484             :       static void writeStaticDataToFile (std::ostream& out );
    7485             :       static void readStaticDataFromFile (std::istream& in );
    7486             :       friend class SgOmpExclusiveClause;
    7487             :    };
    7488             : /* #line 7489 "../../../src/frontend/SageIII//StorageClasses.h" */
    7489             : 
    7490             : 
    7491             : 
    7492             : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarStorageClassDeclatationMacros.macro" */
    7493             : /* 
    7494             :    JH (01/01/2006) ROSETTA generated class declarations for SgOmpIsDevicePtrClauseStorageClass 
    7495             :    used for the ast file IO. Do not chance by hand! 
    7496             : */
    7497           0 : class SgOmpIsDevicePtrClauseStorageClass  : public SgOmpVariablesClauseStorageClass
    7498             :    {
    7499             : 
    7500             :     protected: 
    7501             : 
    7502             : 
    7503             : /* #line 7504 "../../../src/frontend/SageIII//StorageClasses.h" */
    7504             : 
    7505             : 
    7506             : 
    7507             : /* #line 10 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarStorageClassDeclatationMacros.macro" */
    7508             : 
    7509             : 
    7510             :     public:
    7511             :       void pickOutIRNodeData ( SgOmpIsDevicePtrClause* source );
    7512             :       static void arrangeStaticDataOfEasyStorageClassesInOneBlock ( );
    7513             :       static void deleteStaticDataOfEasyStorageClasses ( );
    7514             :       static void pickOutStaticDataMembers ( );
    7515             :       static void rebuildStaticDataMembers ( );
    7516             :       static void writeEasyStorageDataToFile (std::ostream& out);
    7517             :       static void readEasyStorageDataFromFile (std::istream& in);
    7518             :       static void writeStaticDataToFile (std::ostream& out );
    7519             :       static void readStaticDataFromFile (std::istream& in );
    7520             :       friend class SgOmpIsDevicePtrClause;
    7521             :    };
    7522             : /* #line 7523 "../../../src/frontend/SageIII//StorageClasses.h" */
    7523             : 
    7524             : 
    7525             : 
    7526             : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarStorageClassDeclatationMacros.macro" */
    7527             : /* 
    7528             :    JH (01/01/2006) ROSETTA generated class declarations for SgOmpUseDevicePtrClauseStorageClass 
    7529             :    used for the ast file IO. Do not chance by hand! 
    7530             : */
    7531           0 : class SgOmpUseDevicePtrClauseStorageClass  : public SgOmpVariablesClauseStorageClass
    7532             :    {
    7533             : 
    7534             :     protected: 
    7535             : 
    7536             : 
    7537             : /* #line 7538 "../../../src/frontend/SageIII//StorageClasses.h" */
    7538             : 
    7539             : 
    7540             : 
    7541             : /* #line 10 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarStorageClassDeclatationMacros.macro" */
    7542             : 
    7543             : 
    7544             :     public:
    7545             :       void pickOutIRNodeData ( SgOmpUseDevicePtrClause* source );
    7546             :       static void arrangeStaticDataOfEasyStorageClassesInOneBlock ( );
    7547             :       static void deleteStaticDataOfEasyStorageClasses ( );
    7548             :       static void pickOutStaticDataMembers ( );
    7549             :       static void rebuildStaticDataMembers ( );
    7550             :       static void writeEasyStorageDataToFile (std::ostream& out);
    7551             :       static void readEasyStorageDataFromFile (std::istream& in);
    7552             :       static void writeStaticDataToFile (std::ostream& out );
    7553             :       static void readStaticDataFromFile (std::istream& in );
    7554             :       friend class SgOmpUseDevicePtrClause;
    7555             :    };
    7556             : /* #line 7557 "../../../src/frontend/SageIII//StorageClasses.h" */
    7557             : 
    7558             : 
    7559             : 
    7560             : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarStorageClassDeclatationMacros.macro" */
    7561             : /* 
    7562             :    JH (01/01/2006) ROSETTA generated class declarations for SgOmpUseDeviceAddrClauseStorageClass 
    7563             :    used for the ast file IO. Do not chance by hand! 
    7564             : */
    7565           0 : class SgOmpUseDeviceAddrClauseStorageClass  : public SgOmpVariablesClauseStorageClass
    7566             :    {
    7567             : 
    7568             :     protected: 
    7569             : 
    7570             : 
    7571             : /* #line 7572 "../../../src/frontend/SageIII//StorageClasses.h" */
    7572             : 
    7573             : 
    7574             : 
    7575             : /* #line 10 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarStorageClassDeclatationMacros.macro" */
    7576             : 
    7577             : 
    7578             :     public:
    7579             :       void pickOutIRNodeData ( SgOmpUseDeviceAddrClause* source );
    7580             :       static void arrangeStaticDataOfEasyStorageClassesInOneBlock ( );
    7581             :       static void deleteStaticDataOfEasyStorageClasses ( );
    7582             :       static void pickOutStaticDataMembers ( );
    7583             :       static void rebuildStaticDataMembers ( );
    7584             :       static void writeEasyStorageDataToFile (std::ostream& out);
    7585             :       static void readEasyStorageDataFromFile (std::istream& in);
    7586             :       static void writeStaticDataToFile (std::ostream& out );
    7587             :       static void readStaticDataFromFile (std::istream& in );
    7588             :       friend class SgOmpUseDeviceAddrClause;
    7589             :    };
    7590             : /* #line 7591 "../../../src/frontend/SageIII//StorageClasses.h" */
    7591             : 
    7592             : 
    7593             : 
    7594             : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarStorageClassDeclatationMacros.macro" */
    7595             : /* 
    7596             :    JH (01/01/2006) ROSETTA generated class declarations for SgOmpSharedClauseStorageClass 
    7597             :    used for the ast file IO. Do not chance by hand! 
    7598             : */
    7599           0 : class SgOmpSharedClauseStorageClass  : public SgOmpVariablesClauseStorageClass
    7600             :    {
    7601             : 
    7602             :     protected: 
    7603             : 
    7604             : 
    7605             : /* #line 7606 "../../../src/frontend/SageIII//StorageClasses.h" */
    7606             : 
    7607             : 
    7608             : 
    7609             : /* #line 10 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarStorageClassDeclatationMacros.macro" */
    7610             : 
    7611             : 
    7612             :     public:
    7613             :       void pickOutIRNodeData ( SgOmpSharedClause* source );
    7614             :       static void arrangeStaticDataOfEasyStorageClassesInOneBlock ( );
    7615             :       static void deleteStaticDataOfEasyStorageClasses ( );
    7616             :       static void pickOutStaticDataMembers ( );
    7617             :       static void rebuildStaticDataMembers ( );
    7618             :       static void writeEasyStorageDataToFile (std::ostream& out);
    7619             :       static void readEasyStorageDataFromFile (std::istream& in);
    7620             :       static void writeStaticDataToFile (std::ostream& out );
    7621             :       static void readStaticDataFromFile (std::istream& in );
    7622             :       friend class SgOmpSharedClause;
    7623             :    };
    7624             : /* #line 7625 "../../../src/frontend/SageIII//StorageClasses.h" */
    7625             : 
    7626             : 
    7627             : 
    7628             : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarStorageClassDeclatationMacros.macro" */
    7629             : /* 
    7630             :    JH (01/01/2006) ROSETTA generated class declarations for SgOmpCopyinClauseStorageClass 
    7631             :    used for the ast file IO. Do not chance by hand! 
    7632             : */
    7633           0 : class SgOmpCopyinClauseStorageClass  : public SgOmpVariablesClauseStorageClass
    7634             :    {
    7635             : 
    7636             :     protected: 
    7637             : 
    7638             : 
    7639             : /* #line 7640 "../../../src/frontend/SageIII//StorageClasses.h" */
    7640             : 
    7641             : 
    7642             : 
    7643             : /* #line 10 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarStorageClassDeclatationMacros.macro" */
    7644             : 
    7645             : 
    7646             :     public:
    7647             :       void pickOutIRNodeData ( SgOmpCopyinClause* source );
    7648             :       static void arrangeStaticDataOfEasyStorageClassesInOneBlock ( );
    7649             :       static void deleteStaticDataOfEasyStorageClasses ( );
    7650             :       static void pickOutStaticDataMembers ( );
    7651             :       static void rebuildStaticDataMembers ( );
    7652             :       static void writeEasyStorageDataToFile (std::ostream& out);
    7653             :       static void readEasyStorageDataFromFile (std::istream& in);
    7654             :       static void writeStaticDataToFile (std::ostream& out );
    7655             :       static void readStaticDataFromFile (std::istream& in );
    7656             :       friend class SgOmpCopyinClause;
    7657             :    };
    7658             : /* #line 7659 "../../../src/frontend/SageIII//StorageClasses.h" */
    7659             : 
    7660             : 
    7661             : 
    7662             : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarStorageClassDeclatationMacros.macro" */
    7663             : /* 
    7664             :    JH (01/01/2006) ROSETTA generated class declarations for SgOmpLastprivateClauseStorageClass 
    7665             :    used for the ast file IO. Do not chance by hand! 
    7666             : */
    7667           0 : class SgOmpLastprivateClauseStorageClass  : public SgOmpVariablesClauseStorageClass
    7668             :    {
    7669             : 
    7670             :     protected: 
    7671             : 
    7672             : 
    7673             : /* #line 7674 "../../../src/frontend/SageIII//StorageClasses.h" */
    7674             : 
    7675             :       SgOmpClause::omp_lastprivate_modifier_enum storageOf_modifier;
    7676             : 
    7677             : 
    7678             : /* #line 10 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarStorageClassDeclatationMacros.macro" */
    7679             : 
    7680             : 
    7681             :     public:
    7682             :       void pickOutIRNodeData ( SgOmpLastprivateClause* source );
    7683             :       static void arrangeStaticDataOfEasyStorageClassesInOneBlock ( );
    7684             :       static void deleteStaticDataOfEasyStorageClasses ( );
    7685             :       static void pickOutStaticDataMembers ( );
    7686             :       static void rebuildStaticDataMembers ( );
    7687             :       static void writeEasyStorageDataToFile (std::ostream& out);
    7688             :       static void readEasyStorageDataFromFile (std::istream& in);
    7689             :       static void writeStaticDataToFile (std::ostream& out );
    7690             :       static void readStaticDataFromFile (std::istream& in );
    7691             :       friend class SgOmpLastprivateClause;
    7692             :    };
    7693             : /* #line 7694 "../../../src/frontend/SageIII//StorageClasses.h" */
    7694             : 
    7695             : 
    7696             : 
    7697             : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarStorageClassDeclatationMacros.macro" */
    7698             : /* 
    7699             :    JH (01/01/2006) ROSETTA generated class declarations for SgOmpReductionClauseStorageClass 
    7700             :    used for the ast file IO. Do not chance by hand! 
    7701             : */
    7702           0 : class SgOmpReductionClauseStorageClass  : public SgOmpVariablesClauseStorageClass
    7703             :    {
    7704             : 
    7705             :     protected: 
    7706             : 
    7707             : 
    7708             : /* #line 7709 "../../../src/frontend/SageIII//StorageClasses.h" */
    7709             : 
    7710             :       SgOmpClause::omp_reduction_modifier_enum storageOf_modifier;
    7711             :       SgOmpClause::omp_reduction_identifier_enum storageOf_identifier;
    7712             :      unsigned long storageOf_user_defined_identifier;
    7713             : 
    7714             : 
    7715             : /* #line 10 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarStorageClassDeclatationMacros.macro" */
    7716             : 
    7717             : 
    7718             :     public:
    7719             :       void pickOutIRNodeData ( SgOmpReductionClause* source );
    7720             :       static void arrangeStaticDataOfEasyStorageClassesInOneBlock ( );
    7721             :       static void deleteStaticDataOfEasyStorageClasses ( );
    7722             :       static void pickOutStaticDataMembers ( );
    7723             :       static void rebuildStaticDataMembers ( );
    7724             :       static void writeEasyStorageDataToFile (std::ostream& out);
    7725             :       static void readEasyStorageDataFromFile (std::istream& in);
    7726             :       static void writeStaticDataToFile (std::ostream& out );
    7727             :       static void readStaticDataFromFile (std::istream& in );
    7728             :       friend class SgOmpReductionClause;
    7729             :    };
    7730             : /* #line 7731 "../../../src/frontend/SageIII//StorageClasses.h" */
    7731             : 
    7732             : 
    7733             : 
    7734             : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarStorageClassDeclatationMacros.macro" */
    7735             : /* 
    7736             :    JH (01/01/2006) ROSETTA generated class declarations for SgOmpInReductionClauseStorageClass 
    7737             :    used for the ast file IO. Do not chance by hand! 
    7738             : */
    7739           0 : class SgOmpInReductionClauseStorageClass  : public SgOmpVariablesClauseStorageClass
    7740             :    {
    7741             : 
    7742             :     protected: 
    7743             : 
    7744             : 
    7745             : /* #line 7746 "../../../src/frontend/SageIII//StorageClasses.h" */
    7746             : 
    7747             :       SgOmpClause::omp_in_reduction_identifier_enum storageOf_identifier;
    7748             :      unsigned long storageOf_user_defined_identifier;
    7749             : 
    7750             : 
    7751             : /* #line 10 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarStorageClassDeclatationMacros.macro" */
    7752             : 
    7753             : 
    7754             :     public:
    7755             :       void pickOutIRNodeData ( SgOmpInReductionClause* source );
    7756             :       static void arrangeStaticDataOfEasyStorageClassesInOneBlock ( );
    7757             :       static void deleteStaticDataOfEasyStorageClasses ( );
    7758             :       static void pickOutStaticDataMembers ( );
    7759             :       static void rebuildStaticDataMembers ( );
    7760             :       static void writeEasyStorageDataToFile (std::ostream& out);
    7761             :       static void readEasyStorageDataFromFile (std::istream& in);
    7762             :       static void writeStaticDataToFile (std::ostream& out );
    7763             :       static void readStaticDataFromFile (std::istream& in );
    7764             :       friend class SgOmpInReductionClause;
    7765             :    };
    7766             : /* #line 7767 "../../../src/frontend/SageIII//StorageClasses.h" */
    7767             : 
    7768             : 
    7769             : 
    7770             : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarStorageClassDeclatationMacros.macro" */
    7771             : /* 
    7772             :    JH (01/01/2006) ROSETTA generated class declarations for SgOmpTaskReductionClauseStorageClass 
    7773             :    used for the ast file IO. Do not chance by hand! 
    7774             : */
    7775           0 : class SgOmpTaskReductionClauseStorageClass  : public SgOmpVariablesClauseStorageClass
    7776             :    {
    7777             : 
    7778             :     protected: 
    7779             : 
    7780             : 
    7781             : /* #line 7782 "../../../src/frontend/SageIII//StorageClasses.h" */
    7782             : 
    7783             :       SgOmpClause::omp_task_reduction_identifier_enum storageOf_identifier;
    7784             :      unsigned long storageOf_user_defined_identifier;
    7785             : 
    7786             : 
    7787             : /* #line 10 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarStorageClassDeclatationMacros.macro" */
    7788             : 
    7789             : 
    7790             :     public:
    7791             :       void pickOutIRNodeData ( SgOmpTaskReductionClause* source );
    7792             :       static void arrangeStaticDataOfEasyStorageClassesInOneBlock ( );
    7793             :       static void deleteStaticDataOfEasyStorageClasses ( );
    7794             :       static void pickOutStaticDataMembers ( );
    7795             :       static void rebuildStaticDataMembers ( );
    7796             :       static void writeEasyStorageDataToFile (std::ostream& out);
    7797             :       static void readEasyStorageDataFromFile (std::istream& in);
    7798             :       static void writeStaticDataToFile (std::ostream& out );
    7799             :       static void readStaticDataFromFile (std::istream& in );
    7800             :       friend class SgOmpTaskReductionClause;
    7801             :    };
    7802             : /* #line 7803 "../../../src/frontend/SageIII//StorageClasses.h" */
    7803             : 
    7804             : 
    7805             : 
    7806             : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarStorageClassDeclatationMacros.macro" */
    7807             : /* 
    7808             :    JH (01/01/2006) ROSETTA generated class declarations for SgOmpMapClauseStorageClass 
    7809             :    used for the ast file IO. Do not chance by hand! 
    7810             : */
    7811           0 : class SgOmpMapClauseStorageClass  : public SgOmpVariablesClauseStorageClass
    7812             :    {
    7813             : 
    7814             :     protected: 
    7815             : 
    7816             : 
    7817             : /* #line 7818 "../../../src/frontend/SageIII//StorageClasses.h" */
    7818             : 
    7819             :       SgOmpClause::omp_map_operator_enum storageOf_operation;
    7820             :        EasyStorage < std::map<SgSymbol*,  std::vector < std::pair <SgExpression*, SgExpression*> > > > storageOf_array_dimensions;
    7821             :        EasyStorage < std::map<SgSymbol*,  std::vector < std::pair <SgOmpClause::omp_map_dist_data_enum, SgExpression*> > > > storageOf_dist_data_policies;
    7822             : 
    7823             : 
    7824             : /* #line 10 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarStorageClassDeclatationMacros.macro" */
    7825             : 
    7826             : 
    7827             :     public:
    7828             :       void pickOutIRNodeData ( SgOmpMapClause* source );
    7829             :       static void arrangeStaticDataOfEasyStorageClassesInOneBlock ( );
    7830             :       static void deleteStaticDataOfEasyStorageClasses ( );
    7831             :       static void pickOutStaticDataMembers ( );
    7832             :       static void rebuildStaticDataMembers ( );
    7833             :       static void writeEasyStorageDataToFile (std::ostream& out);
    7834             :       static void readEasyStorageDataFromFile (std::istream& in);
    7835             :       static void writeStaticDataToFile (std::ostream& out );
    7836             :       static void readStaticDataFromFile (std::istream& in );
    7837             :       friend class SgOmpMapClause;
    7838             :    };
    7839             : /* #line 7840 "../../../src/frontend/SageIII//StorageClasses.h" */
    7840             : 
    7841             : 
    7842             : 
    7843             : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarStorageClassDeclatationMacros.macro" */
    7844             : /* 
    7845             :    JH (01/01/2006) ROSETTA generated class declarations for SgOmpAllocateClauseStorageClass 
    7846             :    used for the ast file IO. Do not chance by hand! 
    7847             : */
    7848           0 : class SgOmpAllocateClauseStorageClass  : public SgOmpVariablesClauseStorageClass
    7849             :    {
    7850             : 
    7851             :     protected: 
    7852             : 
    7853             : 
    7854             : /* #line 7855 "../../../src/frontend/SageIII//StorageClasses.h" */
    7855             : 
    7856             :       SgOmpClause::omp_allocate_modifier_enum storageOf_modifier;
    7857             :      unsigned long storageOf_user_defined_modifier;
    7858             : 
    7859             : 
    7860             : /* #line 10 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarStorageClassDeclatationMacros.macro" */
    7861             : 
    7862             : 
    7863             :     public:
    7864             :       void pickOutIRNodeData ( SgOmpAllocateClause* source );
    7865             :       static void arrangeStaticDataOfEasyStorageClassesInOneBlock ( );
    7866             :       static void deleteStaticDataOfEasyStorageClasses ( );
    7867             :       static void pickOutStaticDataMembers ( );
    7868             :       static void rebuildStaticDataMembers ( );
    7869             :       static void writeEasyStorageDataToFile (std::ostream& out);
    7870             :       static void readEasyStorageDataFromFile (std::istream& in);
    7871             :       static void writeStaticDataToFile (std::ostream& out );
    7872             :       static void readStaticDataFromFile (std::istream& in );
    7873             :       friend class SgOmpAllocateClause;
    7874             :    };
    7875             : /* #line 7876 "../../../src/frontend/SageIII//StorageClasses.h" */
    7876             : 
    7877             : 
    7878             : 
    7879             : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarStorageClassDeclatationMacros.macro" */
    7880             : /* 
    7881             :    JH (01/01/2006) ROSETTA generated class declarations for SgOmpUniformClauseStorageClass 
    7882             :    used for the ast file IO. Do not chance by hand! 
    7883             : */
    7884           0 : class SgOmpUniformClauseStorageClass  : public SgOmpVariablesClauseStorageClass
    7885             :    {
    7886             : 
    7887             :     protected: 
    7888             : 
    7889             : 
    7890             : /* #line 7891 "../../../src/frontend/SageIII//StorageClasses.h" */
    7891             : 
    7892             : 
    7893             : 
    7894             : /* #line 10 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarStorageClassDeclatationMacros.macro" */
    7895             : 
    7896             : 
    7897             :     public:
    7898             :       void pickOutIRNodeData ( SgOmpUniformClause* source );
    7899             :       static void arrangeStaticDataOfEasyStorageClassesInOneBlock ( );
    7900             :       static void deleteStaticDataOfEasyStorageClasses ( );
    7901             :       static void pickOutStaticDataMembers ( );
    7902             :       static void rebuildStaticDataMembers ( );
    7903             :       static void writeEasyStorageDataToFile (std::ostream& out);
    7904             :       static void readEasyStorageDataFromFile (std::istream& in);
    7905             :       static void writeStaticDataToFile (std::ostream& out );
    7906             :       static void readStaticDataFromFile (std::istream& in );
    7907             :       friend class SgOmpUniformClause;
    7908             :    };
    7909             : /* #line 7910 "../../../src/frontend/SageIII//StorageClasses.h" */
    7910             : 
    7911             : 
    7912             : 
    7913             : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarStorageClassDeclatationMacros.macro" */
    7914             : /* 
    7915             :    JH (01/01/2006) ROSETTA generated class declarations for SgOmpAlignedClauseStorageClass 
    7916             :    used for the ast file IO. Do not chance by hand! 
    7917             : */
    7918           0 : class SgOmpAlignedClauseStorageClass  : public SgOmpVariablesClauseStorageClass
    7919             :    {
    7920             : 
    7921             :     protected: 
    7922             : 
    7923             : 
    7924             : /* #line 7925 "../../../src/frontend/SageIII//StorageClasses.h" */
    7925             : 
    7926             :      unsigned long storageOf_alignment;
    7927             : 
    7928             : 
    7929             : /* #line 10 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarStorageClassDeclatationMacros.macro" */
    7930             : 
    7931             : 
    7932             :     public:
    7933             :       void pickOutIRNodeData ( SgOmpAlignedClause* source );
    7934             :       static void arrangeStaticDataOfEasyStorageClassesInOneBlock ( );
    7935             :       static void deleteStaticDataOfEasyStorageClasses ( );
    7936             :       static void pickOutStaticDataMembers ( );
    7937             :       static void rebuildStaticDataMembers ( );
    7938             :       static void writeEasyStorageDataToFile (std::ostream& out);
    7939             :       static void readEasyStorageDataFromFile (std::istream& in);
    7940             :       static void writeStaticDataToFile (std::ostream& out );
    7941             :       static void readStaticDataFromFile (std::istream& in );
    7942             :       friend class SgOmpAlignedClause;
    7943             :    };
    7944             : /* #line 7945 "../../../src/frontend/SageIII//StorageClasses.h" */
    7945             : 
    7946             : 
    7947             : 
    7948             : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarStorageClassDeclatationMacros.macro" */
    7949             : /* 
    7950             :    JH (01/01/2006) ROSETTA generated class declarations for SgOmpLinearClauseStorageClass 
    7951             :    used for the ast file IO. Do not chance by hand! 
    7952             : */
    7953           0 : class SgOmpLinearClauseStorageClass  : public SgOmpVariablesClauseStorageClass
    7954             :    {
    7955             : 
    7956             :     protected: 
    7957             : 
    7958             : 
    7959             : /* #line 7960 "../../../src/frontend/SageIII//StorageClasses.h" */
    7960             : 
    7961             :      unsigned long storageOf_step;
    7962             :       SgOmpClause::omp_linear_modifier_enum storageOf_modifier;
    7963             : 
    7964             : 
    7965             : /* #line 10 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarStorageClassDeclatationMacros.macro" */
    7966             : 
    7967             : 
    7968             :     public:
    7969             :       void pickOutIRNodeData ( SgOmpLinearClause* source );
    7970             :       static void arrangeStaticDataOfEasyStorageClassesInOneBlock ( );
    7971             :       static void deleteStaticDataOfEasyStorageClasses ( );
    7972             :       static void pickOutStaticDataMembers ( );
    7973             :       static void rebuildStaticDataMembers ( );
    7974             :       static void writeEasyStorageDataToFile (std::ostream& out);
    7975             :       static void readEasyStorageDataFromFile (std::istream& in);
    7976             :       static void writeStaticDataToFile (std::ostream& out );
    7977             :       static void readStaticDataFromFile (std::istream& in );
    7978             :       friend class SgOmpLinearClause;
    7979             :    };
    7980             : /* #line 7981 "../../../src/frontend/SageIII//StorageClasses.h" */
    7981             : 
    7982             : 
    7983             : 
    7984             : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarStorageClassDeclatationMacros.macro" */
    7985             : /* 
    7986             :    JH (01/01/2006) ROSETTA generated class declarations for SgOmpDependClauseStorageClass 
    7987             :    used for the ast file IO. Do not chance by hand! 
    7988             : */
    7989           0 : class SgOmpDependClauseStorageClass  : public SgOmpVariablesClauseStorageClass
    7990             :    {
    7991             : 
    7992             :     protected: 
    7993             : 
    7994             : 
    7995             : /* #line 7996 "../../../src/frontend/SageIII//StorageClasses.h" */
    7996             : 
    7997             :       SgOmpClause::omp_depend_modifier_enum storageOf_depend_modifier;
    7998             :       SgOmpClause::omp_dependence_type_enum storageOf_dependence_type;
    7999             :        EasyStorage < std::list<std::list<SgExpression*> > > storageOf_iterator;
    8000             :        EasyStorage < std::map<SgSymbol*,  std::vector < std::pair <SgExpression*, SgExpression*> > > > storageOf_array_dimensions;
    8001             :        EasyStorage < std::list<SgExpression*> > storageOf_vec;
    8002             : 
    8003             : 
    8004             : /* #line 10 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarStorageClassDeclatationMacros.macro" */
    8005             : 
    8006             : 
    8007             :     public:
    8008             :       void pickOutIRNodeData ( SgOmpDependClause* source );
    8009             :       static void arrangeStaticDataOfEasyStorageClassesInOneBlock ( );
    8010             :       static void deleteStaticDataOfEasyStorageClasses ( );
    8011             :       static void pickOutStaticDataMembers ( );
    8012             :       static void rebuildStaticDataMembers ( );
    8013             :       static void writeEasyStorageDataToFile (std::ostream& out);
    8014             :       static void readEasyStorageDataFromFile (std::istream& in);
    8015             :       static void writeStaticDataToFile (std::ostream& out );
    8016             :       static void readStaticDataFromFile (std::istream& in );
    8017             :       friend class SgOmpDependClause;
    8018             :    };
    8019             : /* #line 8020 "../../../src/frontend/SageIII//StorageClasses.h" */
    8020             : 
    8021             : 
    8022             : 
    8023             : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarStorageClassDeclatationMacros.macro" */
    8024             : /* 
    8025             :    JH (01/01/2006) ROSETTA generated class declarations for SgOmpAffinityClauseStorageClass 
    8026             :    used for the ast file IO. Do not chance by hand! 
    8027             : */
    8028           0 : class SgOmpAffinityClauseStorageClass  : public SgOmpVariablesClauseStorageClass
    8029             :    {
    8030             : 
    8031             :     protected: 
    8032             : 
    8033             : 
    8034             : /* #line 8035 "../../../src/frontend/SageIII//StorageClasses.h" */
    8035             : 
    8036             :       SgOmpClause::omp_affinity_modifier_enum storageOf_affinity_modifier;
    8037             :        EasyStorage < std::list<std::list<SgExpression*> > > storageOf_iterator;
    8038             :        EasyStorage < std::map<SgSymbol*,  std::vector < std::pair <SgExpression*, SgExpression*> > > > storageOf_array_dimensions;
    8039             : 
    8040             : 
    8041             : /* #line 10 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarStorageClassDeclatationMacros.macro" */
    8042             : 
    8043             : 
    8044             :     public:
    8045             :       void pickOutIRNodeData ( SgOmpAffinityClause* source );
    8046             :       static void arrangeStaticDataOfEasyStorageClassesInOneBlock ( );
    8047             :       static void deleteStaticDataOfEasyStorageClasses ( );
    8048             :       static void pickOutStaticDataMembers ( );
    8049             :       static void rebuildStaticDataMembers ( );
    8050             :       static void writeEasyStorageDataToFile (std::ostream& out);
    8051             :       static void readEasyStorageDataFromFile (std::istream& in);
    8052             :       static void writeStaticDataToFile (std::ostream& out );
    8053             :       static void readStaticDataFromFile (std::istream& in );
    8054             :       friend class SgOmpAffinityClause;
    8055             :    };
    8056             : /* #line 8057 "../../../src/frontend/SageIII//StorageClasses.h" */
    8057             : 
    8058             : 
    8059             : 
    8060             : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarStorageClassDeclatationMacros.macro" */
    8061             : /* 
    8062             :    JH (01/01/2006) ROSETTA generated class declarations for SgOmpToClauseStorageClass 
    8063             :    used for the ast file IO. Do not chance by hand! 
    8064             : */
    8065           0 : class SgOmpToClauseStorageClass  : public SgOmpVariablesClauseStorageClass
    8066             :    {
    8067             : 
    8068             :     protected: 
    8069             : 
    8070             : 
    8071             : /* #line 8072 "../../../src/frontend/SageIII//StorageClasses.h" */
    8072             : 
    8073             :       SgOmpClause::omp_to_kind_enum storageOf_kind;
    8074             :      unsigned long storageOf_mapper_identifier;
    8075             :        EasyStorage < std::map<SgSymbol*,  std::vector < std::pair <SgExpression*, SgExpression*> > > > storageOf_array_dimensions;
    8076             : 
    8077             : 
    8078             : /* #line 10 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarStorageClassDeclatationMacros.macro" */
    8079             : 
    8080             : 
    8081             :     public:
    8082             :       void pickOutIRNodeData ( SgOmpToClause* source );
    8083             :       static void arrangeStaticDataOfEasyStorageClassesInOneBlock ( );
    8084             :       static void deleteStaticDataOfEasyStorageClasses ( );
    8085             :       static void pickOutStaticDataMembers ( );
    8086             :       static void rebuildStaticDataMembers ( );
    8087             :       static void writeEasyStorageDataToFile (std::ostream& out);
    8088             :       static void readEasyStorageDataFromFile (std::istream& in);
    8089             :       static void writeStaticDataToFile (std::ostream& out );
    8090             :       static void readStaticDataFromFile (std::istream& in );
    8091             :       friend class SgOmpToClause;
    8092             :    };
    8093             : /* #line 8094 "../../../src/frontend/SageIII//StorageClasses.h" */
    8094             : 
    8095             : 
    8096             : 
    8097             : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarStorageClassDeclatationMacros.macro" */
    8098             : /* 
    8099             :    JH (01/01/2006) ROSETTA generated class declarations for SgOmpFromClauseStorageClass 
    8100             :    used for the ast file IO. Do not chance by hand! 
    8101             : */
    8102           0 : class SgOmpFromClauseStorageClass  : public SgOmpVariablesClauseStorageClass
    8103             :    {
    8104             : 
    8105             :     protected: 
    8106             : 
    8107             : 
    8108             : /* #line 8109 "../../../src/frontend/SageIII//StorageClasses.h" */
    8109             : 
    8110             :       SgOmpClause::omp_from_kind_enum storageOf_kind;
    8111             :      unsigned long storageOf_mapper_identifier;
    8112             :        EasyStorage < std::map<SgSymbol*,  std::vector < std::pair <SgExpression*, SgExpression*> > > > storageOf_array_dimensions;
    8113             : 
    8114             : 
    8115             : /* #line 10 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarStorageClassDeclatationMacros.macro" */
    8116             : 
    8117             : 
    8118             :     public:
    8119             :       void pickOutIRNodeData ( SgOmpFromClause* source );
    8120             :       static void arrangeStaticDataOfEasyStorageClassesInOneBlock ( );
    8121             :       static void deleteStaticDataOfEasyStorageClasses ( );
    8122             :       static void pickOutStaticDataMembers ( );
    8123             :       static void rebuildStaticDataMembers ( );
    8124             :       static void writeEasyStorageDataToFile (std::ostream& out);
    8125             :       static void readEasyStorageDataFromFile (std::istream& in);
    8126             :       static void writeStaticDataToFile (std::ostream& out );
    8127             :       static void readStaticDataFromFile (std::istream& in );
    8128             :       friend class SgOmpFromClause;
    8129             :    };
    8130             : /* #line 8131 "../../../src/frontend/SageIII//StorageClasses.h" */
    8131             : 
    8132             : 
    8133             : 
    8134             : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarStorageClassDeclatationMacros.macro" */
    8135             : /* 
    8136             :    JH (01/01/2006) ROSETTA generated class declarations for SgOmpScheduleClauseStorageClass 
    8137             :    used for the ast file IO. Do not chance by hand! 
    8138             : */
    8139           0 : class SgOmpScheduleClauseStorageClass  : public SgOmpClauseStorageClass
    8140             :    {
    8141             : 
    8142             :     protected: 
    8143             : 
    8144             : 
    8145             : /* #line 8146 "../../../src/frontend/SageIII//StorageClasses.h" */
    8146             : 
    8147             :       SgOmpClause::omp_schedule_modifier_enum storageOf_modifier;
    8148             :       SgOmpClause::omp_schedule_modifier_enum storageOf_modifier1;
    8149             :       SgOmpClause::omp_schedule_kind_enum storageOf_kind;
    8150             :      unsigned long storageOf_chunk_size;
    8151             : 
    8152             : 
    8153             : /* #line 10 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarStorageClassDeclatationMacros.macro" */
    8154             : 
    8155             : 
    8156             :     public:
    8157             :       void pickOutIRNodeData ( SgOmpScheduleClause* source );
    8158             :       static void arrangeStaticDataOfEasyStorageClassesInOneBlock ( );
    8159             :       static void deleteStaticDataOfEasyStorageClasses ( );
    8160             :       static void pickOutStaticDataMembers ( );
    8161             :       static void rebuildStaticDataMembers ( );
    8162             :       static void writeEasyStorageDataToFile (std::ostream& out);
    8163             :       static void readEasyStorageDataFromFile (std::istream& in);
    8164             :       static void writeStaticDataToFile (std::ostream& out );
    8165             :       static void readStaticDataFromFile (std::istream& in );
    8166             :       friend class SgOmpScheduleClause;
    8167             :    };
    8168             : /* #line 8169 "../../../src/frontend/SageIII//StorageClasses.h" */
    8169             : 
    8170             : 
    8171             : 
    8172             : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarStorageClassDeclatationMacros.macro" */
    8173             : /* 
    8174             :    JH (01/01/2006) ROSETTA generated class declarations for SgOmpMergeableClauseStorageClass 
    8175             :    used for the ast file IO. Do not chance by hand! 
    8176             : */
    8177           0 : class SgOmpMergeableClauseStorageClass  : public SgOmpClauseStorageClass
    8178             :    {
    8179             : 
    8180             :     protected: 
    8181             : 
    8182             : 
    8183             : /* #line 8184 "../../../src/frontend/SageIII//StorageClasses.h" */
    8184             : 
    8185             : 
    8186             : 
    8187             : /* #line 10 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarStorageClassDeclatationMacros.macro" */
    8188             : 
    8189             : 
    8190             :     public:
    8191             :       void pickOutIRNodeData ( SgOmpMergeableClause* source );
    8192             :       static void arrangeStaticDataOfEasyStorageClassesInOneBlock ( );
    8193             :       static void deleteStaticDataOfEasyStorageClasses ( );
    8194             :       static void pickOutStaticDataMembers ( );
    8195             :       static void rebuildStaticDataMembers ( );
    8196             :       static void writeEasyStorageDataToFile (std::ostream& out);
    8197             :       static void readEasyStorageDataFromFile (std::istream& in);
    8198             :       static void writeStaticDataToFile (std::ostream& out );
    8199             :       static void readStaticDataFromFile (std::istream& in );
    8200             :       friend class SgOmpMergeableClause;
    8201             :    };
    8202             : /* #line 8203 "../../../src/frontend/SageIII//StorageClasses.h" */
    8203             : 
    8204             : 
    8205             : 
    8206             : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarStorageClassDeclatationMacros.macro" */
    8207             : /* 
    8208             :    JH (01/01/2006) ROSETTA generated class declarations for SgOmpWhenClauseStorageClass 
    8209             :    used for the ast file IO. Do not chance by hand! 
    8210             : */
    8211           0 : class SgOmpWhenClauseStorageClass  : public SgOmpClauseStorageClass
    8212             :    {
    8213             : 
    8214             :     protected: 
    8215             : 
    8216             : 
    8217             : /* #line 8218 "../../../src/frontend/SageIII//StorageClasses.h" */
    8218             : 
    8219             :      unsigned long storageOf_user_condition;
    8220             :      unsigned long storageOf_user_condition_score;
    8221             :        EasyStorage < std::list<SgStatement*> > storageOf_construct_directives;
    8222             :      unsigned long storageOf_device_arch;
    8223             :      unsigned long storageOf_device_isa;
    8224             :       SgOmpClause::omp_when_context_kind_enum storageOf_device_kind;
    8225             :       SgOmpClause::omp_when_context_vendor_enum storageOf_implementation_vendor;
    8226             :      unsigned long storageOf_implementation_user_defined;
    8227             :      unsigned long storageOf_implementation_extension;
    8228             :      unsigned long storageOf_variant_directive;
    8229             : 
    8230             : 
    8231             : /* #line 10 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarStorageClassDeclatationMacros.macro" */
    8232             : 
    8233             : 
    8234             :     public:
    8235             :       void pickOutIRNodeData ( SgOmpWhenClause* source );
    8236             :       static void arrangeStaticDataOfEasyStorageClassesInOneBlock ( );
    8237             :       static void deleteStaticDataOfEasyStorageClasses ( );
    8238             :       static void pickOutStaticDataMembers ( );
    8239             :       static void rebuildStaticDataMembers ( );
    8240             :       static void writeEasyStorageDataToFile (std::ostream& out);
    8241             :       static void readEasyStorageDataFromFile (std::istream& in);
    8242             :       static void writeStaticDataToFile (std::ostream& out );
    8243             :       static void readStaticDataFromFile (std::istream& in );
    8244             :       friend class SgOmpWhenClause;
    8245             :    };
    8246             : /* #line 8247 "../../../src/frontend/SageIII//StorageClasses.h" */
    8247             : 
    8248             : 
    8249             : 
    8250             : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarStorageClassDeclatationMacros.macro" */
    8251             : /* 
    8252             :    JH (01/01/2006) ROSETTA generated class declarations for SgOmpUsesAllocatorsClauseStorageClass 
    8253             :    used for the ast file IO. Do not chance by hand! 
    8254             : */
    8255           0 : class SgOmpUsesAllocatorsClauseStorageClass  : public SgOmpClauseStorageClass
    8256             :    {
    8257             : 
    8258             :     protected: 
    8259             : 
    8260             : 
    8261             : /* #line 8262 "../../../src/frontend/SageIII//StorageClasses.h" */
    8262             : 
    8263             :        EasyStorage < std::list<SgOmpUsesAllocatorsDefination*> > storageOf_uses_allocators_defination;
    8264             : 
    8265             : 
    8266             : /* #line 10 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarStorageClassDeclatationMacros.macro" */
    8267             : 
    8268             : 
    8269             :     public:
    8270             :       void pickOutIRNodeData ( SgOmpUsesAllocatorsClause* source );
    8271             :       static void arrangeStaticDataOfEasyStorageClassesInOneBlock ( );
    8272             :       static void deleteStaticDataOfEasyStorageClasses ( );
    8273             :       static void pickOutStaticDataMembers ( );
    8274             :       static void rebuildStaticDataMembers ( );
    8275             :       static void writeEasyStorageDataToFile (std::ostream& out);
    8276             :       static void readEasyStorageDataFromFile (std::istream& in);
    8277             :       static void writeStaticDataToFile (std::ostream& out );
    8278             :       static void readStaticDataFromFile (std::istream& in );
    8279             :       friend class SgOmpUsesAllocatorsClause;
    8280             :    };
    8281             : /* #line 8282 "../../../src/frontend/SageIII//StorageClasses.h" */
    8282             : 
    8283             : 
    8284             : 
    8285             : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarStorageClassDeclatationMacros.macro" */
    8286             : /* 
    8287             :    JH (01/01/2006) ROSETTA generated class declarations for SgOmpFullClauseStorageClass 
    8288             :    used for the ast file IO. Do not chance by hand! 
    8289             : */
    8290           0 : class SgOmpFullClauseStorageClass  : public SgOmpClauseStorageClass
    8291             :    {
    8292             : 
    8293             :     protected: 
    8294             : 
    8295             : 
    8296             : /* #line 8297 "../../../src/frontend/SageIII//StorageClasses.h" */
    8297             : 
    8298             : 
    8299             : 
    8300             : /* #line 10 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarStorageClassDeclatationMacros.macro" */
    8301             : 
    8302             : 
    8303             :     public:
    8304             :       void pickOutIRNodeData ( SgOmpFullClause* source );
    8305             :       static void arrangeStaticDataOfEasyStorageClassesInOneBlock ( );
    8306             :       static void deleteStaticDataOfEasyStorageClasses ( );
    8307             :       static void pickOutStaticDataMembers ( );
    8308             :       static void rebuildStaticDataMembers ( );
    8309             :       static void writeEasyStorageDataToFile (std::ostream& out);
    8310             :       static void readEasyStorageDataFromFile (std::istream& in);
    8311             :       static void writeStaticDataToFile (std::ostream& out );
    8312             :       static void readStaticDataFromFile (std::istream& in );
    8313             :       friend class SgOmpFullClause;
    8314             :    };
    8315             : /* #line 8316 "../../../src/frontend/SageIII//StorageClasses.h" */
    8316             : 
    8317             : 
    8318             : 
    8319             : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarStorageClassDeclatationMacros.macro" */
    8320             : /* 
    8321             :    JH (01/01/2006) ROSETTA generated class declarations for SgUpirBranchFieldStorageClass 
    8322             :    used for the ast file IO. Do not chance by hand! 
    8323             : */
    8324           0 : class SgUpirBranchFieldStorageClass  : public SgOmpClauseStorageClass
    8325             :    {
    8326             : 
    8327             :     protected: 
    8328             : 
    8329             : 
    8330             : /* #line 8331 "../../../src/frontend/SageIII//StorageClasses.h" */
    8331             : 
    8332             :        EasyStorage < std::list<std::list<SgStatement*> > > storageOf_branches;
    8333             : 
    8334             : 
    8335             : /* #line 10 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarStorageClassDeclatationMacros.macro" */
    8336             : 
    8337             : 
    8338             :     public:
    8339             :       void pickOutIRNodeData ( SgUpirBranchField* source );
    8340             :       static void arrangeStaticDataOfEasyStorageClassesInOneBlock ( );
    8341             :       static void deleteStaticDataOfEasyStorageClasses ( );
    8342             :       static void pickOutStaticDataMembers ( );
    8343             :       static void rebuildStaticDataMembers ( );
    8344             :       static void writeEasyStorageDataToFile (std::ostream& out);
    8345             :       static void readEasyStorageDataFromFile (std::istream& in);
    8346             :       static void writeStaticDataToFile (std::ostream& out );
    8347             :       static void readStaticDataFromFile (std::istream& in );
    8348             :       friend class SgUpirBranchField;
    8349             :    };
    8350             : /* #line 8351 "../../../src/frontend/SageIII//StorageClasses.h" */
    8351             : 
    8352             : 
    8353             : 
    8354             : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarStorageClassDeclatationMacros.macro" */
    8355             : /* 
    8356             :    JH (01/01/2006) ROSETTA generated class declarations for SgUpirNestedLevelFieldStorageClass 
    8357             :    used for the ast file IO. Do not chance by hand! 
    8358             : */
    8359           0 : class SgUpirNestedLevelFieldStorageClass  : public SgOmpClauseStorageClass
    8360             :    {
    8361             : 
    8362             :     protected: 
    8363             : 
    8364             : 
    8365             : /* #line 8366 "../../../src/frontend/SageIII//StorageClasses.h" */
    8366             : 
    8367             :       int storageOf_nested_level;
    8368             : 
    8369             : 
    8370             : /* #line 10 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarStorageClassDeclatationMacros.macro" */
    8371             : 
    8372             : 
    8373             :     public:
    8374             :       void pickOutIRNodeData ( SgUpirNestedLevelField* source );
    8375             :       static void arrangeStaticDataOfEasyStorageClassesInOneBlock ( );
    8376             :       static void deleteStaticDataOfEasyStorageClasses ( );
    8377             :       static void pickOutStaticDataMembers ( );
    8378             :       static void rebuildStaticDataMembers ( );
    8379             :       static void writeEasyStorageDataToFile (std::ostream& out);
    8380             :       static void readEasyStorageDataFromFile (std::istream& in);
    8381             :       static void writeStaticDataToFile (std::ostream& out );
    8382             :       static void readStaticDataFromFile (std::istream& in );
    8383             :       friend class SgUpirNestedLevelField;
    8384             :    };
    8385             : /* #line 8386 "../../../src/frontend/SageIII//StorageClasses.h" */
    8386             : 
    8387             : 
    8388             : 
    8389             : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarStorageClassDeclatationMacros.macro" */
    8390             : /* 
    8391             :    JH (01/01/2006) ROSETTA generated class declarations for SgUpirNestedParentFieldStorageClass 
    8392             :    used for the ast file IO. Do not chance by hand! 
    8393             : */
    8394           0 : class SgUpirNestedParentFieldStorageClass  : public SgOmpClauseStorageClass
    8395             :    {
    8396             : 
    8397             :     protected: 
    8398             : 
    8399             : 
    8400             : /* #line 8401 "../../../src/frontend/SageIII//StorageClasses.h" */
    8401             : 
    8402             :      unsigned long storageOf_nested_parent;
    8403             : 
    8404             : 
    8405             : /* #line 10 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarStorageClassDeclatationMacros.macro" */
    8406             : 
    8407             : 
    8408             :     public:
    8409             :       void pickOutIRNodeData ( SgUpirNestedParentField* source );
    8410             :       static void arrangeStaticDataOfEasyStorageClassesInOneBlock ( );
    8411             :       static void deleteStaticDataOfEasyStorageClasses ( );
    8412             :       static void pickOutStaticDataMembers ( );
    8413             :       static void rebuildStaticDataMembers ( );
    8414             :       static void writeEasyStorageDataToFile (std::ostream& out);
    8415             :       static void readEasyStorageDataFromFile (std::istream& in);
    8416             :       static void writeStaticDataToFile (std::ostream& out );
    8417             :       static void readStaticDataFromFile (std::istream& in );
    8418             :       friend class SgUpirNestedParentField;
    8419             :    };
    8420             : /* #line 8421 "../../../src/frontend/SageIII//StorageClasses.h" */
    8421             : 
    8422             : 
    8423             : 
    8424             : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarStorageClassDeclatationMacros.macro" */
    8425             : /* 
    8426             :    JH (01/01/2006) ROSETTA generated class declarations for SgUpirNestedChildFieldStorageClass 
    8427             :    used for the ast file IO. Do not chance by hand! 
    8428             : */
    8429           0 : class SgUpirNestedChildFieldStorageClass  : public SgOmpClauseStorageClass
    8430             :    {
    8431             : 
    8432             :     protected: 
    8433             : 
    8434             : 
    8435             : /* #line 8436 "../../../src/frontend/SageIII//StorageClasses.h" */
    8436             : 
    8437             :      unsigned long storageOf_nested_child;
    8438             : 
    8439             : 
    8440             : /* #line 10 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarStorageClassDeclatationMacros.macro" */
    8441             : 
    8442             : 
    8443             :     public:
    8444             :       void pickOutIRNodeData ( SgUpirNestedChildField* source );
    8445             :       static void arrangeStaticDataOfEasyStorageClassesInOneBlock ( );
    8446             :       static void deleteStaticDataOfEasyStorageClasses ( );
    8447             :       static void pickOutStaticDataMembers ( );
    8448             :       static void rebuildStaticDataMembers ( );
    8449             :       static void writeEasyStorageDataToFile (std::ostream& out);
    8450             :       static void readEasyStorageDataFromFile (std::istream& in);
    8451             :       static void writeStaticDataToFile (std::ostream& out );
    8452             :       static void readStaticDataFromFile (std::istream& in );
    8453             :       friend class SgUpirNestedChildField;
    8454             :    };
    8455             : /* #line 8456 "../../../src/frontend/SageIII//StorageClasses.h" */
    8456             : 
    8457             : 
    8458             : 
    8459             : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarStorageClassDeclatationMacros.macro" */
    8460             : /* 
    8461             :    JH (01/01/2006) ROSETTA generated class declarations for SgUpirSyncFieldStorageClass 
    8462             :    used for the ast file IO. Do not chance by hand! 
    8463             : */
    8464           0 : class SgUpirSyncFieldStorageClass  : public SgOmpClauseStorageClass
    8465             :    {
    8466             : 
    8467             :     protected: 
    8468             : 
    8469             : 
    8470             : /* #line 8471 "../../../src/frontend/SageIII//StorageClasses.h" */
    8471             : 
    8472             :      unsigned long storageOf_sync;
    8473             : 
    8474             : 
    8475             : /* #line 10 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarStorageClassDeclatationMacros.macro" */
    8476             : 
    8477             : 
    8478             :     public:
    8479             :       void pickOutIRNodeData ( SgUpirSyncField* source );
    8480             :       static void arrangeStaticDataOfEasyStorageClassesInOneBlock ( );
    8481             :       static void deleteStaticDataOfEasyStorageClasses ( );
    8482             :       static void pickOutStaticDataMembers ( );
    8483             :       static void rebuildStaticDataMembers ( );
    8484             :       static void writeEasyStorageDataToFile (std::ostream& out);
    8485             :       static void readEasyStorageDataFromFile (std::istream& in);
    8486             :       static void writeStaticDataToFile (std::ostream& out );
    8487             :       static void readStaticDataFromFile (std::istream& in );
    8488             :       friend class SgUpirSyncField;
    8489             :    };
    8490             : /* #line 8491 "../../../src/frontend/SageIII//StorageClasses.h" */
    8491             : 
    8492             : 
    8493             : 
    8494             : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarStorageClassDeclatationMacros.macro" */
    8495             : /* 
    8496             :    JH (01/01/2006) ROSETTA generated class declarations for SgUpirDataFieldStorageClass 
    8497             :    used for the ast file IO. Do not chance by hand! 
    8498             : */
    8499           0 : class SgUpirDataFieldStorageClass  : public SgOmpClauseStorageClass
    8500             :    {
    8501             : 
    8502             :     protected: 
    8503             : 
    8504             : 
    8505             : /* #line 8506 "../../../src/frontend/SageIII//StorageClasses.h" */
    8506             : 
    8507             :        EasyStorage < std::list<SgUpirDataItemField*> > storageOf_data;
    8508             :        EasyStorage < std::list<SgUpirDataItemField*> > storageOf_shared_data;
    8509             :        EasyStorage < std::list<SgUpirDataItemField*> > storageOf_private_data;
    8510             :        EasyStorage < std::list<SgUpirDataItemField*> > storageOf_firstprivate_data;
    8511             :        EasyStorage < std::list<SgUpirDataItemField*> > storageOf_lastprivate_data;
    8512             :        EasyStorage < std::list<SgUpirDataItemField*> > storageOf_reduction_data;
    8513             :        EasyStorage < std::list<SgUpirDataItemField*> > storageOf_map_to_data;
    8514             :        EasyStorage < std::list<SgUpirDataItemField*> > storageOf_map_from_data;
    8515             :        EasyStorage < std::list<SgUpirDataItemField*> > storageOf_map_tofrom_data;
    8516             :        EasyStorage < std::list<SgUpirDataItemField*> > storageOf_map_alloc_data;
    8517             : 
    8518             : 
    8519             : /* #line 10 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarStorageClassDeclatationMacros.macro" */
    8520             : 
    8521             : 
    8522             :     public:
    8523             :       void pickOutIRNodeData ( SgUpirDataField* source );
    8524             :       static void arrangeStaticDataOfEasyStorageClassesInOneBlock ( );
    8525             :       static void deleteStaticDataOfEasyStorageClasses ( );
    8526             :       static void pickOutStaticDataMembers ( );
    8527             :       static void rebuildStaticDataMembers ( );
    8528             :       static void writeEasyStorageDataToFile (std::ostream& out);
    8529             :       static void readEasyStorageDataFromFile (std::istream& in);
    8530             :       static void writeStaticDataToFile (std::ostream& out );
    8531             :       static void readStaticDataFromFile (std::istream& in );
    8532             :       friend class SgUpirDataField;
    8533             :    };
    8534             : /* #line 8535 "../../../src/frontend/SageIII//StorageClasses.h" */
    8535             : 
    8536             : 
    8537             : 
    8538             : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarStorageClassDeclatationMacros.macro" */
    8539             : /* 
    8540             :    JH (01/01/2006) ROSETTA generated class declarations for SgUpirTargetFieldStorageClass 
    8541             :    used for the ast file IO. Do not chance by hand! 
    8542             : */
    8543           0 : class SgUpirTargetFieldStorageClass  : public SgOmpClauseStorageClass
    8544             :    {
    8545             : 
    8546             :     protected: 
    8547             : 
    8548             : 
    8549             : /* #line 8550 "../../../src/frontend/SageIII//StorageClasses.h" */
    8550             : 
    8551             :        EasyStorage < std::set<SgOmpClause::upir_target_type_enum> > storageOf_target_type;
    8552             : 
    8553             : 
    8554             : /* #line 10 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarStorageClassDeclatationMacros.macro" */
    8555             : 
    8556             : 
    8557             :     public:
    8558             :       void pickOutIRNodeData ( SgUpirTargetField* source );
    8559             :       static void arrangeStaticDataOfEasyStorageClassesInOneBlock ( );
    8560             :       static void deleteStaticDataOfEasyStorageClasses ( );
    8561             :       static void pickOutStaticDataMembers ( );
    8562             :       static void rebuildStaticDataMembers ( );
    8563             :       static void writeEasyStorageDataToFile (std::ostream& out);
    8564             :       static void readEasyStorageDataFromFile (std::istream& in);
    8565             :       static void writeStaticDataToFile (std::ostream& out );
    8566             :       static void readStaticDataFromFile (std::istream& in );
    8567             :       friend class SgUpirTargetField;
    8568             :    };
    8569             : /* #line 8570 "../../../src/frontend/SageIII//StorageClasses.h" */
    8570             : 
    8571             : 
    8572             : 
    8573             : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarStorageClassDeclatationMacros.macro" */
    8574             : /* 
    8575             :    JH (01/01/2006) ROSETTA generated class declarations for SgUpirDataItemFieldStorageClass 
    8576             :    used for the ast file IO. Do not chance by hand! 
    8577             : */
    8578           0 : class SgUpirDataItemFieldStorageClass  : public SgOmpClauseStorageClass
    8579             :    {
    8580             : 
    8581             :     protected: 
    8582             : 
    8583             : 
    8584             : /* #line 8585 "../../../src/frontend/SageIII//StorageClasses.h" */
    8585             : 
    8586             :      unsigned long storageOf_symbol;
    8587             :       SgOmpClause::upir_data_sharing_enum storageOf_sharing_property;
    8588             :       SgOmpClause::upir_property_visibility_enum storageOf_sharing_visibility;
    8589             :       SgOmpClause::upir_data_mapping_enum storageOf_mapping_property;
    8590             :       SgOmpClause::upir_property_visibility_enum storageOf_mapping_visibility;
    8591             :      unsigned long storageOf_mapper;
    8592             :       SgOmpClause::upir_data_access_enum storageOf_access_property;
    8593             :      unsigned long storageOf_unit_id;
    8594             :       SgOmpClause::upir_data_distribution_pattern_enum storageOf_distribution_pattern;
    8595             :        EasyStorage < std::list<std::list<SgExpression*>> > storageOf_section;
    8596             :       SgOmpClause::upir_data_allocator_enum storageOf_allocator;
    8597             :      unsigned long storageOf_user_defined_allocator;
    8598             :       SgOmpClause::upir_data_deallocator_enum storageOf_deallocator;
    8599             :      unsigned long storageOf_user_defined_deallocator;
    8600             :      unsigned long storageOf_memcpy_helper;
    8601             : 
    8602             : 
    8603             : /* #line 10 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarStorageClassDeclatationMacros.macro" */
    8604             : 
    8605             : 
    8606             :     public:
    8607             :       void pickOutIRNodeData ( SgUpirDataItemField* source );
    8608             :       static void arrangeStaticDataOfEasyStorageClassesInOneBlock ( );
    8609             :       static void deleteStaticDataOfEasyStorageClasses ( );
    8610             :       static void pickOutStaticDataMembers ( );
    8611             :       static void rebuildStaticDataMembers ( );
    8612             :       static void writeEasyStorageDataToFile (std::ostream& out);
    8613             :       static void readEasyStorageDataFromFile (std::istream& in);
    8614             :       static void writeStaticDataToFile (std::ostream& out );
    8615             :       static void readStaticDataFromFile (std::istream& in );
    8616             :       friend class SgUpirDataItemField;
    8617             :    };
    8618             : /* #line 8619 "../../../src/frontend/SageIII//StorageClasses.h" */
    8619             : 
    8620             : 
    8621             : 
    8622             : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarStorageClassDeclatationMacros.macro" */
    8623             : /* 
    8624             :    JH (01/01/2006) ROSETTA generated class declarations for SgLambdaCaptureStorageClass 
    8625             :    used for the ast file IO. Do not chance by hand! 
    8626             : */
    8627           0 : class SgLambdaCaptureStorageClass  : public SgLocatedNodeSupportStorageClass
    8628             :    {
    8629             : 
    8630             :     protected: 
    8631             : 
    8632             : 
    8633             : /* #line 8634 "../../../src/frontend/SageIII//StorageClasses.h" */
    8634             : 
    8635             :      unsigned long storageOf_capture_variable;
    8636             :      unsigned long storageOf_source_closure_variable;
    8637             :      unsigned long storageOf_closure_variable;
    8638             :       bool storageOf_capture_by_reference;
    8639             :       bool storageOf_implicit;
    8640             :       bool storageOf_pack_expansion;
    8641             : 
    8642             : 
    8643             : /* #line 10 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarStorageClassDeclatationMacros.macro" */
    8644             : 
    8645             : 
    8646             :     public:
    8647             :       void pickOutIRNodeData ( SgLambdaCapture* source );
    8648             :       static void arrangeStaticDataOfEasyStorageClassesInOneBlock ( );
    8649             :       static void deleteStaticDataOfEasyStorageClasses ( );
    8650             :       static void pickOutStaticDataMembers ( );
    8651             :       static void rebuildStaticDataMembers ( );
    8652             :       static void writeEasyStorageDataToFile (std::ostream& out);
    8653             :       static void readEasyStorageDataFromFile (std::istream& in);
    8654             :       static void writeStaticDataToFile (std::ostream& out );
    8655             :       static void readStaticDataFromFile (std::istream& in );
    8656             :       friend class SgLambdaCapture;
    8657             :    };
    8658             : /* #line 8659 "../../../src/frontend/SageIII//StorageClasses.h" */
    8659             : 
    8660             : 
    8661             : 
    8662             : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarStorageClassDeclatationMacros.macro" */
    8663             : /* 
    8664             :    JH (01/01/2006) ROSETTA generated class declarations for SgLambdaCaptureListStorageClass 
    8665             :    used for the ast file IO. Do not chance by hand! 
    8666             : */
    8667           0 : class SgLambdaCaptureListStorageClass  : public SgLocatedNodeSupportStorageClass
    8668             :    {
    8669             : 
    8670             :     protected: 
    8671             : 
    8672             : 
    8673             : /* #line 8674 "../../../src/frontend/SageIII//StorageClasses.h" */
    8674             : 
    8675             :        EasyStorage < SgLambdaCapturePtrList > storageOf_capture_list;
    8676             : 
    8677             : 
    8678             : /* #line 10 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarStorageClassDeclatationMacros.macro" */
    8679             : 
    8680             : 
    8681             :     public:
    8682             :       void pickOutIRNodeData ( SgLambdaCaptureList* source );
    8683             :       static void arrangeStaticDataOfEasyStorageClassesInOneBlock ( );
    8684             :       static void deleteStaticDataOfEasyStorageClasses ( );
    8685             :       static void pickOutStaticDataMembers ( );
    8686             :       static void rebuildStaticDataMembers ( );
    8687             :       static void writeEasyStorageDataToFile (std::ostream& out);
    8688             :       static void readEasyStorageDataFromFile (std::istream& in);
    8689             :       static void writeStaticDataToFile (std::ostream& out );
    8690             :       static void readStaticDataFromFile (std::istream& in );
    8691             :       friend class SgLambdaCaptureList;
    8692             :    };
    8693             : /* #line 8694 "../../../src/frontend/SageIII//StorageClasses.h" */
    8694             : 
    8695             : 
    8696             : 
    8697             : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarStorageClassDeclatationMacros.macro" */
    8698             : /* 
    8699             :    JH (01/01/2006) ROSETTA generated class declarations for SgStatementStorageClass 
    8700             :    used for the ast file IO. Do not chance by hand! 
    8701             : */
    8702           0 : class SgStatementStorageClass  : public SgLocatedNodeStorageClass
    8703             :    {
    8704             : 
    8705             :     protected: 
    8706             : 
    8707             : 
    8708             : /* #line 8709 "../../../src/frontend/SageIII//StorageClasses.h" */
    8709             : 
    8710             :      unsigned long storageOf_numeric_label;
    8711             :       int storageOf_source_sequence_value;
    8712             : 
    8713             : 
    8714             : /* #line 10 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarStorageClassDeclatationMacros.macro" */
    8715             : 
    8716             : 
    8717             :     public:
    8718             :       void pickOutIRNodeData ( SgStatement* source );
    8719             :       static void arrangeStaticDataOfEasyStorageClassesInOneBlock ( );
    8720             :       static void deleteStaticDataOfEasyStorageClasses ( );
    8721             :       static void pickOutStaticDataMembers ( );
    8722             :       static void rebuildStaticDataMembers ( );
    8723             :       static void writeEasyStorageDataToFile (std::ostream& out);
    8724             :       static void readEasyStorageDataFromFile (std::istream& in);
    8725             :       static void writeStaticDataToFile (std::ostream& out );
    8726             :       static void readStaticDataFromFile (std::istream& in );
    8727             :       friend class SgStatement;
    8728             :    };
    8729             : /* #line 8730 "../../../src/frontend/SageIII//StorageClasses.h" */
    8730             : 
    8731             : 
    8732             : 
    8733             : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarStorageClassDeclatationMacros.macro" */
    8734             : /* 
    8735             :    JH (01/01/2006) ROSETTA generated class declarations for SgScopeStatementStorageClass 
    8736             :    used for the ast file IO. Do not chance by hand! 
    8737             : */
    8738           0 : class SgScopeStatementStorageClass  : public SgStatementStorageClass
    8739             :    {
    8740             : 
    8741             :     protected: 
    8742             : 
    8743             : 
    8744             : /* #line 8745 "../../../src/frontend/SageIII//StorageClasses.h" */
    8745             : 
    8746             :      unsigned long storageOf_symbol_table;
    8747             :      unsigned long storageOf_type_table;
    8748             :        EasyStorage < std::set<SgSymbol*> > storageOf_type_elaboration_list;
    8749             :        EasyStorage < std::set<SgSymbol*> > storageOf_hidden_type_list;
    8750             :        EasyStorage < std::set<SgSymbol*> > storageOf_hidden_declaration_list;
    8751             :      unsigned long storageOf_pragma;
    8752             : 
    8753             : 
    8754             : /* #line 10 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarStorageClassDeclatationMacros.macro" */
    8755             : 
    8756             : 
    8757             :     public:
    8758             :       void pickOutIRNodeData ( SgScopeStatement* source );
    8759             :       static void arrangeStaticDataOfEasyStorageClassesInOneBlock ( );
    8760             :       static void deleteStaticDataOfEasyStorageClasses ( );
    8761             :       static void pickOutStaticDataMembers ( );
    8762             :       static void rebuildStaticDataMembers ( );
    8763             :       static void writeEasyStorageDataToFile (std::ostream& out);
    8764             :       static void readEasyStorageDataFromFile (std::istream& in);
    8765             :       static void writeStaticDataToFile (std::ostream& out );
    8766             :       static void readStaticDataFromFile (std::istream& in );
    8767             :       friend class SgScopeStatement;
    8768             :    };
    8769             : /* #line 8770 "../../../src/frontend/SageIII//StorageClasses.h" */
    8770             : 
    8771             : 
    8772             : 
    8773             : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarStorageClassDeclatationMacros.macro" */
    8774             : /* 
    8775             :    JH (01/01/2006) ROSETTA generated class declarations for SgGlobalStorageClass 
    8776             :    used for the ast file IO. Do not chance by hand! 
    8777             : */
    8778          10 : class SgGlobalStorageClass  : public SgScopeStatementStorageClass
    8779             :    {
    8780             : 
    8781             :     protected: 
    8782             : 
    8783             : 
    8784             : /* #line 8785 "../../../src/frontend/SageIII//StorageClasses.h" */
    8785             : 
    8786             :        EasyStorage < SgDeclarationStatementPtrList > storageOf_declarations;
    8787             : 
    8788             : 
    8789             : /* #line 10 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarStorageClassDeclatationMacros.macro" */
    8790             : 
    8791             : 
    8792             :     public:
    8793             :       void pickOutIRNodeData ( SgGlobal* source );
    8794             :       static void arrangeStaticDataOfEasyStorageClassesInOneBlock ( );
    8795             :       static void deleteStaticDataOfEasyStorageClasses ( );
    8796             :       static void pickOutStaticDataMembers ( );
    8797             :       static void rebuildStaticDataMembers ( );
    8798             :       static void writeEasyStorageDataToFile (std::ostream& out);
    8799             :       static void readEasyStorageDataFromFile (std::istream& in);
    8800             :       static void writeStaticDataToFile (std::ostream& out );
    8801             :       static void readStaticDataFromFile (std::istream& in );
    8802             :       friend class SgGlobal;
    8803             :    };
    8804             : /* #line 8805 "../../../src/frontend/SageIII//StorageClasses.h" */
    8805             : 
    8806             : 
    8807             : 
    8808             : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarStorageClassDeclatationMacros.macro" */
    8809             : /* 
    8810             :    JH (01/01/2006) ROSETTA generated class declarations for SgBasicBlockStorageClass 
    8811             :    used for the ast file IO. Do not chance by hand! 
    8812             : */
    8813        5731 : class SgBasicBlockStorageClass  : public SgScopeStatementStorageClass
    8814             :    {
    8815             : 
    8816             :     protected: 
    8817             : 
    8818             : 
    8819             : /* #line 8820 "../../../src/frontend/SageIII//StorageClasses.h" */
    8820             : 
    8821             :        EasyStorage < SgStatementPtrList > storageOf_statements;
    8822             :        EasyStorage < std::string > storageOf_asm_function_body;
    8823             :        EasyStorage < std::string > storageOf_string_label;
    8824             : 
    8825             : 
    8826             : /* #line 10 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarStorageClassDeclatationMacros.macro" */
    8827             : 
    8828             : 
    8829             :     public:
    8830             :       void pickOutIRNodeData ( SgBasicBlock* source );
    8831             :       static void arrangeStaticDataOfEasyStorageClassesInOneBlock ( );
    8832             :       static void deleteStaticDataOfEasyStorageClasses ( );
    8833             :       static void pickOutStaticDataMembers ( );
    8834             :       static void rebuildStaticDataMembers ( );
    8835             :       static void writeEasyStorageDataToFile (std::ostream& out);
    8836             :       static void readEasyStorageDataFromFile (std::istream& in);
    8837             :       static void writeStaticDataToFile (std::ostream& out );
    8838             :       static void readStaticDataFromFile (std::istream& in );
    8839             :       friend class SgBasicBlock;
    8840             :    };
    8841             : /* #line 8842 "../../../src/frontend/SageIII//StorageClasses.h" */
    8842             : 
    8843             : 
    8844             : 
    8845             : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarStorageClassDeclatationMacros.macro" */
    8846             : /* 
    8847             :    JH (01/01/2006) ROSETTA generated class declarations for SgIfStmtStorageClass 
    8848             :    used for the ast file IO. Do not chance by hand! 
    8849             : */
    8850        1184 : class SgIfStmtStorageClass  : public SgScopeStatementStorageClass
    8851             :    {
    8852             : 
    8853             :     protected: 
    8854             : 
    8855             : 
    8856             : /* #line 8857 "../../../src/frontend/SageIII//StorageClasses.h" */
    8857             : 
    8858             :      unsigned long storageOf_conditional;
    8859             :      unsigned long storageOf_true_body;
    8860             :      unsigned long storageOf_false_body;
    8861             :       bool storageOf_is_if_constexpr_statement;
    8862             :       bool storageOf_if_constexpr_value_known;
    8863             :       bool storageOf_if_constexpr_value;
    8864             :      unsigned long storageOf_else_numeric_label;
    8865             :        EasyStorage < std::string > storageOf_string_label;
    8866             :      unsigned long storageOf_end_numeric_label;
    8867             :       bool storageOf_has_end_statement;
    8868             :       bool storageOf_use_then_keyword;
    8869             :       bool storageOf_is_else_if_statement;
    8870             : 
    8871             : 
    8872             : /* #line 10 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarStorageClassDeclatationMacros.macro" */
    8873             : 
    8874             : 
    8875             :     public:
    8876             :       void pickOutIRNodeData ( SgIfStmt* source );
    8877             :       static void arrangeStaticDataOfEasyStorageClassesInOneBlock ( );
    8878             :       static void deleteStaticDataOfEasyStorageClasses ( );
    8879             :       static void pickOutStaticDataMembers ( );
    8880             :       static void rebuildStaticDataMembers ( );
    8881             :       static void writeEasyStorageDataToFile (std::ostream& out);
    8882             :       static void readEasyStorageDataFromFile (std::istream& in);
    8883             :       static void writeStaticDataToFile (std::ostream& out );
    8884             :       static void readStaticDataFromFile (std::istream& in );
    8885             :       friend class SgIfStmt;
    8886             :    };
    8887             : /* #line 8888 "../../../src/frontend/SageIII//StorageClasses.h" */
    8888             : 
    8889             : 
    8890             : 
    8891             : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarStorageClassDeclatationMacros.macro" */
    8892             : /* 
    8893             :    JH (01/01/2006) ROSETTA generated class declarations for SgForStatementStorageClass 
    8894             :    used for the ast file IO. Do not chance by hand! 
    8895             : */
    8896          80 : class SgForStatementStorageClass  : public SgScopeStatementStorageClass
    8897             :    {
    8898             : 
    8899             :     protected: 
    8900             : 
    8901             : 
    8902             : /* #line 8903 "../../../src/frontend/SageIII//StorageClasses.h" */
    8903             : 
    8904             :      unsigned long storageOf_for_init_stmt;
    8905             :      unsigned long storageOf_test;
    8906             :      unsigned long storageOf_increment;
    8907             :      unsigned long storageOf_loop_body;
    8908             :      unsigned long storageOf_else_body;
    8909             :        EasyStorage < std::string > storageOf_string_label;
    8910             : 
    8911             : 
    8912             : /* #line 10 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarStorageClassDeclatationMacros.macro" */
    8913             : 
    8914             : 
    8915             :     public:
    8916             :       void pickOutIRNodeData ( SgForStatement* source );
    8917             :       static void arrangeStaticDataOfEasyStorageClassesInOneBlock ( );
    8918             :       static void deleteStaticDataOfEasyStorageClasses ( );
    8919             :       static void pickOutStaticDataMembers ( );
    8920             :       static void rebuildStaticDataMembers ( );
    8921             :       static void writeEasyStorageDataToFile (std::ostream& out);
    8922             :       static void readEasyStorageDataFromFile (std::istream& in);
    8923             :       static void writeStaticDataToFile (std::ostream& out );
    8924             :       static void readStaticDataFromFile (std::istream& in );
    8925             :       friend class SgForStatement;
    8926             :    };
    8927             : /* #line 8928 "../../../src/frontend/SageIII//StorageClasses.h" */
    8928             : 
    8929             : 
    8930             : 
    8931             : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarStorageClassDeclatationMacros.macro" */
    8932             : /* 
    8933             :    JH (01/01/2006) ROSETTA generated class declarations for SgFunctionDefinitionStorageClass 
    8934             :    used for the ast file IO. Do not chance by hand! 
    8935             : */
    8936        3165 : class SgFunctionDefinitionStorageClass  : public SgScopeStatementStorageClass
    8937             :    {
    8938             : 
    8939             :     protected: 
    8940             : 
    8941             : 
    8942             : /* #line 8943 "../../../src/frontend/SageIII//StorageClasses.h" */
    8943             : 
    8944             :      unsigned long storageOf_body;
    8945             :        EasyStorage < std::map<SgNode*,int> > storageOf_scope_number_list;
    8946             : 
    8947             : 
    8948             : /* #line 10 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarStorageClassDeclatationMacros.macro" */
    8949             : 
    8950             : 
    8951             :     public:
    8952             :       void pickOutIRNodeData ( SgFunctionDefinition* source );
    8953             :       static void arrangeStaticDataOfEasyStorageClassesInOneBlock ( );
    8954             :       static void deleteStaticDataOfEasyStorageClasses ( );
    8955             :       static void pickOutStaticDataMembers ( );
    8956             :       static void rebuildStaticDataMembers ( );
    8957             :       static void writeEasyStorageDataToFile (std::ostream& out);
    8958             :       static void readEasyStorageDataFromFile (std::istream& in);
    8959             :       static void writeStaticDataToFile (std::ostream& out );
    8960             :       static void readStaticDataFromFile (std::istream& in );
    8961             :       friend class SgFunctionDefinition;
    8962             :    };
    8963             : /* #line 8964 "../../../src/frontend/SageIII//StorageClasses.h" */
    8964             : 
    8965             : 
    8966             : 
    8967             : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarStorageClassDeclatationMacros.macro" */
    8968             : /* 
    8969             :    JH (01/01/2006) ROSETTA generated class declarations for SgTemplateFunctionDefinitionStorageClass 
    8970             :    used for the ast file IO. Do not chance by hand! 
    8971             : */
    8972         630 : class SgTemplateFunctionDefinitionStorageClass  : public SgFunctionDefinitionStorageClass
    8973             :    {
    8974             : 
    8975             :     protected: 
    8976             : 
    8977             : 
    8978             : /* #line 8979 "../../../src/frontend/SageIII//StorageClasses.h" */
    8979             : 
    8980             : 
    8981             : 
    8982             : /* #line 10 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarStorageClassDeclatationMacros.macro" */
    8983             : 
    8984             : 
    8985             :     public:
    8986             :       void pickOutIRNodeData ( SgTemplateFunctionDefinition* source );
    8987             :       static void arrangeStaticDataOfEasyStorageClassesInOneBlock ( );
    8988             :       static void deleteStaticDataOfEasyStorageClasses ( );
    8989             :       static void pickOutStaticDataMembers ( );
    8990             :       static void rebuildStaticDataMembers ( );
    8991             :       static void writeEasyStorageDataToFile (std::ostream& out);
    8992             :       static void readEasyStorageDataFromFile (std::istream& in);
    8993             :       static void writeStaticDataToFile (std::ostream& out );
    8994             :       static void readStaticDataFromFile (std::istream& in );
    8995             :       friend class SgTemplateFunctionDefinition;
    8996             :    };
    8997             : /* #line 8998 "../../../src/frontend/SageIII//StorageClasses.h" */
    8998             : 
    8999             : 
    9000             : 
    9001             : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarStorageClassDeclatationMacros.macro" */
    9002             : /* 
    9003             :    JH (01/01/2006) ROSETTA generated class declarations for SgClassDefinitionStorageClass 
    9004             :    used for the ast file IO. Do not chance by hand! 
    9005             : */
    9006         336 : class SgClassDefinitionStorageClass  : public SgScopeStatementStorageClass
    9007             :    {
    9008             : 
    9009             :     protected: 
    9010             : 
    9011             : 
    9012             : /* #line 9013 "../../../src/frontend/SageIII//StorageClasses.h" */
    9013             : 
    9014             :        EasyStorage < SgDeclarationStatementPtrList > storageOf_members;
    9015             :        EasyStorage < SgBaseClassPtrList > storageOf_inheritances;
    9016             :       unsigned int storageOf_packingAlignment;
    9017             :       bool storageOf_isSequence;
    9018             :       bool storageOf_isPrivate;
    9019             :       bool storageOf_isAbstract;
    9020             : 
    9021             : 
    9022             : /* #line 10 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarStorageClassDeclatationMacros.macro" */
    9023             : 
    9024             : 
    9025             :     public:
    9026             :       void pickOutIRNodeData ( SgClassDefinition* source );
    9027             :       static void arrangeStaticDataOfEasyStorageClassesInOneBlock ( );
    9028             :       static void deleteStaticDataOfEasyStorageClasses ( );
    9029             :       static void pickOutStaticDataMembers ( );
    9030             :       static void rebuildStaticDataMembers ( );
    9031             :       static void writeEasyStorageDataToFile (std::ostream& out);
    9032             :       static void readEasyStorageDataFromFile (std::istream& in);
    9033             :       static void writeStaticDataToFile (std::ostream& out );
    9034             :       static void readStaticDataFromFile (std::istream& in );
    9035             :       friend class SgClassDefinition;
    9036             :    };
    9037             : /* #line 9038 "../../../src/frontend/SageIII//StorageClasses.h" */
    9038             : 
    9039             : 
    9040             : 
    9041             : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarStorageClassDeclatationMacros.macro" */
    9042             : /* 
    9043             :    JH (01/01/2006) ROSETTA generated class declarations for SgTemplateInstantiationDefnStorageClass 
    9044             :    used for the ast file IO. Do not chance by hand! 
    9045             : */
    9046        1202 : class SgTemplateInstantiationDefnStorageClass  : public SgClassDefinitionStorageClass
    9047             :    {
    9048             : 
    9049             :     protected: 
    9050             : 
    9051             : 
    9052             : /* #line 9053 "../../../src/frontend/SageIII//StorageClasses.h" */
    9053             : 
    9054             : 
    9055             : 
    9056             : /* #line 10 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarStorageClassDeclatationMacros.macro" */
    9057             : 
    9058             : 
    9059             :     public:
    9060             :       void pickOutIRNodeData ( SgTemplateInstantiationDefn* source );
    9061             :       static void arrangeStaticDataOfEasyStorageClassesInOneBlock ( );
    9062             :       static void deleteStaticDataOfEasyStorageClasses ( );
    9063             :       static void pickOutStaticDataMembers ( );
    9064             :       static void rebuildStaticDataMembers ( );
    9065             :       static void writeEasyStorageDataToFile (std::ostream& out);
    9066             :       static void readEasyStorageDataFromFile (std::istream& in);
    9067             :       static void writeStaticDataToFile (std::ostream& out );
    9068             :       static void readStaticDataFromFile (std::istream& in );
    9069             :       friend class SgTemplateInstantiationDefn;
    9070             :    };
    9071             : /* #line 9072 "../../../src/frontend/SageIII//StorageClasses.h" */
    9072             : 
    9073             : 
    9074             : 
    9075             : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarStorageClassDeclatationMacros.macro" */
    9076             : /* 
    9077             :    JH (01/01/2006) ROSETTA generated class declarations for SgTemplateClassDefinitionStorageClass 
    9078             :    used for the ast file IO. Do not chance by hand! 
    9079             : */
    9080        1012 : class SgTemplateClassDefinitionStorageClass  : public SgClassDefinitionStorageClass
    9081             :    {
    9082             : 
    9083             :     protected: 
    9084             : 
    9085             : 
    9086             : /* #line 9087 "../../../src/frontend/SageIII//StorageClasses.h" */
    9087             : 
    9088             : 
    9089             : 
    9090             : /* #line 10 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarStorageClassDeclatationMacros.macro" */
    9091             : 
    9092             : 
    9093             :     public:
    9094             :       void pickOutIRNodeData ( SgTemplateClassDefinition* source );
    9095             :       static void arrangeStaticDataOfEasyStorageClassesInOneBlock ( );
    9096             :       static void deleteStaticDataOfEasyStorageClasses ( );
    9097             :       static void pickOutStaticDataMembers ( );
    9098             :       static void rebuildStaticDataMembers ( );
    9099             :       static void writeEasyStorageDataToFile (std::ostream& out);
    9100             :       static void readEasyStorageDataFromFile (std::istream& in);
    9101             :       static void writeStaticDataToFile (std::ostream& out );
    9102             :       static void readStaticDataFromFile (std::istream& in );
    9103             :       friend class SgTemplateClassDefinition;
    9104             :    };
    9105             : /* #line 9106 "../../../src/frontend/SageIII//StorageClasses.h" */
    9106             : 
    9107             : 
    9108             : 
    9109             : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarStorageClassDeclatationMacros.macro" */
    9110             : /* 
    9111             :    JH (01/01/2006) ROSETTA generated class declarations for SgWhileStmtStorageClass 
    9112             :    used for the ast file IO. Do not chance by hand! 
    9113             : */
    9114          94 : class SgWhileStmtStorageClass  : public SgScopeStatementStorageClass
    9115             :    {
    9116             : 
    9117             :     protected: 
    9118             : 
    9119             : 
    9120             : /* #line 9121 "../../../src/frontend/SageIII//StorageClasses.h" */
    9121             : 
    9122             :      unsigned long storageOf_condition;
    9123             :      unsigned long storageOf_body;
    9124             :      unsigned long storageOf_else_body;
    9125             :      unsigned long storageOf_end_numeric_label;
    9126             :        EasyStorage < std::string > storageOf_string_label;
    9127             :       bool storageOf_has_end_statement;
    9128             : 
    9129             : 
    9130             : /* #line 10 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarStorageClassDeclatationMacros.macro" */
    9131             : 
    9132             : 
    9133             :     public:
    9134             :       void pickOutIRNodeData ( SgWhileStmt* source );
    9135             :       static void arrangeStaticDataOfEasyStorageClassesInOneBlock ( );
    9136             :       static void deleteStaticDataOfEasyStorageClasses ( );
    9137             :       static void pickOutStaticDataMembers ( );
    9138             :       static void rebuildStaticDataMembers ( );
    9139             :       static void writeEasyStorageDataToFile (std::ostream& out);
    9140             :       static void readEasyStorageDataFromFile (std::istream& in);
    9141             :       static void writeStaticDataToFile (std::ostream& out );
    9142             :       static void readStaticDataFromFile (std::istream& in );
    9143             :       friend class SgWhileStmt;
    9144             :    };
    9145             : /* #line 9146 "../../../src/frontend/SageIII//StorageClasses.h" */
    9146             : 
    9147             : 
    9148             : 
    9149             : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarStorageClassDeclatationMacros.macro" */
    9150             : /* 
    9151             :    JH (01/01/2006) ROSETTA generated class declarations for SgDoWhileStmtStorageClass 
    9152             :    used for the ast file IO. Do not chance by hand! 
    9153             : */
    9154          14 : class SgDoWhileStmtStorageClass  : public SgScopeStatementStorageClass
    9155             :    {
    9156             : 
    9157             :     protected: 
    9158             : 
    9159             : 
    9160             : /* #line 9161 "../../../src/frontend/SageIII//StorageClasses.h" */
    9161             : 
    9162             :      unsigned long storageOf_body;
    9163             :      unsigned long storageOf_condition;
    9164             : 
    9165             : 
    9166             : /* #line 10 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarStorageClassDeclatationMacros.macro" */
    9167             : 
    9168             : 
    9169             :     public:
    9170             :       void pickOutIRNodeData ( SgDoWhileStmt* source );
    9171             :       static void arrangeStaticDataOfEasyStorageClassesInOneBlock ( );
    9172             :       static void deleteStaticDataOfEasyStorageClasses ( );
    9173             :       static void pickOutStaticDataMembers ( );
    9174             :       static void rebuildStaticDataMembers ( );
    9175             :       static void writeEasyStorageDataToFile (std::ostream& out);
    9176             :       static void readEasyStorageDataFromFile (std::istream& in);
    9177             :       static void writeStaticDataToFile (std::ostream& out );
    9178             :       static void readStaticDataFromFile (std::istream& in );
    9179             :       friend class SgDoWhileStmt;
    9180             :    };
    9181             : /* #line 9182 "../../../src/frontend/SageIII//StorageClasses.h" */
    9182             : 
    9183             : 
    9184             : 
    9185             : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarStorageClassDeclatationMacros.macro" */
    9186             : /* 
    9187             :    JH (01/01/2006) ROSETTA generated class declarations for SgSwitchStatementStorageClass 
    9188             :    used for the ast file IO. Do not chance by hand! 
    9189             : */
    9190           0 : class SgSwitchStatementStorageClass  : public SgScopeStatementStorageClass
    9191             :    {
    9192             : 
    9193             :     protected: 
    9194             : 
    9195             : 
    9196             : /* #line 9197 "../../../src/frontend/SageIII//StorageClasses.h" */
    9197             : 
    9198             :      unsigned long storageOf_item_selector;
    9199             :      unsigned long storageOf_body;
    9200             :      unsigned long storageOf_end_numeric_label;
    9201             :        EasyStorage < std::string > storageOf_string_label;
    9202             : 
    9203             : 
    9204             : /* #line 10 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarStorageClassDeclatationMacros.macro" */
    9205             : 
    9206             : 
    9207             :     public:
    9208             :       void pickOutIRNodeData ( SgSwitchStatement* source );
    9209             :       static void arrangeStaticDataOfEasyStorageClassesInOneBlock ( );
    9210             :       static void deleteStaticDataOfEasyStorageClasses ( );
    9211             :       static void pickOutStaticDataMembers ( );
    9212             :       static void rebuildStaticDataMembers ( );
    9213             :       static void writeEasyStorageDataToFile (std::ostream& out);
    9214             :       static void readEasyStorageDataFromFile (std::istream& in);
    9215             :       static void writeStaticDataToFile (std::ostream& out );
    9216             :       static void readStaticDataFromFile (std::istream& in );
    9217             :       friend class SgSwitchStatement;
    9218             :    };
    9219             : /* #line 9220 "../../../src/frontend/SageIII//StorageClasses.h" */
    9220             : 
    9221             : 
    9222             : 
    9223             : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarStorageClassDeclatationMacros.macro" */
    9224             : /* 
    9225             :    JH (01/01/2006) ROSETTA generated class declarations for SgCatchOptionStmtStorageClass 
    9226             :    used for the ast file IO. Do not chance by hand! 
    9227             : */
    9228         180 : class SgCatchOptionStmtStorageClass  : public SgScopeStatementStorageClass
    9229             :    {
    9230             : 
    9231             :     protected: 
    9232             : 
    9233             : 
    9234             : /* #line 9235 "../../../src/frontend/SageIII//StorageClasses.h" */
    9235             : 
    9236             :      unsigned long storageOf_condition;
    9237             :      unsigned long storageOf_body;
    9238             :      unsigned long storageOf_trystmt;
    9239             : 
    9240             : 
    9241             : /* #line 10 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarStorageClassDeclatationMacros.macro" */
    9242             : 
    9243             : 
    9244             :     public:
    9245             :       void pickOutIRNodeData ( SgCatchOptionStmt* source );
    9246             :       static void arrangeStaticDataOfEasyStorageClassesInOneBlock ( );
    9247             :       static void deleteStaticDataOfEasyStorageClasses ( );
    9248             :       static void pickOutStaticDataMembers ( );
    9249             :       static void rebuildStaticDataMembers ( );
    9250             :       static void writeEasyStorageDataToFile (std::ostream& out);
    9251             :       static void readEasyStorageDataFromFile (std::istream& in);
    9252             :       static void writeStaticDataToFile (std::ostream& out );
    9253             :       static void readStaticDataFromFile (std::istream& in );
    9254             :       friend class SgCatchOptionStmt;
    9255             :    };
    9256             : /* #line 9257 "../../../src/frontend/SageIII//StorageClasses.h" */
    9257             : 
    9258             : 
    9259             : 
    9260             : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarStorageClassDeclatationMacros.macro" */
    9261             : /* 
    9262             :    JH (01/01/2006) ROSETTA generated class declarations for SgNamespaceDefinitionStatementStorageClass 
    9263             :    used for the ast file IO. Do not chance by hand! 
    9264             : */
    9265         270 : class SgNamespaceDefinitionStatementStorageClass  : public SgScopeStatementStorageClass
    9266             :    {
    9267             : 
    9268             :     protected: 
    9269             : 
    9270             : 
    9271             : /* #line 9272 "../../../src/frontend/SageIII//StorageClasses.h" */
    9272             : 
    9273             :        EasyStorage < SgDeclarationStatementPtrList > storageOf_declarations;
    9274             :      unsigned long storageOf_namespaceDeclaration;
    9275             :      unsigned long storageOf_previousNamespaceDefinition;
    9276             :      unsigned long storageOf_nextNamespaceDefinition;
    9277             :      unsigned long storageOf_global_definition;
    9278             :       bool storageOf_isUnionOfReentrantNamespaceDefinitions;
    9279             : 
    9280             : 
    9281             : /* #line 10 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarStorageClassDeclatationMacros.macro" */
    9282             : 
    9283             : 
    9284             :     public:
    9285             :       void pickOutIRNodeData ( SgNamespaceDefinitionStatement* source );
    9286             :       static void arrangeStaticDataOfEasyStorageClassesInOneBlock ( );
    9287             :       static void deleteStaticDataOfEasyStorageClasses ( );
    9288             :       static void pickOutStaticDataMembers ( );
    9289             :       static void rebuildStaticDataMembers ( );
    9290             :       static void writeEasyStorageDataToFile (std::ostream& out);
    9291             :       static void readEasyStorageDataFromFile (std::istream& in);
    9292             :       static void writeStaticDataToFile (std::ostream& out );
    9293             :       static void readStaticDataFromFile (std::istream& in );
    9294             :       friend class SgNamespaceDefinitionStatement;
    9295             :    };
    9296             : /* #line 9297 "../../../src/frontend/SageIII//StorageClasses.h" */
    9297             : 
    9298             : 
    9299             : 
    9300             : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarStorageClassDeclatationMacros.macro" */
    9301             : /* 
    9302             :    JH (01/01/2006) ROSETTA generated class declarations for SgBlockDataStatementStorageClass 
    9303             :    used for the ast file IO. Do not chance by hand! 
    9304             : */
    9305           0 : class SgBlockDataStatementStorageClass  : public SgScopeStatementStorageClass
    9306             :    {
    9307             : 
    9308             :     protected: 
    9309             : 
    9310             : 
    9311             : /* #line 9312 "../../../src/frontend/SageIII//StorageClasses.h" */
    9312             : 
    9313             :      unsigned long storageOf_body;
    9314             : 
    9315             : 
    9316             : /* #line 10 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarStorageClassDeclatationMacros.macro" */
    9317             : 
    9318             : 
    9319             :     public:
    9320             :       void pickOutIRNodeData ( SgBlockDataStatement* source );
    9321             :       static void arrangeStaticDataOfEasyStorageClassesInOneBlock ( );
    9322             :       static void deleteStaticDataOfEasyStorageClasses ( );
    9323             :       static void pickOutStaticDataMembers ( );
    9324             :       static void rebuildStaticDataMembers ( );
    9325             :       static void writeEasyStorageDataToFile (std::ostream& out);
    9326             :       static void readEasyStorageDataFromFile (std::istream& in);
    9327             :       static void writeStaticDataToFile (std::ostream& out );
    9328             :       static void readStaticDataFromFile (std::istream& in );
    9329             :       friend class SgBlockDataStatement;
    9330             :    };
    9331             : /* #line 9332 "../../../src/frontend/SageIII//StorageClasses.h" */
    9332             : 
    9333             : 
    9334             : 
    9335             : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarStorageClassDeclatationMacros.macro" */
    9336             : /* 
    9337             :    JH (01/01/2006) ROSETTA generated class declarations for SgAssociateStatementStorageClass 
    9338             :    used for the ast file IO. Do not chance by hand! 
    9339             : */
    9340           0 : class SgAssociateStatementStorageClass  : public SgScopeStatementStorageClass
    9341             :    {
    9342             : 
    9343             :     protected: 
    9344             : 
    9345             : 
    9346             : /* #line 9347 "../../../src/frontend/SageIII//StorageClasses.h" */
    9347             : 
    9348             :        EasyStorage < SgDeclarationStatementPtrList > storageOf_associates;
    9349             :      unsigned long storageOf_body;
    9350             : 
    9351             : 
    9352             : /* #line 10 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarStorageClassDeclatationMacros.macro" */
    9353             : 
    9354             : 
    9355             :     public:
    9356             :       void pickOutIRNodeData ( SgAssociateStatement* source );
    9357             :       static void arrangeStaticDataOfEasyStorageClassesInOneBlock ( );
    9358             :       static void deleteStaticDataOfEasyStorageClasses ( );
    9359             :       static void pickOutStaticDataMembers ( );
    9360             :       static void rebuildStaticDataMembers ( );
    9361             :       static void writeEasyStorageDataToFile (std::ostream& out);
    9362             :       static void readEasyStorageDataFromFile (std::istream& in);
    9363             :       static void writeStaticDataToFile (std::ostream& out );
    9364             :       static void readStaticDataFromFile (std::istream& in );
    9365             :       friend class SgAssociateStatement;
    9366             :    };
    9367             : /* #line 9368 "../../../src/frontend/SageIII//StorageClasses.h" */
    9368             : 
    9369             : 
    9370             : 
    9371             : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarStorageClassDeclatationMacros.macro" */
    9372             : /* 
    9373             :    JH (01/01/2006) ROSETTA generated class declarations for SgFortranDoStorageClass 
    9374             :    used for the ast file IO. Do not chance by hand! 
    9375             : */
    9376           0 : class SgFortranDoStorageClass  : public SgScopeStatementStorageClass
    9377             :    {
    9378             : 
    9379             :     protected: 
    9380             : 
    9381             : 
    9382             : /* #line 9383 "../../../src/frontend/SageIII//StorageClasses.h" */
    9383             : 
    9384             :      unsigned long storageOf_initialization;
    9385             :      unsigned long storageOf_bound;
    9386             :      unsigned long storageOf_increment;
    9387             :      unsigned long storageOf_body;
    9388             :      unsigned long storageOf_end_numeric_label;
    9389             :        EasyStorage < std::string > storageOf_string_label;
    9390             :       bool storageOf_old_style;
    9391             :       bool storageOf_has_end_statement;
    9392             : 
    9393             : 
    9394             : /* #line 10 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarStorageClassDeclatationMacros.macro" */
    9395             : 
    9396             : 
    9397             :     public:
    9398             :       void pickOutIRNodeData ( SgFortranDo* source );
    9399             :       static void arrangeStaticDataOfEasyStorageClassesInOneBlock ( );
    9400             :       static void deleteStaticDataOfEasyStorageClasses ( );
    9401             :       static void pickOutStaticDataMembers ( );
    9402             :       static void rebuildStaticDataMembers ( );
    9403             :       static void writeEasyStorageDataToFile (std::ostream& out);
    9404             :       static void readEasyStorageDataFromFile (std::istream& in);
    9405             :       static void writeStaticDataToFile (std::ostream& out );
    9406             :       static void readStaticDataFromFile (std::istream& in );
    9407             :       friend class SgFortranDo;
    9408             :    };
    9409             : /* #line 9410 "../../../src/frontend/SageIII//StorageClasses.h" */
    9410             : 
    9411             : 
    9412             : 
    9413             : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarStorageClassDeclatationMacros.macro" */
    9414             : /* 
    9415             :    JH (01/01/2006) ROSETTA generated class declarations for SgFortranNonblockedDoStorageClass 
    9416             :    used for the ast file IO. Do not chance by hand! 
    9417             : */
    9418           0 : class SgFortranNonblockedDoStorageClass  : public SgFortranDoStorageClass
    9419             :    {
    9420             : 
    9421             :     protected: 
    9422             : 
    9423             : 
    9424             : /* #line 9425 "../../../src/frontend/SageIII//StorageClasses.h" */
    9425             : 
    9426             :      unsigned long storageOf_end_statement;
    9427             : 
    9428             : 
    9429             : /* #line 10 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarStorageClassDeclatationMacros.macro" */
    9430             : 
    9431             : 
    9432             :     public:
    9433             :       void pickOutIRNodeData ( SgFortranNonblockedDo* source );
    9434             :       static void arrangeStaticDataOfEasyStorageClassesInOneBlock ( );
    9435             :       static void deleteStaticDataOfEasyStorageClasses ( );
    9436             :       static void pickOutStaticDataMembers ( );
    9437             :       static void rebuildStaticDataMembers ( );
    9438             :       static void writeEasyStorageDataToFile (std::ostream& out);
    9439             :       static void readEasyStorageDataFromFile (std::istream& in);
    9440             :       static void writeStaticDataToFile (std::ostream& out );
    9441             :       static void readStaticDataFromFile (std::istream& in );
    9442             :       friend class SgFortranNonblockedDo;
    9443             :    };
    9444             : /* #line 9445 "../../../src/frontend/SageIII//StorageClasses.h" */
    9445             : 
    9446             : 
    9447             : 
    9448             : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarStorageClassDeclatationMacros.macro" */
    9449             : /* 
    9450             :    JH (01/01/2006) ROSETTA generated class declarations for SgForAllStatementStorageClass 
    9451             :    used for the ast file IO. Do not chance by hand! 
    9452             : */
    9453           0 : class SgForAllStatementStorageClass  : public SgScopeStatementStorageClass
    9454             :    {
    9455             : 
    9456             :     protected: 
    9457             : 
    9458             : 
    9459             : /* #line 9460 "../../../src/frontend/SageIII//StorageClasses.h" */
    9460             : 
    9461             :      unsigned long storageOf_forall_header;
    9462             :      unsigned long storageOf_body;
    9463             :       bool storageOf_has_end_statement;
    9464             :        EasyStorage < std::string > storageOf_string_label;
    9465             :      unsigned long storageOf_end_numeric_label;
    9466             :       SgForAllStatement::forall_statement_kind_enum storageOf_forall_statement_kind;
    9467             : 
    9468             : 
    9469             : /* #line 10 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarStorageClassDeclatationMacros.macro" */
    9470             : 
    9471             : 
    9472             :     public:
    9473             :       void pickOutIRNodeData ( SgForAllStatement* source );
    9474             :       static void arrangeStaticDataOfEasyStorageClassesInOneBlock ( );
    9475             :       static void deleteStaticDataOfEasyStorageClasses ( );
    9476             :       static void pickOutStaticDataMembers ( );
    9477             :       static void rebuildStaticDataMembers ( );
    9478             :       static void writeEasyStorageDataToFile (std::ostream& out);
    9479             :       static void readEasyStorageDataFromFile (std::istream& in);
    9480             :       static void writeStaticDataToFile (std::ostream& out );
    9481             :       static void readStaticDataFromFile (std::istream& in );
    9482             :       friend class SgForAllStatement;
    9483             :    };
    9484             : /* #line 9485 "../../../src/frontend/SageIII//StorageClasses.h" */
    9485             : 
    9486             : 
    9487             : 
    9488             : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarStorageClassDeclatationMacros.macro" */
    9489             : /* 
    9490             :    JH (01/01/2006) ROSETTA generated class declarations for SgUpcForAllStatementStorageClass 
    9491             :    used for the ast file IO. Do not chance by hand! 
    9492             : */
    9493           0 : class SgUpcForAllStatementStorageClass  : public SgScopeStatementStorageClass
    9494             :    {
    9495             : 
    9496             :     protected: 
    9497             : 
    9498             : 
    9499             : /* #line 9500 "../../../src/frontend/SageIII//StorageClasses.h" */
    9500             : 
    9501             :      unsigned long storageOf_for_init_stmt;
    9502             :      unsigned long storageOf_test;
    9503             :      unsigned long storageOf_increment;
    9504             :      unsigned long storageOf_affinity;
    9505             :      unsigned long storageOf_loop_body;
    9506             : 
    9507             : 
    9508             : /* #line 10 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarStorageClassDeclatationMacros.macro" */
    9509             : 
    9510             : 
    9511             :     public:
    9512             :       void pickOutIRNodeData ( SgUpcForAllStatement* source );
    9513             :       static void arrangeStaticDataOfEasyStorageClassesInOneBlock ( );
    9514             :       static void deleteStaticDataOfEasyStorageClasses ( );
    9515             :       static void pickOutStaticDataMembers ( );
    9516             :       static void rebuildStaticDataMembers ( );
    9517             :       static void writeEasyStorageDataToFile (std::ostream& out);
    9518             :       static void readEasyStorageDataFromFile (std::istream& in);
    9519             :       static void writeStaticDataToFile (std::ostream& out );
    9520             :       static void readStaticDataFromFile (std::istream& in );
    9521             :       friend class SgUpcForAllStatement;
    9522             :    };
    9523             : /* #line 9524 "../../../src/frontend/SageIII//StorageClasses.h" */
    9524             : 
    9525             : 
    9526             : 
    9527             : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarStorageClassDeclatationMacros.macro" */
    9528             : /* 
    9529             :    JH (01/01/2006) ROSETTA generated class declarations for SgCAFWithTeamStatementStorageClass 
    9530             :    used for the ast file IO. Do not chance by hand! 
    9531             : */
    9532           0 : class SgCAFWithTeamStatementStorageClass  : public SgScopeStatementStorageClass
    9533             :    {
    9534             : 
    9535             :     protected: 
    9536             : 
    9537             : 
    9538             : /* #line 9539 "../../../src/frontend/SageIII//StorageClasses.h" */
    9539             : 
    9540             :      unsigned long storageOf_teamId;
    9541             :      unsigned long storageOf_body;
    9542             :       bool storageOf_endHasTeamId;
    9543             : 
    9544             : 
    9545             : /* #line 10 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarStorageClassDeclatationMacros.macro" */
    9546             : 
    9547             : 
    9548             :     public:
    9549             :       void pickOutIRNodeData ( SgCAFWithTeamStatement* source );
    9550             :       static void arrangeStaticDataOfEasyStorageClassesInOneBlock ( );
    9551             :       static void deleteStaticDataOfEasyStorageClasses ( );
    9552             :       static void pickOutStaticDataMembers ( );
    9553             :       static void rebuildStaticDataMembers ( );
    9554             :       static void writeEasyStorageDataToFile (std::ostream& out);
    9555             :       static void readEasyStorageDataFromFile (std::istream& in);
    9556             :       static void writeStaticDataToFile (std::ostream& out );
    9557             :       static void readStaticDataFromFile (std::istream& in );
    9558             :       friend class SgCAFWithTeamStatement;
    9559             :    };
    9560             : /* #line 9561 "../../../src/frontend/SageIII//StorageClasses.h" */
    9561             : 
    9562             : 
    9563             : 
    9564             : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarStorageClassDeclatationMacros.macro" */
    9565             : /* 
    9566             :    JH (01/01/2006) ROSETTA generated class declarations for SgFunctionParameterScopeStorageClass 
    9567             :    used for the ast file IO. Do not chance by hand! 
    9568             : */
    9569           0 : class SgFunctionParameterScopeStorageClass  : public SgScopeStatementStorageClass
    9570             :    {
    9571             : 
    9572             :     protected: 
    9573             : 
    9574             : 
    9575             : /* #line 9576 "../../../src/frontend/SageIII//StorageClasses.h" */
    9576             : 
    9577             :        EasyStorage < SgDeclarationStatementPtrList > storageOf_declarations;
    9578             : 
    9579             : 
    9580             : /* #line 10 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarStorageClassDeclatationMacros.macro" */
    9581             : 
    9582             : 
    9583             :     public:
    9584             :       void pickOutIRNodeData ( SgFunctionParameterScope* source );
    9585             :       static void arrangeStaticDataOfEasyStorageClassesInOneBlock ( );
    9586             :       static void deleteStaticDataOfEasyStorageClasses ( );
    9587             :       static void pickOutStaticDataMembers ( );
    9588             :       static void rebuildStaticDataMembers ( );
    9589             :       static void writeEasyStorageDataToFile (std::ostream& out);
    9590             :       static void readEasyStorageDataFromFile (std::istream& in);
    9591             :       static void writeStaticDataToFile (std::ostream& out );
    9592             :       static void readStaticDataFromFile (std::istream& in );
    9593             :       friend class SgFunctionParameterScope;
    9594             :    };
    9595             : /* #line 9596 "../../../src/frontend/SageIII//StorageClasses.h" */
    9596             : 
    9597             : 
    9598             : 
    9599             : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarStorageClassDeclatationMacros.macro" */
    9600             : /* 
    9601             :    JH (01/01/2006) ROSETTA generated class declarations for SgDeclarationScopeStorageClass 
    9602             :    used for the ast file IO. Do not chance by hand! 
    9603             : */
    9604       12992 : class SgDeclarationScopeStorageClass  : public SgScopeStatementStorageClass
    9605             :    {
    9606             : 
    9607             :     protected: 
    9608             : 
    9609             : 
    9610             : /* #line 9611 "../../../src/frontend/SageIII//StorageClasses.h" */
    9611             : 
    9612             : 
    9613             : 
    9614             : /* #line 10 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarStorageClassDeclatationMacros.macro" */
    9615             : 
    9616             : 
    9617             :     public:
    9618             :       void pickOutIRNodeData ( SgDeclarationScope* source );
    9619             :       static void arrangeStaticDataOfEasyStorageClassesInOneBlock ( );
    9620             :       static void deleteStaticDataOfEasyStorageClasses ( );
    9621             :       static void pickOutStaticDataMembers ( );
    9622             :       static void rebuildStaticDataMembers ( );
    9623             :       static void writeEasyStorageDataToFile (std::ostream& out);
    9624             :       static void readEasyStorageDataFromFile (std::istream& in);
    9625             :       static void writeStaticDataToFile (std::ostream& out );
    9626             :       static void readStaticDataFromFile (std::istream& in );
    9627             :       friend class SgDeclarationScope;
    9628             :    };
    9629             : /* #line 9630 "../../../src/frontend/SageIII//StorageClasses.h" */
    9630             : 
    9631             : 
    9632             : 
    9633             : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarStorageClassDeclatationMacros.macro" */
    9634             : /* 
    9635             :    JH (01/01/2006) ROSETTA generated class declarations for SgRangeBasedForStatementStorageClass 
    9636             :    used for the ast file IO. Do not chance by hand! 
    9637             : */
    9638           0 : class SgRangeBasedForStatementStorageClass  : public SgScopeStatementStorageClass
    9639             :    {
    9640             : 
    9641             :     protected: 
    9642             : 
    9643             : 
    9644             : /* #line 9645 "../../../src/frontend/SageIII//StorageClasses.h" */
    9645             : 
    9646             :      unsigned long storageOf_iterator_declaration;
    9647             :      unsigned long storageOf_range_declaration;
    9648             :      unsigned long storageOf_begin_declaration;
    9649             :      unsigned long storageOf_end_declaration;
    9650             :      unsigned long storageOf_not_equal_expression;
    9651             :      unsigned long storageOf_increment_expression;
    9652             :      unsigned long storageOf_loop_body;
    9653             : 
    9654             : 
    9655             : /* #line 10 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarStorageClassDeclatationMacros.macro" */
    9656             : 
    9657             : 
    9658             :     public:
    9659             :       void pickOutIRNodeData ( SgRangeBasedForStatement* source );
    9660             :       static void arrangeStaticDataOfEasyStorageClassesInOneBlock ( );
    9661             :       static void deleteStaticDataOfEasyStorageClasses ( );
    9662             :       static void pickOutStaticDataMembers ( );
    9663             :       static void rebuildStaticDataMembers ( );
    9664             :       static void writeEasyStorageDataToFile (std::ostream& out);
    9665             :       static void readEasyStorageDataFromFile (std::istream& in);
    9666             :       static void writeStaticDataToFile (std::ostream& out );
    9667             :       static void readStaticDataFromFile (std::istream& in );
    9668             :       friend class SgRangeBasedForStatement;
    9669             :    };
    9670             : /* #line 9671 "../../../src/frontend/SageIII//StorageClasses.h" */
    9671             : 
    9672             : 
    9673             : 
    9674             : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarStorageClassDeclatationMacros.macro" */
    9675             : /* 
    9676             :    JH (01/01/2006) ROSETTA generated class declarations for SgFunctionTypeTableStorageClass 
    9677             :    used for the ast file IO. Do not chance by hand! 
    9678             : */
    9679           5 : class SgFunctionTypeTableStorageClass  : public SgStatementStorageClass
    9680             :    {
    9681             : 
    9682             :     protected: 
    9683             : 
    9684             : 
    9685             : /* #line 9686 "../../../src/frontend/SageIII//StorageClasses.h" */
    9686             : 
    9687             :      unsigned long storageOf_function_type_table;
    9688             : 
    9689             : 
    9690             : /* #line 10 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarStorageClassDeclatationMacros.macro" */
    9691             : 
    9692             : 
    9693             :     public:
    9694             :       void pickOutIRNodeData ( SgFunctionTypeTable* source );
    9695             :       static void arrangeStaticDataOfEasyStorageClassesInOneBlock ( );
    9696             :       static void deleteStaticDataOfEasyStorageClasses ( );
    9697             :       static void pickOutStaticDataMembers ( );
    9698             :       static void rebuildStaticDataMembers ( );
    9699             :       static void writeEasyStorageDataToFile (std::ostream& out);
    9700             :       static void readEasyStorageDataFromFile (std::istream& in);
    9701             :       static void writeStaticDataToFile (std::ostream& out );
    9702             :       static void readStaticDataFromFile (std::istream& in );
    9703             :       friend class SgFunctionTypeTable;
    9704             :    };
    9705             : /* #line 9706 "../../../src/frontend/SageIII//StorageClasses.h" */
    9706             : 
    9707             : 
    9708             : 
    9709             : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarStorageClassDeclatationMacros.macro" */
    9710             : /* 
    9711             :    JH (01/01/2006) ROSETTA generated class declarations for SgDeclarationStatementStorageClass 
    9712             :    used for the ast file IO. Do not chance by hand! 
    9713             : */
    9714           0 : class SgDeclarationStatementStorageClass  : public SgStatementStorageClass
    9715             :    {
    9716             : 
    9717             :     protected: 
    9718             : 
    9719             : 
    9720             : /* #line 9721 "../../../src/frontend/SageIII//StorageClasses.h" */
    9721             : 
    9722             :       unsigned int storageOf_decl_attributes;
    9723             :        EasyStorage < std::string > storageOf_linkage;
    9724             :       SgDeclarationModifierStorageClass storageOf_declarationModifier;
    9725             :       bool storageOf_nameOnly;
    9726             :       bool storageOf_forward;
    9727             :       bool storageOf_externBrace;
    9728             :       bool storageOf_skipElaborateType;
    9729             :      unsigned long storageOf_definingDeclaration;
    9730             :      unsigned long storageOf_firstNondefiningDeclaration;
    9731             :        EasyStorage < SgQualifiedNamePtrList > storageOf_qualifiedNameList;
    9732             :        EasyStorage < std::string > storageOf_binding_label;
    9733             :      unsigned long storageOf_declarationScope;
    9734             :       bool storageOf_unparse_template_ast;
    9735             : 
    9736             : 
    9737             : /* #line 10 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarStorageClassDeclatationMacros.macro" */
    9738             : 
    9739             : 
    9740             :     public:
    9741             :       void pickOutIRNodeData ( SgDeclarationStatement* source );
    9742             :       static void arrangeStaticDataOfEasyStorageClassesInOneBlock ( );
    9743             :       static void deleteStaticDataOfEasyStorageClasses ( );
    9744             :       static void pickOutStaticDataMembers ( );
    9745             :       static void rebuildStaticDataMembers ( );
    9746             :       static void writeEasyStorageDataToFile (std::ostream& out);
    9747             :       static void readEasyStorageDataFromFile (std::istream& in);
    9748             :       static void writeStaticDataToFile (std::ostream& out );
    9749             :       static void readStaticDataFromFile (std::istream& in );
    9750             :       friend class SgDeclarationStatement;
    9751             :    };
    9752             : /* #line 9753 "../../../src/frontend/SageIII//StorageClasses.h" */
    9753             : 
    9754             : 
    9755             : 
    9756             : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarStorageClassDeclatationMacros.macro" */
    9757             : /* 
    9758             :    JH (01/01/2006) ROSETTA generated class declarations for SgFunctionParameterListStorageClass 
    9759             :    used for the ast file IO. Do not chance by hand! 
    9760             : */
    9761       45535 : class SgFunctionParameterListStorageClass  : public SgDeclarationStatementStorageClass
    9762             :    {
    9763             : 
    9764             :     protected: 
    9765             : 
    9766             : 
    9767             : /* #line 9768 "../../../src/frontend/SageIII//StorageClasses.h" */
    9768             : 
    9769             :        EasyStorage < SgInitializedNamePtrList > storageOf_args;
    9770             : 
    9771             : 
    9772             : /* #line 10 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarStorageClassDeclatationMacros.macro" */
    9773             : 
    9774             : 
    9775             :     public:
    9776             :       void pickOutIRNodeData ( SgFunctionParameterList* source );
    9777             :       static void arrangeStaticDataOfEasyStorageClassesInOneBlock ( );
    9778             :       static void deleteStaticDataOfEasyStorageClasses ( );
    9779             :       static void pickOutStaticDataMembers ( );
    9780             :       static void rebuildStaticDataMembers ( );
    9781             :       static void writeEasyStorageDataToFile (std::ostream& out);
    9782             :       static void readEasyStorageDataFromFile (std::istream& in);
    9783             :       static void writeStaticDataToFile (std::ostream& out );
    9784             :       static void readStaticDataFromFile (std::istream& in );
    9785             :       friend class SgFunctionParameterList;
    9786             :    };
    9787             : /* #line 9788 "../../../src/frontend/SageIII//StorageClasses.h" */
    9788             : 
    9789             : 
    9790             : 
    9791             : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarStorageClassDeclatationMacros.macro" */
    9792             : /* 
    9793             :    JH (01/01/2006) ROSETTA generated class declarations for SgVariableDeclarationStorageClass 
    9794             :    used for the ast file IO. Do not chance by hand! 
    9795             : */
    9796        2588 : class SgVariableDeclarationStorageClass  : public SgDeclarationStatementStorageClass
    9797             :    {
    9798             : 
    9799             :     protected: 
    9800             : 
    9801             : 
    9802             : /* #line 9803 "../../../src/frontend/SageIII//StorageClasses.h" */
    9803             : 
    9804             :      unsigned long storageOf_baseTypeDefiningDeclaration;
    9805             :        EasyStorage < SgInitializedNamePtrList > storageOf_variables;
    9806             :       bool storageOf_variableDeclarationContainsBaseTypeDefiningDeclaration;
    9807             :       SgDeclarationStatement::template_specialization_enum storageOf_specialization;
    9808             :       bool storageOf_requiresGlobalNameQualificationOnType;
    9809             :        EasyStorage < std::string > storageOf_gnu_extension_section;
    9810             :        EasyStorage < std::string > storageOf_gnu_extension_alias;
    9811             :       unsigned short storageOf_gnu_extension_initialization_priority;
    9812             :       SgDeclarationStatement::gnu_extension_visability_attribute_enum storageOf_gnu_extension_visability;
    9813             :       SgVariableDeclaration::gnu_extension_declaration_attributes_enum storageOf_gnu_extension_declaration_attribute;
    9814             :       int storageOf_name_qualification_length;
    9815             :       bool storageOf_type_elaboration_required;
    9816             :       bool storageOf_global_qualification_required;
    9817             :       bool storageOf_isAssociatedWithDeclarationList;
    9818             :       bool storageOf_isFirstDeclarationOfDeclarationList;
    9819             :       bool storageOf_is_thread_local;
    9820             :       bool storageOf_is_constexpr;
    9821             :       bool storageOf_builtFromUseOnly;
    9822             : 
    9823             : 
    9824             : /* #line 10 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarStorageClassDeclatationMacros.macro" */
    9825             : 
    9826             : 
    9827             :     public:
    9828             :       void pickOutIRNodeData ( SgVariableDeclaration* source );
    9829             :       static void arrangeStaticDataOfEasyStorageClassesInOneBlock ( );
    9830             :       static void deleteStaticDataOfEasyStorageClasses ( );
    9831             :       static void pickOutStaticDataMembers ( );
    9832             :       static void rebuildStaticDataMembers ( );
    9833             :       static void writeEasyStorageDataToFile (std::ostream& out);
    9834             :       static void readEasyStorageDataFromFile (std::istream& in);
    9835             :       static void writeStaticDataToFile (std::ostream& out );
    9836             :       static void readStaticDataFromFile (std::istream& in );
    9837             :       friend class SgVariableDeclaration;
    9838             :    };
    9839             : /* #line 9840 "../../../src/frontend/SageIII//StorageClasses.h" */
    9840             : 
    9841             : 
    9842             : 
    9843             : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarStorageClassDeclatationMacros.macro" */
    9844             : /* 
    9845             :    JH (01/01/2006) ROSETTA generated class declarations for SgTemplateVariableDeclarationStorageClass 
    9846             :    used for the ast file IO. Do not chance by hand! 
    9847             : */
    9848             : class SgTemplateVariableDeclarationStorageClass  : public SgVariableDeclarationStorageClass
    9849             :    {
    9850             : 
    9851             :     protected: 
    9852             : 
    9853             : 
    9854             : /* #line 9855 "../../../src/frontend/SageIII//StorageClasses.h" */
    9855             : 
    9856             :        EasyStorage < SgTemplateParameterPtrList > storageOf_templateParameters;
    9857             :        EasyStorage < SgTemplateArgumentPtrList > storageOf_templateSpecializationArguments;
    9858             :       SgNameStorageClass storageOf_string;
    9859             :      unsigned long storageOf_nonreal_decl_scope;
    9860             : 
    9861             : 
    9862             : /* #line 10 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarStorageClassDeclatationMacros.macro" */
    9863             : 
    9864             : 
    9865             :     public:
    9866             :       void pickOutIRNodeData ( SgTemplateVariableDeclaration* source );
    9867             :       static void arrangeStaticDataOfEasyStorageClassesInOneBlock ( );
    9868             :       static void deleteStaticDataOfEasyStorageClasses ( );
    9869             :       static void pickOutStaticDataMembers ( );
    9870             :       static void rebuildStaticDataMembers ( );
    9871             :       static void writeEasyStorageDataToFile (std::ostream& out);
    9872             :       static void readEasyStorageDataFromFile (std::istream& in);
    9873             :       static void writeStaticDataToFile (std::ostream& out );
    9874             :       static void readStaticDataFromFile (std::istream& in );
    9875             :       friend class SgTemplateVariableDeclaration;
    9876             :    };
    9877             : /* #line 9878 "../../../src/frontend/SageIII//StorageClasses.h" */
    9878             : 
    9879             : 
    9880             : 
    9881             : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarStorageClassDeclatationMacros.macro" */
    9882             : /* 
    9883             :    JH (01/01/2006) ROSETTA generated class declarations for SgVariableDefinitionStorageClass 
    9884             :    used for the ast file IO. Do not chance by hand! 
    9885             : */
    9886        2792 : class SgVariableDefinitionStorageClass  : public SgDeclarationStatementStorageClass
    9887             :    {
    9888             : 
    9889             :     protected: 
    9890             : 
    9891             : 
    9892             : /* #line 9893 "../../../src/frontend/SageIII//StorageClasses.h" */
    9893             : 
    9894             :      unsigned long storageOf_vardefn;
    9895             :      unsigned long storageOf_bitfield;
    9896             : 
    9897             : 
    9898             : /* #line 10 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarStorageClassDeclatationMacros.macro" */
    9899             : 
    9900             : 
    9901             :     public:
    9902             :       void pickOutIRNodeData ( SgVariableDefinition* source );
    9903             :       static void arrangeStaticDataOfEasyStorageClassesInOneBlock ( );
    9904             :       static void deleteStaticDataOfEasyStorageClasses ( );
    9905             :       static void pickOutStaticDataMembers ( );
    9906             :       static void rebuildStaticDataMembers ( );
    9907             :       static void writeEasyStorageDataToFile (std::ostream& out);
    9908             :       static void readEasyStorageDataFromFile (std::istream& in);
    9909             :       static void writeStaticDataToFile (std::ostream& out );
    9910             :       static void readStaticDataFromFile (std::istream& in );
    9911             :       friend class SgVariableDefinition;
    9912             :    };
    9913             : /* #line 9914 "../../../src/frontend/SageIII//StorageClasses.h" */
    9914             : 
    9915             : 
    9916             : 
    9917             : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarStorageClassDeclatationMacros.macro" */
    9918             : /* 
    9919             :    JH (01/01/2006) ROSETTA generated class declarations for SgClinkageDeclarationStatementStorageClass 
    9920             :    used for the ast file IO. Do not chance by hand! 
    9921             : */
    9922           0 : class SgClinkageDeclarationStatementStorageClass  : public SgDeclarationStatementStorageClass
    9923             :    {
    9924             : 
    9925             :     protected: 
    9926             : 
    9927             : 
    9928             : /* #line 9929 "../../../src/frontend/SageIII//StorageClasses.h" */
    9929             : 
    9930             :        EasyStorage < std::string > storageOf_languageSpecifier;
    9931             : 
    9932             : 
    9933             : /* #line 10 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarStorageClassDeclatationMacros.macro" */
    9934             : 
    9935             : 
    9936             :     public:
    9937             :       void pickOutIRNodeData ( SgClinkageDeclarationStatement* source );
    9938             :       static void arrangeStaticDataOfEasyStorageClassesInOneBlock ( );
    9939             :       static void deleteStaticDataOfEasyStorageClasses ( );
    9940             :       static void pickOutStaticDataMembers ( );
    9941             :       static void rebuildStaticDataMembers ( );
    9942             :       static void writeEasyStorageDataToFile (std::ostream& out);
    9943             :       static void readEasyStorageDataFromFile (std::istream& in);
    9944             :       static void writeStaticDataToFile (std::ostream& out );
    9945             :       static void readStaticDataFromFile (std::istream& in );
    9946             :       friend class SgClinkageDeclarationStatement;
    9947             :    };
    9948             : /* #line 9949 "../../../src/frontend/SageIII//StorageClasses.h" */
    9949             : 
    9950             : 
    9951             : 
    9952             : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarStorageClassDeclatationMacros.macro" */
    9953             : /* 
    9954             :    JH (01/01/2006) ROSETTA generated class declarations for SgClinkageStartStatementStorageClass 
    9955             :    used for the ast file IO. Do not chance by hand! 
    9956             : */
    9957           0 : class SgClinkageStartStatementStorageClass  : public SgClinkageDeclarationStatementStorageClass
    9958             :    {
    9959             : 
    9960             :     protected: 
    9961             : 
    9962             : 
    9963             : /* #line 9964 "../../../src/frontend/SageIII//StorageClasses.h" */
    9964             : 
    9965             : 
    9966             : 
    9967             : /* #line 10 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarStorageClassDeclatationMacros.macro" */
    9968             : 
    9969             : 
    9970             :     public:
    9971             :       void pickOutIRNodeData ( SgClinkageStartStatement* source );
    9972             :       static void arrangeStaticDataOfEasyStorageClassesInOneBlock ( );
    9973             :       static void deleteStaticDataOfEasyStorageClasses ( );
    9974             :       static void pickOutStaticDataMembers ( );
    9975             :       static void rebuildStaticDataMembers ( );
    9976             :       static void writeEasyStorageDataToFile (std::ostream& out);
    9977             :       static void readEasyStorageDataFromFile (std::istream& in);
    9978             :       static void writeStaticDataToFile (std::ostream& out );
    9979             :       static void readStaticDataFromFile (std::istream& in );
    9980             :       friend class SgClinkageStartStatement;
    9981             :    };
    9982             : /* #line 9983 "../../../src/frontend/SageIII//StorageClasses.h" */
    9983             : 
    9984             : 
    9985             : 
    9986             : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarStorageClassDeclatationMacros.macro" */
    9987             : /* 
    9988             :    JH (01/01/2006) ROSETTA generated class declarations for SgClinkageEndStatementStorageClass 
    9989             :    used for the ast file IO. Do not chance by hand! 
    9990             : */
    9991           0 : class SgClinkageEndStatementStorageClass  : public SgClinkageDeclarationStatementStorageClass
    9992             :    {
    9993             : 
    9994             :     protected: 
    9995             : 
    9996             : 
    9997             : /* #line 9998 "../../../src/frontend/SageIII//StorageClasses.h" */
    9998             : 
    9999             : 
   10000             : 
   10001             : /* #line 10 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarStorageClassDeclatationMacros.macro" */
   10002             : 
   10003             : 
   10004             :     public:
   10005             :       void pickOutIRNodeData ( SgClinkageEndStatement* source );
   10006             :       static void arrangeStaticDataOfEasyStorageClassesInOneBlock ( );
   10007             :       static void deleteStaticDataOfEasyStorageClasses ( );
   10008             :       static void pickOutStaticDataMembers ( );
   10009             :       static void rebuildStaticDataMembers ( );
   10010             :       static void writeEasyStorageDataToFile (std::ostream& out);
   10011             :       static void readEasyStorageDataFromFile (std::istream& in);
   10012             :       static void writeStaticDataToFile (std::ostream& out );
   10013             :       static void readStaticDataFromFile (std::istream& in );
   10014             :       friend class SgClinkageEndStatement;
   10015             :    };
   10016             : /* #line 10017 "../../../src/frontend/SageIII//StorageClasses.h" */
   10017             : 
   10018             : 
   10019             : 
   10020             : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarStorageClassDeclatationMacros.macro" */
   10021             : /* 
   10022             :    JH (01/01/2006) ROSETTA generated class declarations for SgEnumDeclarationStorageClass 
   10023             :    used for the ast file IO. Do not chance by hand! 
   10024             : */
   10025         352 : class SgEnumDeclarationStorageClass  : public SgDeclarationStatementStorageClass
   10026             :    {
   10027             : 
   10028             :     protected: 
   10029             : 
   10030             : 
   10031             : /* #line 10032 "../../../src/frontend/SageIII//StorageClasses.h" */
   10032             : 
   10033             :       SgNameStorageClass storageOf_name;
   10034             :       bool storageOf_embedded;
   10035             :      unsigned long storageOf_type;
   10036             :      unsigned long storageOf_adaParentType;
   10037             :        EasyStorage < SgInitializedNamePtrList > storageOf_enumerators;
   10038             :      unsigned long storageOf_scope;
   10039             :       bool storageOf_isUnNamed;
   10040             :       bool storageOf_isAutonomousDeclaration;
   10041             :      unsigned long storageOf_field_type;
   10042             :       bool storageOf_isScopedEnum;
   10043             :       int storageOf_name_qualification_length;
   10044             :       bool storageOf_type_elaboration_required;
   10045             :       bool storageOf_global_qualification_required;
   10046             : 
   10047             : 
   10048             : /* #line 10 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarStorageClassDeclatationMacros.macro" */
   10049             : 
   10050             : 
   10051             :     public:
   10052             :       void pickOutIRNodeData ( SgEnumDeclaration* source );
   10053             :       static void arrangeStaticDataOfEasyStorageClassesInOneBlock ( );
   10054             :       static void deleteStaticDataOfEasyStorageClasses ( );
   10055             :       static void pickOutStaticDataMembers ( );
   10056             :       static void rebuildStaticDataMembers ( );
   10057             :       static void writeEasyStorageDataToFile (std::ostream& out);
   10058             :       static void readEasyStorageDataFromFile (std::istream& in);
   10059             :       static void writeStaticDataToFile (std::ostream& out );
   10060             :       static void readStaticDataFromFile (std::istream& in );
   10061             :       friend class SgEnumDeclaration;
   10062             :    };
   10063             : /* #line 10064 "../../../src/frontend/SageIII//StorageClasses.h" */
   10064             : 
   10065             : 
   10066             : 
   10067             : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarStorageClassDeclatationMacros.macro" */
   10068             : /* 
   10069             :    JH (01/01/2006) ROSETTA generated class declarations for SgAsmStmtStorageClass 
   10070             :    used for the ast file IO. Do not chance by hand! 
   10071             : */
   10072           0 : class SgAsmStmtStorageClass  : public SgDeclarationStatementStorageClass
   10073             :    {
   10074             : 
   10075             :     protected: 
   10076             : 
   10077             : 
   10078             : /* #line 10079 "../../../src/frontend/SageIII//StorageClasses.h" */
   10079             : 
   10080             :        EasyStorage < std::string > storageOf_assemblyCode;
   10081             :       bool storageOf_useGnuExtendedFormat;
   10082             :        EasyStorage < SgExpressionPtrList > storageOf_operands;
   10083             :        EasyStorage < SgAsmStmt::AsmRegisterNameList > storageOf_clobberRegisterList;
   10084             :       bool storageOf_isVolatile;
   10085             : 
   10086             : 
   10087             : /* #line 10 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarStorageClassDeclatationMacros.macro" */
   10088             : 
   10089             : 
   10090             :     public:
   10091             :       void pickOutIRNodeData ( SgAsmStmt* source );
   10092             :       static void arrangeStaticDataOfEasyStorageClassesInOneBlock ( );
   10093             :       static void deleteStaticDataOfEasyStorageClasses ( );
   10094             :       static void pickOutStaticDataMembers ( );
   10095             :       static void rebuildStaticDataMembers ( );
   10096             :       static void writeEasyStorageDataToFile (std::ostream& out);
   10097             :       static void readEasyStorageDataFromFile (std::istream& in);
   10098             :       static void writeStaticDataToFile (std::ostream& out );
   10099             :       static void readStaticDataFromFile (std::istream& in );
   10100             :       friend class SgAsmStmt;
   10101             :    };
   10102             : /* #line 10103 "../../../src/frontend/SageIII//StorageClasses.h" */
   10103             : 
   10104             : 
   10105             : 
   10106             : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarStorageClassDeclatationMacros.macro" */
   10107             : /* 
   10108             :    JH (01/01/2006) ROSETTA generated class declarations for SgAttributeSpecificationStatementStorageClass 
   10109             :    used for the ast file IO. Do not chance by hand! 
   10110             : */
   10111           0 : class SgAttributeSpecificationStatementStorageClass  : public SgDeclarationStatementStorageClass
   10112             :    {
   10113             : 
   10114             :     protected: 
   10115             : 
   10116             : 
   10117             : /* #line 10118 "../../../src/frontend/SageIII//StorageClasses.h" */
   10118             : 
   10119             :        EasyStorage < SgStringList > storageOf_name_list;
   10120             :       SgAttributeSpecificationStatement::attribute_spec_enum storageOf_attribute_kind;
   10121             :       int storageOf_intent;
   10122             :      unsigned long storageOf_parameter_list;
   10123             :        EasyStorage < SgDataStatementGroupPtrList > storageOf_data_statement_group_list;
   10124             :      unsigned long storageOf_bind_list;
   10125             :        EasyStorage < SgDimensionObjectPtrList > storageOf_dimension_object_list;
   10126             : 
   10127             : 
   10128             : /* #line 10 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarStorageClassDeclatationMacros.macro" */
   10129             : 
   10130             : 
   10131             :     public:
   10132             :       void pickOutIRNodeData ( SgAttributeSpecificationStatement* source );
   10133             :       static void arrangeStaticDataOfEasyStorageClassesInOneBlock ( );
   10134             :       static void deleteStaticDataOfEasyStorageClasses ( );
   10135             :       static void pickOutStaticDataMembers ( );
   10136             :       static void rebuildStaticDataMembers ( );
   10137             :       static void writeEasyStorageDataToFile (std::ostream& out);
   10138             :       static void readEasyStorageDataFromFile (std::istream& in);
   10139             :       static void writeStaticDataToFile (std::ostream& out );
   10140             :       static void readStaticDataFromFile (std::istream& in );
   10141             :       friend class SgAttributeSpecificationStatement;
   10142             :    };
   10143             : /* #line 10144 "../../../src/frontend/SageIII//StorageClasses.h" */
   10144             : 
   10145             : 
   10146             : 
   10147             : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarStorageClassDeclatationMacros.macro" */
   10148             : /* 
   10149             :    JH (01/01/2006) ROSETTA generated class declarations for SgFormatStatementStorageClass 
   10150             :    used for the ast file IO. Do not chance by hand! 
   10151             : */
   10152           0 : class SgFormatStatementStorageClass  : public SgDeclarationStatementStorageClass
   10153             :    {
   10154             : 
   10155             :     protected: 
   10156             : 
   10157             : 
   10158             : /* #line 10159 "../../../src/frontend/SageIII//StorageClasses.h" */
   10159             : 
   10160             :      unsigned long storageOf_format_item_list;
   10161             : 
   10162             : 
   10163             : /* #line 10 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarStorageClassDeclatationMacros.macro" */
   10164             : 
   10165             : 
   10166             :     public:
   10167             :       void pickOutIRNodeData ( SgFormatStatement* source );
   10168             :       static void arrangeStaticDataOfEasyStorageClassesInOneBlock ( );
   10169             :       static void deleteStaticDataOfEasyStorageClasses ( );
   10170             :       static void pickOutStaticDataMembers ( );
   10171             :       static void rebuildStaticDataMembers ( );
   10172             :       static void writeEasyStorageDataToFile (std::ostream& out);
   10173             :       static void readEasyStorageDataFromFile (std::istream& in);
   10174             :       static void writeStaticDataToFile (std::ostream& out );
   10175             :       static void readStaticDataFromFile (std::istream& in );
   10176             :       friend class SgFormatStatement;
   10177             :    };
   10178             : /* #line 10179 "../../../src/frontend/SageIII//StorageClasses.h" */
   10179             : 
   10180             : 
   10181             : 
   10182             : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarStorageClassDeclatationMacros.macro" */
   10183             : /* 
   10184             :    JH (01/01/2006) ROSETTA generated class declarations for SgTemplateDeclarationStorageClass 
   10185             :    used for the ast file IO. Do not chance by hand! 
   10186             : */
   10187           0 : class SgTemplateDeclarationStorageClass  : public SgDeclarationStatementStorageClass
   10188             :    {
   10189             : 
   10190             :     protected: 
   10191             : 
   10192             : 
   10193             : /* #line 10194 "../../../src/frontend/SageIII//StorageClasses.h" */
   10194             : 
   10195             :       SgNameStorageClass storageOf_name;
   10196             :       SgNameStorageClass storageOf_string;
   10197             :       SgTemplateDeclaration::template_type_enum storageOf_template_kind;
   10198             :        EasyStorage < SgTemplateParameterPtrList > storageOf_templateParameters;
   10199             :      unsigned long storageOf_scope;
   10200             :      unsigned long storageOf_nonreal_decl_scope;
   10201             : 
   10202             : 
   10203             : /* #line 10 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarStorageClassDeclatationMacros.macro" */
   10204             : 
   10205             : 
   10206             :     public:
   10207             :       void pickOutIRNodeData ( SgTemplateDeclaration* source );
   10208             :       static void arrangeStaticDataOfEasyStorageClassesInOneBlock ( );
   10209             :       static void deleteStaticDataOfEasyStorageClasses ( );
   10210             :       static void pickOutStaticDataMembers ( );
   10211             :       static void rebuildStaticDataMembers ( );
   10212             :       static void writeEasyStorageDataToFile (std::ostream& out);
   10213             :       static void readEasyStorageDataFromFile (std::istream& in);
   10214             :       static void writeStaticDataToFile (std::ostream& out );
   10215             :       static void readStaticDataFromFile (std::istream& in );
   10216             :       friend class SgTemplateDeclaration;
   10217             :    };
   10218             : /* #line 10219 "../../../src/frontend/SageIII//StorageClasses.h" */
   10219             : 
   10220             : 
   10221             : 
   10222             : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarStorageClassDeclatationMacros.macro" */
   10223             : /* 
   10224             :    JH (01/01/2006) ROSETTA generated class declarations for SgTemplateInstantiationDirectiveStatementStorageClass 
   10225             :    used for the ast file IO. Do not chance by hand! 
   10226             : */
   10227         248 : class SgTemplateInstantiationDirectiveStatementStorageClass  : public SgDeclarationStatementStorageClass
   10228             :    {
   10229             : 
   10230             :     protected: 
   10231             : 
   10232             : 
   10233             : /* #line 10234 "../../../src/frontend/SageIII//StorageClasses.h" */
   10234             : 
   10235             :      unsigned long storageOf_declaration;
   10236             :       bool storageOf_do_not_instantiate;
   10237             : 
   10238             : 
   10239             : /* #line 10 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarStorageClassDeclatationMacros.macro" */
   10240             : 
   10241             : 
   10242             :     public:
   10243             :       void pickOutIRNodeData ( SgTemplateInstantiationDirectiveStatement* source );
   10244             :       static void arrangeStaticDataOfEasyStorageClassesInOneBlock ( );
   10245             :       static void deleteStaticDataOfEasyStorageClasses ( );
   10246             :       static void pickOutStaticDataMembers ( );
   10247             :       static void rebuildStaticDataMembers ( );
   10248             :       static void writeEasyStorageDataToFile (std::ostream& out);
   10249             :       static void readEasyStorageDataFromFile (std::istream& in);
   10250             :       static void writeStaticDataToFile (std::ostream& out );
   10251             :       static void readStaticDataFromFile (std::istream& in );
   10252             :       friend class SgTemplateInstantiationDirectiveStatement;
   10253             :    };
   10254             : /* #line 10255 "../../../src/frontend/SageIII//StorageClasses.h" */
   10255             : 
   10256             : 
   10257             : 
   10258             : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarStorageClassDeclatationMacros.macro" */
   10259             : /* 
   10260             :    JH (01/01/2006) ROSETTA generated class declarations for SgUseStatementStorageClass 
   10261             :    used for the ast file IO. Do not chance by hand! 
   10262             : */
   10263           0 : class SgUseStatementStorageClass  : public SgDeclarationStatementStorageClass
   10264             :    {
   10265             : 
   10266             :     protected: 
   10267             : 
   10268             : 
   10269             : /* #line 10270 "../../../src/frontend/SageIII//StorageClasses.h" */
   10270             : 
   10271             :       SgNameStorageClass storageOf_name;
   10272             :       bool storageOf_only_option;
   10273             :        EasyStorage < std::string > storageOf_module_nature;
   10274             :        EasyStorage < SgRenamePairPtrList > storageOf_rename_list;
   10275             :      unsigned long storageOf_module;
   10276             : 
   10277             : 
   10278             : /* #line 10 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarStorageClassDeclatationMacros.macro" */
   10279             : 
   10280             : 
   10281             :     public:
   10282             :       void pickOutIRNodeData ( SgUseStatement* source );
   10283             :       static void arrangeStaticDataOfEasyStorageClassesInOneBlock ( );
   10284             :       static void deleteStaticDataOfEasyStorageClasses ( );
   10285             :       static void pickOutStaticDataMembers ( );
   10286             :       static void rebuildStaticDataMembers ( );
   10287             :       static void writeEasyStorageDataToFile (std::ostream& out);
   10288             :       static void readEasyStorageDataFromFile (std::istream& in);
   10289             :       static void writeStaticDataToFile (std::ostream& out );
   10290             :       static void readStaticDataFromFile (std::istream& in );
   10291             :       friend class SgUseStatement;
   10292             :    };
   10293             : /* #line 10294 "../../../src/frontend/SageIII//StorageClasses.h" */
   10294             : 
   10295             : 
   10296             : 
   10297             : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarStorageClassDeclatationMacros.macro" */
   10298             : /* 
   10299             :    JH (01/01/2006) ROSETTA generated class declarations for SgParameterStatementStorageClass 
   10300             :    used for the ast file IO. Do not chance by hand! 
   10301             : */
   10302           0 : class SgParameterStatementStorageClass  : public SgDeclarationStatementStorageClass
   10303             :    {
   10304             : 
   10305             :     protected: 
   10306             : 
   10307             : 
   10308             : /* #line 10309 "../../../src/frontend/SageIII//StorageClasses.h" */
   10309             : 
   10310             : 
   10311             : 
   10312             : /* #line 10 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarStorageClassDeclatationMacros.macro" */
   10313             : 
   10314             : 
   10315             :     public:
   10316             :       void pickOutIRNodeData ( SgParameterStatement* source );
   10317             :       static void arrangeStaticDataOfEasyStorageClassesInOneBlock ( );
   10318             :       static void deleteStaticDataOfEasyStorageClasses ( );
   10319             :       static void pickOutStaticDataMembers ( );
   10320             :       static void rebuildStaticDataMembers ( );
   10321             :       static void writeEasyStorageDataToFile (std::ostream& out);
   10322             :       static void readEasyStorageDataFromFile (std::istream& in);
   10323             :       static void writeStaticDataToFile (std::ostream& out );
   10324             :       static void readStaticDataFromFile (std::istream& in );
   10325             :       friend class SgParameterStatement;
   10326             :    };
   10327             : /* #line 10328 "../../../src/frontend/SageIII//StorageClasses.h" */
   10328             : 
   10329             : 
   10330             : 
   10331             : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarStorageClassDeclatationMacros.macro" */
   10332             : /* 
   10333             :    JH (01/01/2006) ROSETTA generated class declarations for SgNamespaceDeclarationStatementStorageClass 
   10334             :    used for the ast file IO. Do not chance by hand! 
   10335             : */
   10336         242 : class SgNamespaceDeclarationStatementStorageClass  : public SgDeclarationStatementStorageClass
   10337             :    {
   10338             : 
   10339             :     protected: 
   10340             : 
   10341             : 
   10342             : /* #line 10343 "../../../src/frontend/SageIII//StorageClasses.h" */
   10343             : 
   10344             :       SgNameStorageClass storageOf_name;
   10345             :      unsigned long storageOf_definition;
   10346             :       bool storageOf_isUnnamedNamespace;
   10347             :       bool storageOf_isInlinedNamespace;
   10348             : 
   10349             : 
   10350             : /* #line 10 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarStorageClassDeclatationMacros.macro" */
   10351             : 
   10352             : 
   10353             :     public:
   10354             :       void pickOutIRNodeData ( SgNamespaceDeclarationStatement* source );
   10355             :       static void arrangeStaticDataOfEasyStorageClassesInOneBlock ( );
   10356             :       static void deleteStaticDataOfEasyStorageClasses ( );
   10357             :       static void pickOutStaticDataMembers ( );
   10358             :       static void rebuildStaticDataMembers ( );
   10359             :       static void writeEasyStorageDataToFile (std::ostream& out);
   10360             :       static void readEasyStorageDataFromFile (std::istream& in);
   10361             :       static void writeStaticDataToFile (std::ostream& out );
   10362             :       static void readStaticDataFromFile (std::istream& in );
   10363             :       friend class SgNamespaceDeclarationStatement;
   10364             :    };
   10365             : /* #line 10366 "../../../src/frontend/SageIII//StorageClasses.h" */
   10366             : 
   10367             : 
   10368             : 
   10369             : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarStorageClassDeclatationMacros.macro" */
   10370             : /* 
   10371             :    JH (01/01/2006) ROSETTA generated class declarations for SgEquivalenceStatementStorageClass 
   10372             :    used for the ast file IO. Do not chance by hand! 
   10373             : */
   10374           0 : class SgEquivalenceStatementStorageClass  : public SgDeclarationStatementStorageClass
   10375             :    {
   10376             : 
   10377             :     protected: 
   10378             : 
   10379             : 
   10380             : /* #line 10381 "../../../src/frontend/SageIII//StorageClasses.h" */
   10381             : 
   10382             :      unsigned long storageOf_equivalence_set_list;
   10383             : 
   10384             : 
   10385             : /* #line 10 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarStorageClassDeclatationMacros.macro" */
   10386             : 
   10387             : 
   10388             :     public:
   10389             :       void pickOutIRNodeData ( SgEquivalenceStatement* source );
   10390             :       static void arrangeStaticDataOfEasyStorageClassesInOneBlock ( );
   10391             :       static void deleteStaticDataOfEasyStorageClasses ( );
   10392             :       static void pickOutStaticDataMembers ( );
   10393             :       static void rebuildStaticDataMembers ( );
   10394             :       static void writeEasyStorageDataToFile (std::ostream& out);
   10395             :       static void readEasyStorageDataFromFile (std::istream& in);
   10396             :       static void writeStaticDataToFile (std::ostream& out );
   10397             :       static void readStaticDataFromFile (std::istream& in );
   10398             :       friend class SgEquivalenceStatement;
   10399             :    };
   10400             : /* #line 10401 "../../../src/frontend/SageIII//StorageClasses.h" */
   10401             : 
   10402             : 
   10403             : 
   10404             : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarStorageClassDeclatationMacros.macro" */
   10405             : /* 
   10406             :    JH (01/01/2006) ROSETTA generated class declarations for SgInterfaceStatementStorageClass 
   10407             :    used for the ast file IO. Do not chance by hand! 
   10408             : */
   10409           0 : class SgInterfaceStatementStorageClass  : public SgDeclarationStatementStorageClass
   10410             :    {
   10411             : 
   10412             :     protected: 
   10413             : 
   10414             : 
   10415             : /* #line 10416 "../../../src/frontend/SageIII//StorageClasses.h" */
   10416             : 
   10417             :       SgNameStorageClass storageOf_name;
   10418             :       SgInterfaceStatement::generic_spec_enum storageOf_generic_spec;
   10419             :        EasyStorage < SgInterfaceBodyPtrList > storageOf_interface_body_list;
   10420             :      unsigned long storageOf_end_numeric_label;
   10421             : 
   10422             : 
   10423             : /* #line 10 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarStorageClassDeclatationMacros.macro" */
   10424             : 
   10425             : 
   10426             :     public:
   10427             :       void pickOutIRNodeData ( SgInterfaceStatement* source );
   10428             :       static void arrangeStaticDataOfEasyStorageClassesInOneBlock ( );
   10429             :       static void deleteStaticDataOfEasyStorageClasses ( );
   10430             :       static void pickOutStaticDataMembers ( );
   10431             :       static void rebuildStaticDataMembers ( );
   10432             :       static void writeEasyStorageDataToFile (std::ostream& out);
   10433             :       static void readEasyStorageDataFromFile (std::istream& in);
   10434             :       static void writeStaticDataToFile (std::ostream& out );
   10435             :       static void readStaticDataFromFile (std::istream& in );
   10436             :       friend class SgInterfaceStatement;
   10437             :    };
   10438             : /* #line 10439 "../../../src/frontend/SageIII//StorageClasses.h" */
   10439             : 
   10440             : 
   10441             : 
   10442             : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarStorageClassDeclatationMacros.macro" */
   10443             : /* 
   10444             :    JH (01/01/2006) ROSETTA generated class declarations for SgNamespaceAliasDeclarationStatementStorageClass 
   10445             :    used for the ast file IO. Do not chance by hand! 
   10446             : */
   10447           0 : class SgNamespaceAliasDeclarationStatementStorageClass  : public SgDeclarationStatementStorageClass
   10448             :    {
   10449             : 
   10450             :     protected: 
   10451             : 
   10452             : 
   10453             : /* #line 10454 "../../../src/frontend/SageIII//StorageClasses.h" */
   10454             : 
   10455             :       SgNameStorageClass storageOf_name;
   10456             :      unsigned long storageOf_namespaceDeclaration;
   10457             :       int storageOf_name_qualification_length;
   10458             :       bool storageOf_type_elaboration_required;
   10459             :       bool storageOf_global_qualification_required;
   10460             :       bool storageOf_is_alias_for_another_namespace_alias;
   10461             :      unsigned long storageOf_namespaceAliasDeclaration;
   10462             : 
   10463             : 
   10464             : /* #line 10 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarStorageClassDeclatationMacros.macro" */
   10465             : 
   10466             : 
   10467             :     public:
   10468             :       void pickOutIRNodeData ( SgNamespaceAliasDeclarationStatement* source );
   10469             :       static void arrangeStaticDataOfEasyStorageClassesInOneBlock ( );
   10470             :       static void deleteStaticDataOfEasyStorageClasses ( );
   10471             :       static void pickOutStaticDataMembers ( );
   10472             :       static void rebuildStaticDataMembers ( );
   10473             :       static void writeEasyStorageDataToFile (std::ostream& out);
   10474             :       static void readEasyStorageDataFromFile (std::istream& in);
   10475             :       static void writeStaticDataToFile (std::ostream& out );
   10476             :       static void readStaticDataFromFile (std::istream& in );
   10477             :       friend class SgNamespaceAliasDeclarationStatement;
   10478             :    };
   10479             : /* #line 10480 "../../../src/frontend/SageIII//StorageClasses.h" */
   10480             : 
   10481             : 
   10482             : 
   10483             : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarStorageClassDeclatationMacros.macro" */
   10484             : /* 
   10485             :    JH (01/01/2006) ROSETTA generated class declarations for SgCommonBlockStorageClass 
   10486             :    used for the ast file IO. Do not chance by hand! 
   10487             : */
   10488           0 : class SgCommonBlockStorageClass  : public SgDeclarationStatementStorageClass
   10489             :    {
   10490             : 
   10491             :     protected: 
   10492             : 
   10493             : 
   10494             : /* #line 10495 "../../../src/frontend/SageIII//StorageClasses.h" */
   10495             : 
   10496             :        EasyStorage < SgCommonBlockObjectPtrList > storageOf_block_list;
   10497             : 
   10498             : 
   10499             : /* #line 10 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarStorageClassDeclatationMacros.macro" */
   10500             : 
   10501             : 
   10502             :     public:
   10503             :       void pickOutIRNodeData ( SgCommonBlock* source );
   10504             :       static void arrangeStaticDataOfEasyStorageClassesInOneBlock ( );
   10505             :       static void deleteStaticDataOfEasyStorageClasses ( );
   10506             :       static void pickOutStaticDataMembers ( );
   10507             :       static void rebuildStaticDataMembers ( );
   10508             :       static void writeEasyStorageDataToFile (std::ostream& out);
   10509             :       static void readEasyStorageDataFromFile (std::istream& in);
   10510             :       static void writeStaticDataToFile (std::ostream& out );
   10511             :       static void readStaticDataFromFile (std::istream& in );
   10512             :       friend class SgCommonBlock;
   10513             :    };
   10514             : /* #line 10515 "../../../src/frontend/SageIII//StorageClasses.h" */
   10515             : 
   10516             : 
   10517             : 
   10518             : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarStorageClassDeclatationMacros.macro" */
   10519             : /* 
   10520             :    JH (01/01/2006) ROSETTA generated class declarations for SgTypedefDeclarationStorageClass 
   10521             :    used for the ast file IO. Do not chance by hand! 
   10522             : */
   10523        3438 : class SgTypedefDeclarationStorageClass  : public SgDeclarationStatementStorageClass
   10524             :    {
   10525             : 
   10526             :     protected: 
   10527             : 
   10528             : 
   10529             : /* #line 10530 "../../../src/frontend/SageIII//StorageClasses.h" */
   10530             : 
   10531             :       SgNameStorageClass storageOf_name;
   10532             :      unsigned long storageOf_base_type;
   10533             :      unsigned long storageOf_type;
   10534             :      unsigned long storageOf_declaration;
   10535             :      unsigned long storageOf_parent_scope;
   10536             :       bool storageOf_typedefBaseTypeContainsDefiningDeclaration;
   10537             :      unsigned long storageOf_scope;
   10538             :       bool storageOf_requiresGlobalNameQualificationOnType;
   10539             :       int storageOf_name_qualification_length_for_base_type;
   10540             :       bool storageOf_type_elaboration_required_for_base_type;
   10541             :       bool storageOf_global_qualification_required_for_base_type;
   10542             :       bool storageOf_isAutonomousDeclaration;
   10543             :       bool storageOf_isAssociatedWithDeclarationList;
   10544             :       bool storageOf_isFirstDeclarationOfDeclarationList;
   10545             :       int storageOf_name_qualification_length;
   10546             :       bool storageOf_type_elaboration_required;
   10547             :       bool storageOf_global_qualification_required;
   10548             : 
   10549             : 
   10550             : /* #line 10 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarStorageClassDeclatationMacros.macro" */
   10551             : 
   10552             : 
   10553             :     public:
   10554             :       void pickOutIRNodeData ( SgTypedefDeclaration* source );
   10555             :       static void arrangeStaticDataOfEasyStorageClassesInOneBlock ( );
   10556             :       static void deleteStaticDataOfEasyStorageClasses ( );
   10557             :       static void pickOutStaticDataMembers ( );
   10558             :       static void rebuildStaticDataMembers ( );
   10559             :       static void writeEasyStorageDataToFile (std::ostream& out);
   10560             :       static void readEasyStorageDataFromFile (std::istream& in);
   10561             :       static void writeStaticDataToFile (std::ostream& out );
   10562             :       static void readStaticDataFromFile (std::istream& in );
   10563             :       friend class SgTypedefDeclaration;
   10564             :    };
   10565             : /* #line 10566 "../../../src/frontend/SageIII//StorageClasses.h" */
   10566             : 
   10567             : 
   10568             : 
   10569             : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarStorageClassDeclatationMacros.macro" */
   10570             : /* 
   10571             :    JH (01/01/2006) ROSETTA generated class declarations for SgTemplateTypedefDeclarationStorageClass 
   10572             :    used for the ast file IO. Do not chance by hand! 
   10573             : */
   10574         190 : class SgTemplateTypedefDeclarationStorageClass  : public SgTypedefDeclarationStorageClass
   10575             :    {
   10576             : 
   10577             :     protected: 
   10578             : 
   10579             : 
   10580             : /* #line 10581 "../../../src/frontend/SageIII//StorageClasses.h" */
   10581             : 
   10582             :        EasyStorage < SgTemplateParameterPtrList > storageOf_templateParameters;
   10583             :        EasyStorage < SgTemplateArgumentPtrList > storageOf_templateSpecializationArguments;
   10584             :       SgNameStorageClass storageOf_string;
   10585             :      unsigned long storageOf_nonreal_decl_scope;
   10586             : 
   10587             : 
   10588             : /* #line 10 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarStorageClassDeclatationMacros.macro" */
   10589             : 
   10590             : 
   10591             :     public:
   10592             :       void pickOutIRNodeData ( SgTemplateTypedefDeclaration* source );
   10593             :       static void arrangeStaticDataOfEasyStorageClassesInOneBlock ( );
   10594             :       static void deleteStaticDataOfEasyStorageClasses ( );
   10595             :       static void pickOutStaticDataMembers ( );
   10596             :       static void rebuildStaticDataMembers ( );
   10597             :       static void writeEasyStorageDataToFile (std::ostream& out);
   10598             :       static void readEasyStorageDataFromFile (std::istream& in);
   10599             :       static void writeStaticDataToFile (std::ostream& out );
   10600             :       static void readStaticDataFromFile (std::istream& in );
   10601             :       friend class SgTemplateTypedefDeclaration;
   10602             :    };
   10603             : /* #line 10604 "../../../src/frontend/SageIII//StorageClasses.h" */
   10604             : 
   10605             : 
   10606             : 
   10607             : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarStorageClassDeclatationMacros.macro" */
   10608             : /* 
   10609             :    JH (01/01/2006) ROSETTA generated class declarations for SgTemplateInstantiationTypedefDeclarationStorageClass 
   10610             :    used for the ast file IO. Do not chance by hand! 
   10611             : */
   10612         130 : class SgTemplateInstantiationTypedefDeclarationStorageClass  : public SgTypedefDeclarationStorageClass
   10613             :    {
   10614             : 
   10615             :     protected: 
   10616             : 
   10617             : 
   10618             : /* #line 10619 "../../../src/frontend/SageIII//StorageClasses.h" */
   10619             : 
   10620             :       SgNameStorageClass storageOf_templateName;
   10621             :       SgNameStorageClass storageOf_templateHeader;
   10622             :      unsigned long storageOf_templateDeclaration;
   10623             :        EasyStorage < SgTemplateArgumentPtrList > storageOf_templateArguments;
   10624             :       bool storageOf_nameResetFromMangledForm;
   10625             : 
   10626             : 
   10627             : /* #line 10 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarStorageClassDeclatationMacros.macro" */
   10628             : 
   10629             : 
   10630             :     public:
   10631             :       void pickOutIRNodeData ( SgTemplateInstantiationTypedefDeclaration* source );
   10632             :       static void arrangeStaticDataOfEasyStorageClassesInOneBlock ( );
   10633             :       static void deleteStaticDataOfEasyStorageClasses ( );
   10634             :       static void pickOutStaticDataMembers ( );
   10635             :       static void rebuildStaticDataMembers ( );
   10636             :       static void writeEasyStorageDataToFile (std::ostream& out);
   10637             :       static void readEasyStorageDataFromFile (std::istream& in);
   10638             :       static void writeStaticDataToFile (std::ostream& out );
   10639             :       static void readStaticDataFromFile (std::istream& in );
   10640             :       friend class SgTemplateInstantiationTypedefDeclaration;
   10641             :    };
   10642             : /* #line 10643 "../../../src/frontend/SageIII//StorageClasses.h" */
   10643             : 
   10644             : 
   10645             : 
   10646             : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarStorageClassDeclatationMacros.macro" */
   10647             : /* 
   10648             :    JH (01/01/2006) ROSETTA generated class declarations for SgStatementFunctionStatementStorageClass 
   10649             :    used for the ast file IO. Do not chance by hand! 
   10650             : */
   10651           0 : class SgStatementFunctionStatementStorageClass  : public SgDeclarationStatementStorageClass
   10652             :    {
   10653             : 
   10654             :     protected: 
   10655             : 
   10656             : 
   10657             : /* #line 10658 "../../../src/frontend/SageIII//StorageClasses.h" */
   10658             : 
   10659             :      unsigned long storageOf_function;
   10660             :      unsigned long storageOf_expression;
   10661             : 
   10662             : 
   10663             : /* #line 10 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarStorageClassDeclatationMacros.macro" */
   10664             : 
   10665             : 
   10666             :     public:
   10667             :       void pickOutIRNodeData ( SgStatementFunctionStatement* source );
   10668             :       static void arrangeStaticDataOfEasyStorageClassesInOneBlock ( );
   10669             :       static void deleteStaticDataOfEasyStorageClasses ( );
   10670             :       static void pickOutStaticDataMembers ( );
   10671             :       static void rebuildStaticDataMembers ( );
   10672             :       static void writeEasyStorageDataToFile (std::ostream& out);
   10673             :       static void readEasyStorageDataFromFile (std::istream& in);
   10674             :       static void writeStaticDataToFile (std::ostream& out );
   10675             :       static void readStaticDataFromFile (std::istream& in );
   10676             :       friend class SgStatementFunctionStatement;
   10677             :    };
   10678             : /* #line 10679 "../../../src/frontend/SageIII//StorageClasses.h" */
   10679             : 
   10680             : 
   10681             : 
   10682             : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarStorageClassDeclatationMacros.macro" */
   10683             : /* 
   10684             :    JH (01/01/2006) ROSETTA generated class declarations for SgCtorInitializerListStorageClass 
   10685             :    used for the ast file IO. Do not chance by hand! 
   10686             : */
   10687        8856 : class SgCtorInitializerListStorageClass  : public SgDeclarationStatementStorageClass
   10688             :    {
   10689             : 
   10690             :     protected: 
   10691             : 
   10692             : 
   10693             : /* #line 10694 "../../../src/frontend/SageIII//StorageClasses.h" */
   10694             : 
   10695             :        EasyStorage < SgInitializedNamePtrList > storageOf_ctors;
   10696             : 
   10697             : 
   10698             : /* #line 10 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarStorageClassDeclatationMacros.macro" */
   10699             : 
   10700             : 
   10701             :     public:
   10702             :       void pickOutIRNodeData ( SgCtorInitializerList* source );
   10703             :       static void arrangeStaticDataOfEasyStorageClassesInOneBlock ( );
   10704             :       static void deleteStaticDataOfEasyStorageClasses ( );
   10705             :       static void pickOutStaticDataMembers ( );
   10706             :       static void rebuildStaticDataMembers ( );
   10707             :       static void writeEasyStorageDataToFile (std::ostream& out);
   10708             :       static void readEasyStorageDataFromFile (std::istream& in);
   10709             :       static void writeStaticDataToFile (std::ostream& out );
   10710             :       static void readStaticDataFromFile (std::istream& in );
   10711             :       friend class SgCtorInitializerList;
   10712             :    };
   10713             : /* #line 10714 "../../../src/frontend/SageIII//StorageClasses.h" */
   10714             : 
   10715             : 
   10716             : 
   10717             : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarStorageClassDeclatationMacros.macro" */
   10718             : /* 
   10719             :    JH (01/01/2006) ROSETTA generated class declarations for SgPragmaDeclarationStorageClass 
   10720             :    used for the ast file IO. Do not chance by hand! 
   10721             : */
   10722         194 : class SgPragmaDeclarationStorageClass  : public SgDeclarationStatementStorageClass
   10723             :    {
   10724             : 
   10725             :     protected: 
   10726             : 
   10727             : 
   10728             : /* #line 10729 "../../../src/frontend/SageIII//StorageClasses.h" */
   10729             : 
   10730             :      unsigned long storageOf_pragma;
   10731             : 
   10732             : 
   10733             : /* #line 10 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarStorageClassDeclatationMacros.macro" */
   10734             : 
   10735             : 
   10736             :     public:
   10737             :       void pickOutIRNodeData ( SgPragmaDeclaration* source );
   10738             :       static void arrangeStaticDataOfEasyStorageClassesInOneBlock ( );
   10739             :       static void deleteStaticDataOfEasyStorageClasses ( );
   10740             :       static void pickOutStaticDataMembers ( );
   10741             :       static void rebuildStaticDataMembers ( );
   10742             :       static void writeEasyStorageDataToFile (std::ostream& out);
   10743             :       static void readEasyStorageDataFromFile (std::istream& in);
   10744             :       static void writeStaticDataToFile (std::ostream& out );
   10745             :       static void readStaticDataFromFile (std::istream& in );
   10746             :       friend class SgPragmaDeclaration;
   10747             :    };
   10748             : /* #line 10749 "../../../src/frontend/SageIII//StorageClasses.h" */
   10749             : 
   10750             : 
   10751             : 
   10752             : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarStorageClassDeclatationMacros.macro" */
   10753             : /* 
   10754             :    JH (01/01/2006) ROSETTA generated class declarations for SgUsingDirectiveStatementStorageClass 
   10755             :    used for the ast file IO. Do not chance by hand! 
   10756             : */
   10757           2 : class SgUsingDirectiveStatementStorageClass  : public SgDeclarationStatementStorageClass
   10758             :    {
   10759             : 
   10760             :     protected: 
   10761             : 
   10762             : 
   10763             : /* #line 10764 "../../../src/frontend/SageIII//StorageClasses.h" */
   10764             : 
   10765             :      unsigned long storageOf_namespaceDeclaration;
   10766             :       int storageOf_name_qualification_length;
   10767             :       bool storageOf_type_elaboration_required;
   10768             :       bool storageOf_global_qualification_required;
   10769             : 
   10770             : 
   10771             : /* #line 10 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarStorageClassDeclatationMacros.macro" */
   10772             : 
   10773             : 
   10774             :     public:
   10775             :       void pickOutIRNodeData ( SgUsingDirectiveStatement* source );
   10776             :       static void arrangeStaticDataOfEasyStorageClassesInOneBlock ( );
   10777             :       static void deleteStaticDataOfEasyStorageClasses ( );
   10778             :       static void pickOutStaticDataMembers ( );
   10779             :       static void rebuildStaticDataMembers ( );
   10780             :       static void writeEasyStorageDataToFile (std::ostream& out);
   10781             :       static void readEasyStorageDataFromFile (std::istream& in);
   10782             :       static void writeStaticDataToFile (std::ostream& out );
   10783             :       static void readStaticDataFromFile (std::istream& in );
   10784             :       friend class SgUsingDirectiveStatement;
   10785             :    };
   10786             : /* #line 10787 "../../../src/frontend/SageIII//StorageClasses.h" */
   10787             : 
   10788             : 
   10789             : 
   10790             : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarStorageClassDeclatationMacros.macro" */
   10791             : /* 
   10792             :    JH (01/01/2006) ROSETTA generated class declarations for SgClassDeclarationStorageClass 
   10793             :    used for the ast file IO. Do not chance by hand! 
   10794             : */
   10795         742 : class SgClassDeclarationStorageClass  : public SgDeclarationStatementStorageClass
   10796             :    {
   10797             : 
   10798             :     protected: 
   10799             : 
   10800             : 
   10801             : /* #line 10802 "../../../src/frontend/SageIII//StorageClasses.h" */
   10802             : 
   10803             :       SgNameStorageClass storageOf_name;
   10804             :       SgClassDeclaration::class_types storageOf_class_type;
   10805             :      unsigned long storageOf_type;
   10806             :      unsigned long storageOf_definition;
   10807             :      unsigned long storageOf_scope;
   10808             :       SgDeclarationStatement::template_specialization_enum storageOf_specialization;
   10809             :       bool storageOf_from_template;
   10810             :       bool storageOf_fixupScope;
   10811             :       bool storageOf_isUnNamed;
   10812             :       bool storageOf_explicit_annotation_interface;
   10813             :       bool storageOf_explicit_interface;
   10814             :       bool storageOf_explicit_enum;
   10815             :       bool storageOf_explicit_anonymous;
   10816             :      unsigned long storageOf_decoratorList;
   10817             :       int storageOf_name_qualification_length;
   10818             :       bool storageOf_type_elaboration_required;
   10819             :       bool storageOf_global_qualification_required;
   10820             :       bool storageOf_isAutonomousDeclaration;
   10821             :       bool storageOf_isRepresentingTemplateParameterInTemplateDeclaration;
   10822             :      unsigned long storageOf_adaParentType;
   10823             : 
   10824             : 
   10825             : /* #line 10 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarStorageClassDeclatationMacros.macro" */
   10826             : 
   10827             : 
   10828             :     public:
   10829             :       void pickOutIRNodeData ( SgClassDeclaration* source );
   10830             :       static void arrangeStaticDataOfEasyStorageClassesInOneBlock ( );
   10831             :       static void deleteStaticDataOfEasyStorageClasses ( );
   10832             :       static void pickOutStaticDataMembers ( );
   10833             :       static void rebuildStaticDataMembers ( );
   10834             :       static void writeEasyStorageDataToFile (std::ostream& out);
   10835             :       static void readEasyStorageDataFromFile (std::istream& in);
   10836             :       static void writeStaticDataToFile (std::ostream& out );
   10837             :       static void readStaticDataFromFile (std::istream& in );
   10838             :       friend class SgClassDeclaration;
   10839             :    };
   10840             : /* #line 10841 "../../../src/frontend/SageIII//StorageClasses.h" */
   10841             : 
   10842             : 
   10843             : 
   10844             : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarStorageClassDeclatationMacros.macro" */
   10845             : /* 
   10846             :    JH (01/01/2006) ROSETTA generated class declarations for SgTemplateClassDeclarationStorageClass 
   10847             :    used for the ast file IO. Do not chance by hand! 
   10848             : */
   10849        2180 : class SgTemplateClassDeclarationStorageClass  : public SgClassDeclarationStorageClass
   10850             :    {
   10851             : 
   10852             :     protected: 
   10853             : 
   10854             : 
   10855             : /* #line 10856 "../../../src/frontend/SageIII//StorageClasses.h" */
   10856             : 
   10857             :        EasyStorage < SgTemplateParameterPtrList > storageOf_templateParameters;
   10858             :        EasyStorage < SgTemplateArgumentPtrList > storageOf_templateSpecializationArguments;
   10859             :       SgNameStorageClass storageOf_string;
   10860             :       SgNameStorageClass storageOf_templateName;
   10861             :      unsigned long storageOf_nonreal_decl_scope;
   10862             : 
   10863             : 
   10864             : /* #line 10 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarStorageClassDeclatationMacros.macro" */
   10865             : 
   10866             : 
   10867             :     public:
   10868             :       void pickOutIRNodeData ( SgTemplateClassDeclaration* source );
   10869             :       static void arrangeStaticDataOfEasyStorageClassesInOneBlock ( );
   10870             :       static void deleteStaticDataOfEasyStorageClasses ( );
   10871             :       static void pickOutStaticDataMembers ( );
   10872             :       static void rebuildStaticDataMembers ( );
   10873             :       static void writeEasyStorageDataToFile (std::ostream& out);
   10874             :       static void readEasyStorageDataFromFile (std::istream& in);
   10875             :       static void writeStaticDataToFile (std::ostream& out );
   10876             :       static void readStaticDataFromFile (std::istream& in );
   10877             :       friend class SgTemplateClassDeclaration;
   10878             :    };
   10879             : /* #line 10880 "../../../src/frontend/SageIII//StorageClasses.h" */
   10880             : 
   10881             : 
   10882             : 
   10883             : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarStorageClassDeclatationMacros.macro" */
   10884             : /* 
   10885             :    JH (01/01/2006) ROSETTA generated class declarations for SgTemplateInstantiationDeclStorageClass 
   10886             :    used for the ast file IO. Do not chance by hand! 
   10887             : */
   10888        2638 : class SgTemplateInstantiationDeclStorageClass  : public SgClassDeclarationStorageClass
   10889             :    {
   10890             : 
   10891             :     protected: 
   10892             : 
   10893             : 
   10894             : /* #line 10895 "../../../src/frontend/SageIII//StorageClasses.h" */
   10895             : 
   10896             :       SgNameStorageClass storageOf_templateName;
   10897             :       SgNameStorageClass storageOf_templateHeader;
   10898             :      unsigned long storageOf_templateDeclaration;
   10899             :        EasyStorage < SgTemplateArgumentPtrList > storageOf_templateArguments;
   10900             :       bool storageOf_nameResetFromMangledForm;
   10901             : 
   10902             : 
   10903             : /* #line 10 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarStorageClassDeclatationMacros.macro" */
   10904             : 
   10905             : 
   10906             :     public:
   10907             :       void pickOutIRNodeData ( SgTemplateInstantiationDecl* source );
   10908             :       static void arrangeStaticDataOfEasyStorageClassesInOneBlock ( );
   10909             :       static void deleteStaticDataOfEasyStorageClasses ( );
   10910             :       static void pickOutStaticDataMembers ( );
   10911             :       static void rebuildStaticDataMembers ( );
   10912             :       static void writeEasyStorageDataToFile (std::ostream& out);
   10913             :       static void readEasyStorageDataFromFile (std::istream& in);
   10914             :       static void writeStaticDataToFile (std::ostream& out );
   10915             :       static void readStaticDataFromFile (std::istream& in );
   10916             :       friend class SgTemplateInstantiationDecl;
   10917             :    };
   10918             : /* #line 10919 "../../../src/frontend/SageIII//StorageClasses.h" */
   10919             : 
   10920             : 
   10921             : 
   10922             : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarStorageClassDeclatationMacros.macro" */
   10923             : /* 
   10924             :    JH (01/01/2006) ROSETTA generated class declarations for SgDerivedTypeStatementStorageClass 
   10925             :    used for the ast file IO. Do not chance by hand! 
   10926             : */
   10927           0 : class SgDerivedTypeStatementStorageClass  : public SgClassDeclarationStorageClass
   10928             :    {
   10929             : 
   10930             :     protected: 
   10931             : 
   10932             : 
   10933             : /* #line 10934 "../../../src/frontend/SageIII//StorageClasses.h" */
   10934             : 
   10935             :      unsigned long storageOf_end_numeric_label;
   10936             : 
   10937             : 
   10938             : /* #line 10 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarStorageClassDeclatationMacros.macro" */
   10939             : 
   10940             : 
   10941             :     public:
   10942             :       void pickOutIRNodeData ( SgDerivedTypeStatement* source );
   10943             :       static void arrangeStaticDataOfEasyStorageClassesInOneBlock ( );
   10944             :       static void deleteStaticDataOfEasyStorageClasses ( );
   10945             :       static void pickOutStaticDataMembers ( );
   10946             :       static void rebuildStaticDataMembers ( );
   10947             :       static void writeEasyStorageDataToFile (std::ostream& out);
   10948             :       static void readEasyStorageDataFromFile (std::istream& in);
   10949             :       static void writeStaticDataToFile (std::ostream& out );
   10950             :       static void readStaticDataFromFile (std::istream& in );
   10951             :       friend class SgDerivedTypeStatement;
   10952             :    };
   10953             : /* #line 10954 "../../../src/frontend/SageIII//StorageClasses.h" */
   10954             : 
   10955             : 
   10956             : 
   10957             : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarStorageClassDeclatationMacros.macro" */
   10958             : /* 
   10959             :    JH (01/01/2006) ROSETTA generated class declarations for SgModuleStatementStorageClass 
   10960             :    used for the ast file IO. Do not chance by hand! 
   10961             : */
   10962           0 : class SgModuleStatementStorageClass  : public SgClassDeclarationStorageClass
   10963             :    {
   10964             : 
   10965             :     protected: 
   10966             : 
   10967             : 
   10968             : /* #line 10969 "../../../src/frontend/SageIII//StorageClasses.h" */
   10969             : 
   10970             :      unsigned long storageOf_end_numeric_label;
   10971             : 
   10972             : 
   10973             : /* #line 10 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarStorageClassDeclatationMacros.macro" */
   10974             : 
   10975             : 
   10976             :     public:
   10977             :       void pickOutIRNodeData ( SgModuleStatement* source );
   10978             :       static void arrangeStaticDataOfEasyStorageClassesInOneBlock ( );
   10979             :       static void deleteStaticDataOfEasyStorageClasses ( );
   10980             :       static void pickOutStaticDataMembers ( );
   10981             :       static void rebuildStaticDataMembers ( );
   10982             :       static void writeEasyStorageDataToFile (std::ostream& out);
   10983             :       static void readEasyStorageDataFromFile (std::istream& in);
   10984             :       static void writeStaticDataToFile (std::ostream& out );
   10985             :       static void readStaticDataFromFile (std::istream& in );
   10986             :       friend class SgModuleStatement;
   10987             :    };
   10988             : /* #line 10989 "../../../src/frontend/SageIII//StorageClasses.h" */
   10989             : 
   10990             : 
   10991             : 
   10992             : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarStorageClassDeclatationMacros.macro" */
   10993             : /* 
   10994             :    JH (01/01/2006) ROSETTA generated class declarations for SgImplicitStatementStorageClass 
   10995             :    used for the ast file IO. Do not chance by hand! 
   10996             : */
   10997           0 : class SgImplicitStatementStorageClass  : public SgDeclarationStatementStorageClass
   10998             :    {
   10999             : 
   11000             :     protected: 
   11001             : 
   11002             : 
   11003             : /* #line 11004 "../../../src/frontend/SageIII//StorageClasses.h" */
   11004             : 
   11005             :       bool storageOf_implicit_none;
   11006             :       SgImplicitStatement::implicit_spec_enum storageOf_implicit_spec;
   11007             :        EasyStorage < SgInitializedNamePtrList > storageOf_variables;
   11008             : 
   11009             : 
   11010             : /* #line 10 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarStorageClassDeclatationMacros.macro" */
   11011             : 
   11012             : 
   11013             :     public:
   11014             :       void pickOutIRNodeData ( SgImplicitStatement* source );
   11015             :       static void arrangeStaticDataOfEasyStorageClassesInOneBlock ( );
   11016             :       static void deleteStaticDataOfEasyStorageClasses ( );
   11017             :       static void pickOutStaticDataMembers ( );
   11018             :       static void rebuildStaticDataMembers ( );
   11019             :       static void writeEasyStorageDataToFile (std::ostream& out);
   11020             :       static void readEasyStorageDataFromFile (std::istream& in);
   11021             :       static void writeStaticDataToFile (std::ostream& out );
   11022             :       static void readStaticDataFromFile (std::istream& in );
   11023             :       friend class SgImplicitStatement;
   11024             :    };
   11025             : /* #line 11026 "../../../src/frontend/SageIII//StorageClasses.h" */
   11026             : 
   11027             : 
   11028             : 
   11029             : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarStorageClassDeclatationMacros.macro" */
   11030             : /* 
   11031             :    JH (01/01/2006) ROSETTA generated class declarations for SgUsingDeclarationStatementStorageClass 
   11032             :    used for the ast file IO. Do not chance by hand! 
   11033             : */
   11034         550 : class SgUsingDeclarationStatementStorageClass  : public SgDeclarationStatementStorageClass
   11035             :    {
   11036             : 
   11037             :     protected: 
   11038             : 
   11039             : 
   11040             : /* #line 11041 "../../../src/frontend/SageIII//StorageClasses.h" */
   11041             : 
   11042             :      unsigned long storageOf_declaration;
   11043             :      unsigned long storageOf_initializedName;
   11044             :       int storageOf_name_qualification_length;
   11045             :       bool storageOf_type_elaboration_required;
   11046             :       bool storageOf_global_qualification_required;
   11047             :       bool storageOf_is_inheriting_constructor;
   11048             : 
   11049             : 
   11050             : /* #line 10 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarStorageClassDeclatationMacros.macro" */
   11051             : 
   11052             : 
   11053             :     public:
   11054             :       void pickOutIRNodeData ( SgUsingDeclarationStatement* source );
   11055             :       static void arrangeStaticDataOfEasyStorageClassesInOneBlock ( );
   11056             :       static void deleteStaticDataOfEasyStorageClasses ( );
   11057             :       static void pickOutStaticDataMembers ( );
   11058             :       static void rebuildStaticDataMembers ( );
   11059             :       static void writeEasyStorageDataToFile (std::ostream& out);
   11060             :       static void readEasyStorageDataFromFile (std::istream& in);
   11061             :       static void writeStaticDataToFile (std::ostream& out );
   11062             :       static void readStaticDataFromFile (std::istream& in );
   11063             :       friend class SgUsingDeclarationStatement;
   11064             :    };
   11065             : /* #line 11066 "../../../src/frontend/SageIII//StorageClasses.h" */
   11066             : 
   11067             : 
   11068             : 
   11069             : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarStorageClassDeclatationMacros.macro" */
   11070             : /* 
   11071             :    JH (01/01/2006) ROSETTA generated class declarations for SgNamelistStatementStorageClass 
   11072             :    used for the ast file IO. Do not chance by hand! 
   11073             : */
   11074           0 : class SgNamelistStatementStorageClass  : public SgDeclarationStatementStorageClass
   11075             :    {
   11076             : 
   11077             :     protected: 
   11078             : 
   11079             : 
   11080             : /* #line 11081 "../../../src/frontend/SageIII//StorageClasses.h" */
   11081             : 
   11082             :        EasyStorage < SgNameGroupPtrList > storageOf_group_list;
   11083             : 
   11084             : 
   11085             : /* #line 10 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarStorageClassDeclatationMacros.macro" */
   11086             : 
   11087             : 
   11088             :     public:
   11089             :       void pickOutIRNodeData ( SgNamelistStatement* source );
   11090             :       static void arrangeStaticDataOfEasyStorageClassesInOneBlock ( );
   11091             :       static void deleteStaticDataOfEasyStorageClasses ( );
   11092             :       static void pickOutStaticDataMembers ( );
   11093             :       static void rebuildStaticDataMembers ( );
   11094             :       static void writeEasyStorageDataToFile (std::ostream& out);
   11095             :       static void readEasyStorageDataFromFile (std::istream& in);
   11096             :       static void writeStaticDataToFile (std::ostream& out );
   11097             :       static void readStaticDataFromFile (std::istream& in );
   11098             :       friend class SgNamelistStatement;
   11099             :    };
   11100             : /* #line 11101 "../../../src/frontend/SageIII//StorageClasses.h" */
   11101             : 
   11102             : 
   11103             : 
   11104             : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarStorageClassDeclatationMacros.macro" */
   11105             : /* 
   11106             :    JH (01/01/2006) ROSETTA generated class declarations for SgImportStatementStorageClass 
   11107             :    used for the ast file IO. Do not chance by hand! 
   11108             : */
   11109           0 : class SgImportStatementStorageClass  : public SgDeclarationStatementStorageClass
   11110             :    {
   11111             : 
   11112             :     protected: 
   11113             : 
   11114             : 
   11115             : /* #line 11116 "../../../src/frontend/SageIII//StorageClasses.h" */
   11116             : 
   11117             :        EasyStorage < SgExpressionPtrList > storageOf_import_list;
   11118             : 
   11119             : 
   11120             : /* #line 10 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarStorageClassDeclatationMacros.macro" */
   11121             : 
   11122             : 
   11123             :     public:
   11124             :       void pickOutIRNodeData ( SgImportStatement* source );
   11125             :       static void arrangeStaticDataOfEasyStorageClassesInOneBlock ( );
   11126             :       static void deleteStaticDataOfEasyStorageClasses ( );
   11127             :       static void pickOutStaticDataMembers ( );
   11128             :       static void rebuildStaticDataMembers ( );
   11129             :       static void writeEasyStorageDataToFile (std::ostream& out);
   11130             :       static void readEasyStorageDataFromFile (std::istream& in);
   11131             :       static void writeStaticDataToFile (std::ostream& out );
   11132             :       static void readStaticDataFromFile (std::istream& in );
   11133             :       friend class SgImportStatement;
   11134             :    };
   11135             : /* #line 11136 "../../../src/frontend/SageIII//StorageClasses.h" */
   11136             : 
   11137             : 
   11138             : 
   11139             : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarStorageClassDeclatationMacros.macro" */
   11140             : /* 
   11141             :    JH (01/01/2006) ROSETTA generated class declarations for SgFunctionDeclarationStorageClass 
   11142             :    used for the ast file IO. Do not chance by hand! 
   11143             : */
   11144             : class SgFunctionDeclarationStorageClass  : public SgDeclarationStatementStorageClass
   11145             :    {
   11146             : 
   11147             :     protected: 
   11148             : 
   11149             : 
   11150             : /* #line 11151 "../../../src/frontend/SageIII//StorageClasses.h" */
   11151             : 
   11152             :       SgNameStorageClass storageOf_name;
   11153             :      unsigned long storageOf_parameterList;
   11154             :       SgFunctionModifierStorageClass storageOf_functionModifier;
   11155             :       SgSpecialFunctionModifierStorageClass storageOf_specialFunctionModifier;
   11156             :        EasyStorage < SgTypePtrList > storageOf_exceptionSpecification;
   11157             :       bool storageOf_named_in_end_statement;
   11158             :        EasyStorage < std::string > storageOf_asm_name;
   11159             :      unsigned long storageOf_decoratorList;
   11160             :       bool storageOf_ada_formal_subprogram_decl;
   11161             :      unsigned long storageOf_type;
   11162             :      unsigned long storageOf_definition;
   11163             :       bool storageOf_oldStyleDefinition;
   11164             :      unsigned long storageOf_scope;
   11165             :       SgDeclarationStatement::template_specialization_enum storageOf_specialization;
   11166             :       bool storageOf_requiresNameQualificationOnReturnType;
   11167             :        EasyStorage < std::string > storageOf_gnu_extension_section;
   11168             :        EasyStorage < std::string > storageOf_gnu_extension_alias;
   11169             :       SgDeclarationStatement::gnu_extension_visability_attribute_enum storageOf_gnu_extension_visability;
   11170             :       int storageOf_name_qualification_length;
   11171             :       bool storageOf_type_elaboration_required;
   11172             :       bool storageOf_global_qualification_required;
   11173             :       int storageOf_name_qualification_length_for_return_type;
   11174             :       bool storageOf_type_elaboration_required_for_return_type;
   11175             :       bool storageOf_global_qualification_required_for_return_type;
   11176             :       bool storageOf_prototypeIsWithoutParameters;
   11177             :       int storageOf_gnu_regparm_attribute;
   11178             :      unsigned long storageOf_type_syntax;
   11179             :       bool storageOf_type_syntax_is_available;
   11180             :      unsigned long storageOf_parameterList_syntax;
   11181             :       bool storageOf_using_C11_Noreturn_keyword;
   11182             :       bool storageOf_is_constexpr;
   11183             :       bool storageOf_using_new_function_return_type_syntax;
   11184             :      unsigned long storageOf_functionParameterScope;
   11185             :       bool storageOf_marked_as_edg_normalization;
   11186             :       bool storageOf_is_implicit_function;
   11187             : 
   11188             : 
   11189             : /* #line 10 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarStorageClassDeclatationMacros.macro" */
   11190             : 
   11191             : 
   11192             :     public:
   11193             :       void pickOutIRNodeData ( SgFunctionDeclaration* source );
   11194             :       static void arrangeStaticDataOfEasyStorageClassesInOneBlock ( );
   11195             :       static void deleteStaticDataOfEasyStorageClasses ( );
   11196             :       static void pickOutStaticDataMembers ( );
   11197             :       static void rebuildStaticDataMembers ( );
   11198             :       static void writeEasyStorageDataToFile (std::ostream& out);
   11199             :       static void readEasyStorageDataFromFile (std::istream& in);
   11200             :       static void writeStaticDataToFile (std::ostream& out );
   11201             :       static void readStaticDataFromFile (std::istream& in );
   11202             :       friend class SgFunctionDeclaration;
   11203             :    };
   11204             : /* #line 11205 "../../../src/frontend/SageIII//StorageClasses.h" */
   11205             : 
   11206             : 
   11207             : 
   11208             : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarStorageClassDeclatationMacros.macro" */
   11209             : /* 
   11210             :    JH (01/01/2006) ROSETTA generated class declarations for SgTemplateFunctionDeclarationStorageClass 
   11211             :    used for the ast file IO. Do not chance by hand! 
   11212             : */
   11213        1352 : class SgTemplateFunctionDeclarationStorageClass  : public SgFunctionDeclarationStorageClass
   11214             :    {
   11215             : 
   11216             :     protected: 
   11217             : 
   11218             : 
   11219             : /* #line 11220 "../../../src/frontend/SageIII//StorageClasses.h" */
   11220             : 
   11221             :        EasyStorage < SgTemplateParameterPtrList > storageOf_templateParameters;
   11222             :        EasyStorage < SgTemplateArgumentPtrList > storageOf_templateSpecializationArguments;
   11223             :       SgNameStorageClass storageOf_string;
   11224             :       bool storageOf_string_represents_function_body;
   11225             :      unsigned long storageOf_nonreal_decl_scope;
   11226             : 
   11227             : 
   11228             : /* #line 10 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarStorageClassDeclatationMacros.macro" */
   11229             : 
   11230             : 
   11231             :     public:
   11232             :       void pickOutIRNodeData ( SgTemplateFunctionDeclaration* source );
   11233             :       static void arrangeStaticDataOfEasyStorageClassesInOneBlock ( );
   11234             :       static void deleteStaticDataOfEasyStorageClasses ( );
   11235             :       static void pickOutStaticDataMembers ( );
   11236             :       static void rebuildStaticDataMembers ( );
   11237             :       static void writeEasyStorageDataToFile (std::ostream& out);
   11238             :       static void readEasyStorageDataFromFile (std::istream& in);
   11239             :       static void writeStaticDataToFile (std::ostream& out );
   11240             :       static void readStaticDataFromFile (std::istream& in );
   11241             :       friend class SgTemplateFunctionDeclaration;
   11242             :    };
   11243             : /* #line 11244 "../../../src/frontend/SageIII//StorageClasses.h" */
   11244             : 
   11245             : 
   11246             : 
   11247             : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarStorageClassDeclatationMacros.macro" */
   11248             : /* 
   11249             :    JH (01/01/2006) ROSETTA generated class declarations for SgMemberFunctionDeclarationStorageClass 
   11250             :    used for the ast file IO. Do not chance by hand! 
   11251             : */
   11252        1568 : class SgMemberFunctionDeclarationStorageClass  : public SgFunctionDeclarationStorageClass
   11253             :    {
   11254             : 
   11255             :     protected: 
   11256             : 
   11257             : 
   11258             : /* #line 11259 "../../../src/frontend/SageIII//StorageClasses.h" */
   11259             : 
   11260             :      unsigned long storageOf_CtorInitializerList;
   11261             :      unsigned long storageOf_associatedClassDeclaration;
   11262             : 
   11263             : 
   11264             : /* #line 10 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarStorageClassDeclatationMacros.macro" */
   11265             : 
   11266             : 
   11267             :     public:
   11268             :       void pickOutIRNodeData ( SgMemberFunctionDeclaration* source );
   11269             :       static void arrangeStaticDataOfEasyStorageClassesInOneBlock ( );
   11270             :       static void deleteStaticDataOfEasyStorageClasses ( );
   11271             :       static void pickOutStaticDataMembers ( );
   11272             :       static void rebuildStaticDataMembers ( );
   11273             :       static void writeEasyStorageDataToFile (std::ostream& out);
   11274             :       static void readEasyStorageDataFromFile (std::istream& in);
   11275             :       static void writeStaticDataToFile (std::ostream& out );
   11276             :       static void readStaticDataFromFile (std::istream& in );
   11277             :       friend class SgMemberFunctionDeclaration;
   11278             :    };
   11279             : /* #line 11280 "../../../src/frontend/SageIII//StorageClasses.h" */
   11280             : 
   11281             : 
   11282             : 
   11283             : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarStorageClassDeclatationMacros.macro" */
   11284             : /* 
   11285             :    JH (01/01/2006) ROSETTA generated class declarations for SgTemplateMemberFunctionDeclarationStorageClass 
   11286             :    used for the ast file IO. Do not chance by hand! 
   11287             : */
   11288        3810 : class SgTemplateMemberFunctionDeclarationStorageClass  : public SgMemberFunctionDeclarationStorageClass
   11289             :    {
   11290             : 
   11291             :     protected: 
   11292             : 
   11293             : 
   11294             : /* #line 11295 "../../../src/frontend/SageIII//StorageClasses.h" */
   11295             : 
   11296             :        EasyStorage < SgTemplateParameterPtrList > storageOf_templateParameters;
   11297             :        EasyStorage < SgTemplateArgumentPtrList > storageOf_templateSpecializationArguments;
   11298             :       SgNameStorageClass storageOf_string;
   11299             :       bool storageOf_string_represents_function_body;
   11300             :      unsigned long storageOf_nonreal_decl_scope;
   11301             : 
   11302             : 
   11303             : /* #line 10 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarStorageClassDeclatationMacros.macro" */
   11304             : 
   11305             : 
   11306             :     public:
   11307             :       void pickOutIRNodeData ( SgTemplateMemberFunctionDeclaration* source );
   11308             :       static void arrangeStaticDataOfEasyStorageClassesInOneBlock ( );
   11309             :       static void deleteStaticDataOfEasyStorageClasses ( );
   11310             :       static void pickOutStaticDataMembers ( );
   11311             :       static void rebuildStaticDataMembers ( );
   11312             :       static void writeEasyStorageDataToFile (std::ostream& out);
   11313             :       static void readEasyStorageDataFromFile (std::istream& in);
   11314             :       static void writeStaticDataToFile (std::ostream& out );
   11315             :       static void readStaticDataFromFile (std::istream& in );
   11316             :       friend class SgTemplateMemberFunctionDeclaration;
   11317             :    };
   11318             : /* #line 11319 "../../../src/frontend/SageIII//StorageClasses.h" */
   11319             : 
   11320             : 
   11321             : 
   11322             : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarStorageClassDeclatationMacros.macro" */
   11323             : /* 
   11324             :    JH (01/01/2006) ROSETTA generated class declarations for SgTemplateInstantiationMemberFunctionDeclStorageClass 
   11325             :    used for the ast file IO. Do not chance by hand! 
   11326             : */
   11327        3478 : class SgTemplateInstantiationMemberFunctionDeclStorageClass  : public SgMemberFunctionDeclarationStorageClass
   11328             :    {
   11329             : 
   11330             :     protected: 
   11331             : 
   11332             : 
   11333             : /* #line 11334 "../../../src/frontend/SageIII//StorageClasses.h" */
   11334             : 
   11335             :       SgNameStorageClass storageOf_templateName;
   11336             :      unsigned long storageOf_templateDeclaration;
   11337             :        EasyStorage < SgTemplateArgumentPtrList > storageOf_templateArguments;
   11338             :       bool storageOf_nameResetFromMangledForm;
   11339             :       bool storageOf_template_argument_list_is_explicit;
   11340             : 
   11341             : 
   11342             : /* #line 10 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarStorageClassDeclatationMacros.macro" */
   11343             : 
   11344             : 
   11345             :     public:
   11346             :       void pickOutIRNodeData ( SgTemplateInstantiationMemberFunctionDecl* source );
   11347             :       static void arrangeStaticDataOfEasyStorageClassesInOneBlock ( );
   11348             :       static void deleteStaticDataOfEasyStorageClasses ( );
   11349             :       static void pickOutStaticDataMembers ( );
   11350             :       static void rebuildStaticDataMembers ( );
   11351             :       static void writeEasyStorageDataToFile (std::ostream& out);
   11352             :       static void readEasyStorageDataFromFile (std::istream& in);
   11353             :       static void writeStaticDataToFile (std::ostream& out );
   11354             :       static void readStaticDataFromFile (std::istream& in );
   11355             :       friend class SgTemplateInstantiationMemberFunctionDecl;
   11356             :    };
   11357             : /* #line 11358 "../../../src/frontend/SageIII//StorageClasses.h" */
   11358             : 
   11359             : 
   11360             : 
   11361             : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarStorageClassDeclatationMacros.macro" */
   11362             : /* 
   11363             :    JH (01/01/2006) ROSETTA generated class declarations for SgTemplateInstantiationFunctionDeclStorageClass 
   11364             :    used for the ast file IO. Do not chance by hand! 
   11365             : */
   11366         566 : class SgTemplateInstantiationFunctionDeclStorageClass  : public SgFunctionDeclarationStorageClass
   11367             :    {
   11368             : 
   11369             :     protected: 
   11370             : 
   11371             : 
   11372             : /* #line 11373 "../../../src/frontend/SageIII//StorageClasses.h" */
   11373             : 
   11374             :       SgNameStorageClass storageOf_templateName;
   11375             :      unsigned long storageOf_templateDeclaration;
   11376             :        EasyStorage < SgTemplateArgumentPtrList > storageOf_templateArguments;
   11377             :       bool storageOf_nameResetFromMangledForm;
   11378             :       bool storageOf_template_argument_list_is_explicit;
   11379             : 
   11380             : 
   11381             : /* #line 10 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarStorageClassDeclatationMacros.macro" */
   11382             : 
   11383             : 
   11384             :     public:
   11385             :       void pickOutIRNodeData ( SgTemplateInstantiationFunctionDecl* source );
   11386             :       static void arrangeStaticDataOfEasyStorageClassesInOneBlock ( );
   11387             :       static void deleteStaticDataOfEasyStorageClasses ( );
   11388             :       static void pickOutStaticDataMembers ( );
   11389             :       static void rebuildStaticDataMembers ( );
   11390             :       static void writeEasyStorageDataToFile (std::ostream& out);
   11391             :       static void readEasyStorageDataFromFile (std::istream& in);
   11392             :       static void writeStaticDataToFile (std::ostream& out );
   11393             :       static void readStaticDataFromFile (std::istream& in );
   11394             :       friend class SgTemplateInstantiationFunctionDecl;
   11395             :    };
   11396             : /* #line 11397 "../../../src/frontend/SageIII//StorageClasses.h" */
   11397             : 
   11398             : 
   11399             : 
   11400             : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarStorageClassDeclatationMacros.macro" */
   11401             : /* 
   11402             :    JH (01/01/2006) ROSETTA generated class declarations for SgProgramHeaderStatementStorageClass 
   11403             :    used for the ast file IO. Do not chance by hand! 
   11404             : */
   11405           1 : class SgProgramHeaderStatementStorageClass  : public SgFunctionDeclarationStorageClass
   11406             :    {
   11407             : 
   11408             :     protected: 
   11409             : 
   11410             : 
   11411             : /* #line 11412 "../../../src/frontend/SageIII//StorageClasses.h" */
   11412             : 
   11413             :       bool storageOf_program_statement_explicit;
   11414             :      unsigned long storageOf_end_numeric_label;
   11415             : 
   11416             : 
   11417             : /* #line 10 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarStorageClassDeclatationMacros.macro" */
   11418             : 
   11419             : 
   11420             :     public:
   11421             :       void pickOutIRNodeData ( SgProgramHeaderStatement* source );
   11422             :       static void arrangeStaticDataOfEasyStorageClassesInOneBlock ( );
   11423             :       static void deleteStaticDataOfEasyStorageClasses ( );
   11424             :       static void pickOutStaticDataMembers ( );
   11425             :       static void rebuildStaticDataMembers ( );
   11426             :       static void writeEasyStorageDataToFile (std::ostream& out);
   11427             :       static void readEasyStorageDataFromFile (std::istream& in);
   11428             :       static void writeStaticDataToFile (std::ostream& out );
   11429             :       static void readStaticDataFromFile (std::istream& in );
   11430             :       friend class SgProgramHeaderStatement;
   11431             :    };
   11432             : /* #line 11433 "../../../src/frontend/SageIII//StorageClasses.h" */
   11433             : 
   11434             : 
   11435             : 
   11436             : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarStorageClassDeclatationMacros.macro" */
   11437             : /* 
   11438             :    JH (01/01/2006) ROSETTA generated class declarations for SgProcedureHeaderStatementStorageClass 
   11439             :    used for the ast file IO. Do not chance by hand! 
   11440             : */
   11441           0 : class SgProcedureHeaderStatementStorageClass  : public SgFunctionDeclarationStorageClass
   11442             :    {
   11443             : 
   11444             :     protected: 
   11445             : 
   11446             : 
   11447             : /* #line 11448 "../../../src/frontend/SageIII//StorageClasses.h" */
   11448             : 
   11449             :       SgProcedureHeaderStatement::subprogram_kind_enum storageOf_subprogram_kind;
   11450             :      unsigned long storageOf_end_numeric_label;
   11451             :      unsigned long storageOf_result_name;
   11452             : 
   11453             : 
   11454             : /* #line 10 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarStorageClassDeclatationMacros.macro" */
   11455             : 
   11456             : 
   11457             :     public:
   11458             :       void pickOutIRNodeData ( SgProcedureHeaderStatement* source );
   11459             :       static void arrangeStaticDataOfEasyStorageClassesInOneBlock ( );
   11460             :       static void deleteStaticDataOfEasyStorageClasses ( );
   11461             :       static void pickOutStaticDataMembers ( );
   11462             :       static void rebuildStaticDataMembers ( );
   11463             :       static void writeEasyStorageDataToFile (std::ostream& out);
   11464             :       static void readEasyStorageDataFromFile (std::istream& in);
   11465             :       static void writeStaticDataToFile (std::ostream& out );
   11466             :       static void readStaticDataFromFile (std::istream& in );
   11467             :       friend class SgProcedureHeaderStatement;
   11468             :    };
   11469             : /* #line 11470 "../../../src/frontend/SageIII//StorageClasses.h" */
   11470             : 
   11471             : 
   11472             : 
   11473             : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarStorageClassDeclatationMacros.macro" */
   11474             : /* 
   11475             :    JH (01/01/2006) ROSETTA generated class declarations for SgEntryStatementStorageClass 
   11476             :    used for the ast file IO. Do not chance by hand! 
   11477             : */
   11478           0 : class SgEntryStatementStorageClass  : public SgFunctionDeclarationStorageClass
   11479             :    {
   11480             : 
   11481             :     protected: 
   11482             : 
   11483             : 
   11484             : /* #line 11485 "../../../src/frontend/SageIII//StorageClasses.h" */
   11485             : 
   11486             :      unsigned long storageOf_result_name;
   11487             : 
   11488             : 
   11489             : /* #line 10 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarStorageClassDeclatationMacros.macro" */
   11490             : 
   11491             : 
   11492             :     public:
   11493             :       void pickOutIRNodeData ( SgEntryStatement* source );
   11494             :       static void arrangeStaticDataOfEasyStorageClassesInOneBlock ( );
   11495             :       static void deleteStaticDataOfEasyStorageClasses ( );
   11496             :       static void pickOutStaticDataMembers ( );
   11497             :       static void rebuildStaticDataMembers ( );
   11498             :       static void writeEasyStorageDataToFile (std::ostream& out);
   11499             :       static void readEasyStorageDataFromFile (std::istream& in);
   11500             :       static void writeStaticDataToFile (std::ostream& out );
   11501             :       static void readStaticDataFromFile (std::istream& in );
   11502             :       friend class SgEntryStatement;
   11503             :    };
   11504             : /* #line 11505 "../../../src/frontend/SageIII//StorageClasses.h" */
   11505             : 
   11506             : 
   11507             : 
   11508             : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarStorageClassDeclatationMacros.macro" */
   11509             : /* 
   11510             :    JH (01/01/2006) ROSETTA generated class declarations for SgContainsStatementStorageClass 
   11511             :    used for the ast file IO. Do not chance by hand! 
   11512             : */
   11513           0 : class SgContainsStatementStorageClass  : public SgDeclarationStatementStorageClass
   11514             :    {
   11515             : 
   11516             :     protected: 
   11517             : 
   11518             : 
   11519             : /* #line 11520 "../../../src/frontend/SageIII//StorageClasses.h" */
   11520             : 
   11521             : 
   11522             : 
   11523             : /* #line 10 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarStorageClassDeclatationMacros.macro" */
   11524             : 
   11525             : 
   11526             :     public:
   11527             :       void pickOutIRNodeData ( SgContainsStatement* source );
   11528             :       static void arrangeStaticDataOfEasyStorageClassesInOneBlock ( );
   11529             :       static void deleteStaticDataOfEasyStorageClasses ( );
   11530             :       static void pickOutStaticDataMembers ( );
   11531             :       static void rebuildStaticDataMembers ( );
   11532             :       static void writeEasyStorageDataToFile (std::ostream& out);
   11533             :       static void readEasyStorageDataFromFile (std::istream& in);
   11534             :       static void writeStaticDataToFile (std::ostream& out );
   11535             :       static void readStaticDataFromFile (std::istream& in );
   11536             :       friend class SgContainsStatement;
   11537             :    };
   11538             : /* #line 11539 "../../../src/frontend/SageIII//StorageClasses.h" */
   11539             : 
   11540             : 
   11541             : 
   11542             : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarStorageClassDeclatationMacros.macro" */
   11543             : /* 
   11544             :    JH (01/01/2006) ROSETTA generated class declarations for SgC_PreprocessorDirectiveStatementStorageClass 
   11545             :    used for the ast file IO. Do not chance by hand! 
   11546             : */
   11547           0 : class SgC_PreprocessorDirectiveStatementStorageClass  : public SgDeclarationStatementStorageClass
   11548             :    {
   11549             : 
   11550             :     protected: 
   11551             : 
   11552             : 
   11553             : /* #line 11554 "../../../src/frontend/SageIII//StorageClasses.h" */
   11554             : 
   11555             :        EasyStorage < std::string > storageOf_directiveString;
   11556             : 
   11557             : 
   11558             : /* #line 10 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarStorageClassDeclatationMacros.macro" */
   11559             : 
   11560             : 
   11561             :     public:
   11562             :       void pickOutIRNodeData ( SgC_PreprocessorDirectiveStatement* source );
   11563             :       static void arrangeStaticDataOfEasyStorageClassesInOneBlock ( );
   11564             :       static void deleteStaticDataOfEasyStorageClasses ( );
   11565             :       static void pickOutStaticDataMembers ( );
   11566             :       static void rebuildStaticDataMembers ( );
   11567             :       static void writeEasyStorageDataToFile (std::ostream& out);
   11568             :       static void readEasyStorageDataFromFile (std::istream& in);
   11569             :       static void writeStaticDataToFile (std::ostream& out );
   11570             :       static void readStaticDataFromFile (std::istream& in );
   11571             :       friend class SgC_PreprocessorDirectiveStatement;
   11572             :    };
   11573             : /* #line 11574 "../../../src/frontend/SageIII//StorageClasses.h" */
   11574             : 
   11575             : 
   11576             : 
   11577             : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarStorageClassDeclatationMacros.macro" */
   11578             : /* 
   11579             :    JH (01/01/2006) ROSETTA generated class declarations for SgIncludeDirectiveStatementStorageClass 
   11580             :    used for the ast file IO. Do not chance by hand! 
   11581             : */
   11582           0 : class SgIncludeDirectiveStatementStorageClass  : public SgC_PreprocessorDirectiveStatementStorageClass
   11583             :    {
   11584             : 
   11585             :     protected: 
   11586             : 
   11587             : 
   11588             : /* #line 11589 "../../../src/frontend/SageIII//StorageClasses.h" */
   11589             : 
   11590             :      unsigned long storageOf_headerFileBody;
   11591             :      unsigned long storageOf_include_file_heirarchy;
   11592             :        EasyStorage < std::string > storageOf_name_used_in_include_directive;
   11593             : 
   11594             : 
   11595             : /* #line 10 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarStorageClassDeclatationMacros.macro" */
   11596             : 
   11597             : 
   11598             :     public:
   11599             :       void pickOutIRNodeData ( SgIncludeDirectiveStatement* source );
   11600             :       static void arrangeStaticDataOfEasyStorageClassesInOneBlock ( );
   11601             :       static void deleteStaticDataOfEasyStorageClasses ( );
   11602             :       static void pickOutStaticDataMembers ( );
   11603             :       static void rebuildStaticDataMembers ( );
   11604             :       static void writeEasyStorageDataToFile (std::ostream& out);
   11605             :       static void readEasyStorageDataFromFile (std::istream& in);
   11606             :       static void writeStaticDataToFile (std::ostream& out );
   11607             :       static void readStaticDataFromFile (std::istream& in );
   11608             :       friend class SgIncludeDirectiveStatement;
   11609             :    };
   11610             : /* #line 11611 "../../../src/frontend/SageIII//StorageClasses.h" */
   11611             : 
   11612             : 
   11613             : 
   11614             : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarStorageClassDeclatationMacros.macro" */
   11615             : /* 
   11616             :    JH (01/01/2006) ROSETTA generated class declarations for SgDefineDirectiveStatementStorageClass 
   11617             :    used for the ast file IO. Do not chance by hand! 
   11618             : */
   11619           0 : class SgDefineDirectiveStatementStorageClass  : public SgC_PreprocessorDirectiveStatementStorageClass
   11620             :    {
   11621             : 
   11622             :     protected: 
   11623             : 
   11624             : 
   11625             : /* #line 11626 "../../../src/frontend/SageIII//StorageClasses.h" */
   11626             : 
   11627             : 
   11628             : 
   11629             : /* #line 10 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarStorageClassDeclatationMacros.macro" */
   11630             : 
   11631             : 
   11632             :     public:
   11633             :       void pickOutIRNodeData ( SgDefineDirectiveStatement* source );
   11634             :       static void arrangeStaticDataOfEasyStorageClassesInOneBlock ( );
   11635             :       static void deleteStaticDataOfEasyStorageClasses ( );
   11636             :       static void pickOutStaticDataMembers ( );
   11637             :       static void rebuildStaticDataMembers ( );
   11638             :       static void writeEasyStorageDataToFile (std::ostream& out);
   11639             :       static void readEasyStorageDataFromFile (std::istream& in);
   11640             :       static void writeStaticDataToFile (std::ostream& out );
   11641             :       static void readStaticDataFromFile (std::istream& in );
   11642             :       friend class SgDefineDirectiveStatement;
   11643             :    };
   11644             : /* #line 11645 "../../../src/frontend/SageIII//StorageClasses.h" */
   11645             : 
   11646             : 
   11647             : 
   11648             : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarStorageClassDeclatationMacros.macro" */
   11649             : /* 
   11650             :    JH (01/01/2006) ROSETTA generated class declarations for SgUndefDirectiveStatementStorageClass 
   11651             :    used for the ast file IO. Do not chance by hand! 
   11652             : */
   11653           0 : class SgUndefDirectiveStatementStorageClass  : public SgC_PreprocessorDirectiveStatementStorageClass
   11654             :    {
   11655             : 
   11656             :     protected: 
   11657             : 
   11658             : 
   11659             : /* #line 11660 "../../../src/frontend/SageIII//StorageClasses.h" */
   11660             : 
   11661             : 
   11662             : 
   11663             : /* #line 10 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarStorageClassDeclatationMacros.macro" */
   11664             : 
   11665             : 
   11666             :     public:
   11667             :       void pickOutIRNodeData ( SgUndefDirectiveStatement* source );
   11668             :       static void arrangeStaticDataOfEasyStorageClassesInOneBlock ( );
   11669             :       static void deleteStaticDataOfEasyStorageClasses ( );
   11670             :       static void pickOutStaticDataMembers ( );
   11671             :       static void rebuildStaticDataMembers ( );
   11672             :       static void writeEasyStorageDataToFile (std::ostream& out);
   11673             :       static void readEasyStorageDataFromFile (std::istream& in);
   11674             :       static void writeStaticDataToFile (std::ostream& out );
   11675             :       static void readStaticDataFromFile (std::istream& in );
   11676             :       friend class SgUndefDirectiveStatement;
   11677             :    };
   11678             : /* #line 11679 "../../../src/frontend/SageIII//StorageClasses.h" */
   11679             : 
   11680             : 
   11681             : 
   11682             : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarStorageClassDeclatationMacros.macro" */
   11683             : /* 
   11684             :    JH (01/01/2006) ROSETTA generated class declarations for SgIfdefDirectiveStatementStorageClass 
   11685             :    used for the ast file IO. Do not chance by hand! 
   11686             : */
   11687           0 : class SgIfdefDirectiveStatementStorageClass  : public SgC_PreprocessorDirectiveStatementStorageClass
   11688             :    {
   11689             : 
   11690             :     protected: 
   11691             : 
   11692             : 
   11693             : /* #line 11694 "../../../src/frontend/SageIII//StorageClasses.h" */
   11694             : 
   11695             : 
   11696             : 
   11697             : /* #line 10 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarStorageClassDeclatationMacros.macro" */
   11698             : 
   11699             : 
   11700             :     public:
   11701             :       void pickOutIRNodeData ( SgIfdefDirectiveStatement* source );
   11702             :       static void arrangeStaticDataOfEasyStorageClassesInOneBlock ( );
   11703             :       static void deleteStaticDataOfEasyStorageClasses ( );
   11704             :       static void pickOutStaticDataMembers ( );
   11705             :       static void rebuildStaticDataMembers ( );
   11706             :       static void writeEasyStorageDataToFile (std::ostream& out);
   11707             :       static void readEasyStorageDataFromFile (std::istream& in);
   11708             :       static void writeStaticDataToFile (std::ostream& out );
   11709             :       static void readStaticDataFromFile (std::istream& in );
   11710             :       friend class SgIfdefDirectiveStatement;
   11711             :    };
   11712             : /* #line 11713 "../../../src/frontend/SageIII//StorageClasses.h" */
   11713             : 
   11714             : 
   11715             : 
   11716             : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarStorageClassDeclatationMacros.macro" */
   11717             : /* 
   11718             :    JH (01/01/2006) ROSETTA generated class declarations for SgIfndefDirectiveStatementStorageClass 
   11719             :    used for the ast file IO. Do not chance by hand! 
   11720             : */
   11721           0 : class SgIfndefDirectiveStatementStorageClass  : public SgC_PreprocessorDirectiveStatementStorageClass
   11722             :    {
   11723             : 
   11724             :     protected: 
   11725             : 
   11726             : 
   11727             : /* #line 11728 "../../../src/frontend/SageIII//StorageClasses.h" */
   11728             : 
   11729             : 
   11730             : 
   11731             : /* #line 10 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarStorageClassDeclatationMacros.macro" */
   11732             : 
   11733             : 
   11734             :     public:
   11735             :       void pickOutIRNodeData ( SgIfndefDirectiveStatement* source );
   11736             :       static void arrangeStaticDataOfEasyStorageClassesInOneBlock ( );
   11737             :       static void deleteStaticDataOfEasyStorageClasses ( );
   11738             :       static void pickOutStaticDataMembers ( );
   11739             :       static void rebuildStaticDataMembers ( );
   11740             :       static void writeEasyStorageDataToFile (std::ostream& out);
   11741             :       static void readEasyStorageDataFromFile (std::istream& in);
   11742             :       static void writeStaticDataToFile (std::ostream& out );
   11743             :       static void readStaticDataFromFile (std::istream& in );
   11744             :       friend class SgIfndefDirectiveStatement;
   11745             :    };
   11746             : /* #line 11747 "../../../src/frontend/SageIII//StorageClasses.h" */
   11747             : 
   11748             : 
   11749             : 
   11750             : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarStorageClassDeclatationMacros.macro" */
   11751             : /* 
   11752             :    JH (01/01/2006) ROSETTA generated class declarations for SgIfDirectiveStatementStorageClass 
   11753             :    used for the ast file IO. Do not chance by hand! 
   11754             : */
   11755           0 : class SgIfDirectiveStatementStorageClass  : public SgC_PreprocessorDirectiveStatementStorageClass
   11756             :    {
   11757             : 
   11758             :     protected: 
   11759             : 
   11760             : 
   11761             : /* #line 11762 "../../../src/frontend/SageIII//StorageClasses.h" */
   11762             : 
   11763             : 
   11764             : 
   11765             : /* #line 10 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarStorageClassDeclatationMacros.macro" */
   11766             : 
   11767             : 
   11768             :     public:
   11769             :       void pickOutIRNodeData ( SgIfDirectiveStatement* source );
   11770             :       static void arrangeStaticDataOfEasyStorageClassesInOneBlock ( );
   11771             :       static void deleteStaticDataOfEasyStorageClasses ( );
   11772             :       static void pickOutStaticDataMembers ( );
   11773             :       static void rebuildStaticDataMembers ( );
   11774             :       static void writeEasyStorageDataToFile (std::ostream& out);
   11775             :       static void readEasyStorageDataFromFile (std::istream& in);
   11776             :       static void writeStaticDataToFile (std::ostream& out );
   11777             :       static void readStaticDataFromFile (std::istream& in );
   11778             :       friend class SgIfDirectiveStatement;
   11779             :    };
   11780             : /* #line 11781 "../../../src/frontend/SageIII//StorageClasses.h" */
   11781             : 
   11782             : 
   11783             : 
   11784             : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarStorageClassDeclatationMacros.macro" */
   11785             : /* 
   11786             :    JH (01/01/2006) ROSETTA generated class declarations for SgDeadIfDirectiveStatementStorageClass 
   11787             :    used for the ast file IO. Do not chance by hand! 
   11788             : */
   11789           0 : class SgDeadIfDirectiveStatementStorageClass  : public SgC_PreprocessorDirectiveStatementStorageClass
   11790             :    {
   11791             : 
   11792             :     protected: 
   11793             : 
   11794             : 
   11795             : /* #line 11796 "../../../src/frontend/SageIII//StorageClasses.h" */
   11796             : 
   11797             : 
   11798             : 
   11799             : /* #line 10 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarStorageClassDeclatationMacros.macro" */
   11800             : 
   11801             : 
   11802             :     public:
   11803             :       void pickOutIRNodeData ( SgDeadIfDirectiveStatement* source );
   11804             :       static void arrangeStaticDataOfEasyStorageClassesInOneBlock ( );
   11805             :       static void deleteStaticDataOfEasyStorageClasses ( );
   11806             :       static void pickOutStaticDataMembers ( );
   11807             :       static void rebuildStaticDataMembers ( );
   11808             :       static void writeEasyStorageDataToFile (std::ostream& out);
   11809             :       static void readEasyStorageDataFromFile (std::istream& in);
   11810             :       static void writeStaticDataToFile (std::ostream& out );
   11811             :       static void readStaticDataFromFile (std::istream& in );
   11812             :       friend class SgDeadIfDirectiveStatement;
   11813             :    };
   11814             : /* #line 11815 "../../../src/frontend/SageIII//StorageClasses.h" */
   11815             : 
   11816             : 
   11817             : 
   11818             : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarStorageClassDeclatationMacros.macro" */
   11819             : /* 
   11820             :    JH (01/01/2006) ROSETTA generated class declarations for SgElseDirectiveStatementStorageClass 
   11821             :    used for the ast file IO. Do not chance by hand! 
   11822             : */
   11823           0 : class SgElseDirectiveStatementStorageClass  : public SgC_PreprocessorDirectiveStatementStorageClass
   11824             :    {
   11825             : 
   11826             :     protected: 
   11827             : 
   11828             : 
   11829             : /* #line 11830 "../../../src/frontend/SageIII//StorageClasses.h" */
   11830             : 
   11831             : 
   11832             : 
   11833             : /* #line 10 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarStorageClassDeclatationMacros.macro" */
   11834             : 
   11835             : 
   11836             :     public:
   11837             :       void pickOutIRNodeData ( SgElseDirectiveStatement* source );
   11838             :       static void arrangeStaticDataOfEasyStorageClassesInOneBlock ( );
   11839             :       static void deleteStaticDataOfEasyStorageClasses ( );
   11840             :       static void pickOutStaticDataMembers ( );
   11841             :       static void rebuildStaticDataMembers ( );
   11842             :       static void writeEasyStorageDataToFile (std::ostream& out);
   11843             :       static void readEasyStorageDataFromFile (std::istream& in);
   11844             :       static void writeStaticDataToFile (std::ostream& out );
   11845             :       static void readStaticDataFromFile (std::istream& in );
   11846             :       friend class SgElseDirectiveStatement;
   11847             :    };
   11848             : /* #line 11849 "../../../src/frontend/SageIII//StorageClasses.h" */
   11849             : 
   11850             : 
   11851             : 
   11852             : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarStorageClassDeclatationMacros.macro" */
   11853             : /* 
   11854             :    JH (01/01/2006) ROSETTA generated class declarations for SgElseifDirectiveStatementStorageClass 
   11855             :    used for the ast file IO. Do not chance by hand! 
   11856             : */
   11857           0 : class SgElseifDirectiveStatementStorageClass  : public SgC_PreprocessorDirectiveStatementStorageClass
   11858             :    {
   11859             : 
   11860             :     protected: 
   11861             : 
   11862             : 
   11863             : /* #line 11864 "../../../src/frontend/SageIII//StorageClasses.h" */
   11864             : 
   11865             : 
   11866             : 
   11867             : /* #line 10 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarStorageClassDeclatationMacros.macro" */
   11868             : 
   11869             : 
   11870             :     public:
   11871             :       void pickOutIRNodeData ( SgElseifDirectiveStatement* source );
   11872             :       static void arrangeStaticDataOfEasyStorageClassesInOneBlock ( );
   11873             :       static void deleteStaticDataOfEasyStorageClasses ( );
   11874             :       static void pickOutStaticDataMembers ( );
   11875             :       static void rebuildStaticDataMembers ( );
   11876             :       static void writeEasyStorageDataToFile (std::ostream& out);
   11877             :       static void readEasyStorageDataFromFile (std::istream& in);
   11878             :       static void writeStaticDataToFile (std::ostream& out );
   11879             :       static void readStaticDataFromFile (std::istream& in );
   11880             :       friend class SgElseifDirectiveStatement;
   11881             :    };
   11882             : /* #line 11883 "../../../src/frontend/SageIII//StorageClasses.h" */
   11883             : 
   11884             : 
   11885             : 
   11886             : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarStorageClassDeclatationMacros.macro" */
   11887             : /* 
   11888             :    JH (01/01/2006) ROSETTA generated class declarations for SgEndifDirectiveStatementStorageClass 
   11889             :    used for the ast file IO. Do not chance by hand! 
   11890             : */
   11891           0 : class SgEndifDirectiveStatementStorageClass  : public SgC_PreprocessorDirectiveStatementStorageClass
   11892             :    {
   11893             : 
   11894             :     protected: 
   11895             : 
   11896             : 
   11897             : /* #line 11898 "../../../src/frontend/SageIII//StorageClasses.h" */
   11898             : 
   11899             : 
   11900             : 
   11901             : /* #line 10 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarStorageClassDeclatationMacros.macro" */
   11902             : 
   11903             : 
   11904             :     public:
   11905             :       void pickOutIRNodeData ( SgEndifDirectiveStatement* source );
   11906             :       static void arrangeStaticDataOfEasyStorageClassesInOneBlock ( );
   11907             :       static void deleteStaticDataOfEasyStorageClasses ( );
   11908             :       static void pickOutStaticDataMembers ( );
   11909             :       static void rebuildStaticDataMembers ( );
   11910             :       static void writeEasyStorageDataToFile (std::ostream& out);
   11911             :       static void readEasyStorageDataFromFile (std::istream& in);
   11912             :       static void writeStaticDataToFile (std::ostream& out );
   11913             :       static void readStaticDataFromFile (std::istream& in );
   11914             :       friend class SgEndifDirectiveStatement;
   11915             :    };
   11916             : /* #line 11917 "../../../src/frontend/SageIII//StorageClasses.h" */
   11917             : 
   11918             : 
   11919             : 
   11920             : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarStorageClassDeclatationMacros.macro" */
   11921             : /* 
   11922             :    JH (01/01/2006) ROSETTA generated class declarations for SgLineDirectiveStatementStorageClass 
   11923             :    used for the ast file IO. Do not chance by hand! 
   11924             : */
   11925           0 : class SgLineDirectiveStatementStorageClass  : public SgC_PreprocessorDirectiveStatementStorageClass
   11926             :    {
   11927             : 
   11928             :     protected: 
   11929             : 
   11930             : 
   11931             : /* #line 11932 "../../../src/frontend/SageIII//StorageClasses.h" */
   11932             : 
   11933             : 
   11934             : 
   11935             : /* #line 10 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarStorageClassDeclatationMacros.macro" */
   11936             : 
   11937             : 
   11938             :     public:
   11939             :       void pickOutIRNodeData ( SgLineDirectiveStatement* source );
   11940             :       static void arrangeStaticDataOfEasyStorageClassesInOneBlock ( );
   11941             :       static void deleteStaticDataOfEasyStorageClasses ( );
   11942             :       static void pickOutStaticDataMembers ( );
   11943             :       static void rebuildStaticDataMembers ( );
   11944             :       static void writeEasyStorageDataToFile (std::ostream& out);
   11945             :       static void readEasyStorageDataFromFile (std::istream& in);
   11946             :       static void writeStaticDataToFile (std::ostream& out );
   11947             :       static void readStaticDataFromFile (std::istream& in );
   11948             :       friend class SgLineDirectiveStatement;
   11949             :    };
   11950             : /* #line 11951 "../../../src/frontend/SageIII//StorageClasses.h" */
   11951             : 
   11952             : 
   11953             : 
   11954             : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarStorageClassDeclatationMacros.macro" */
   11955             : /* 
   11956             :    JH (01/01/2006) ROSETTA generated class declarations for SgWarningDirectiveStatementStorageClass 
   11957             :    used for the ast file IO. Do not chance by hand! 
   11958             : */
   11959           0 : class SgWarningDirectiveStatementStorageClass  : public SgC_PreprocessorDirectiveStatementStorageClass
   11960             :    {
   11961             : 
   11962             :     protected: 
   11963             : 
   11964             : 
   11965             : /* #line 11966 "../../../src/frontend/SageIII//StorageClasses.h" */
   11966             : 
   11967             : 
   11968             : 
   11969             : /* #line 10 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarStorageClassDeclatationMacros.macro" */
   11970             : 
   11971             : 
   11972             :     public:
   11973             :       void pickOutIRNodeData ( SgWarningDirectiveStatement* source );
   11974             :       static void arrangeStaticDataOfEasyStorageClassesInOneBlock ( );
   11975             :       static void deleteStaticDataOfEasyStorageClasses ( );
   11976             :       static void pickOutStaticDataMembers ( );
   11977             :       static void rebuildStaticDataMembers ( );
   11978             :       static void writeEasyStorageDataToFile (std::ostream& out);
   11979             :       static void readEasyStorageDataFromFile (std::istream& in);
   11980             :       static void writeStaticDataToFile (std::ostream& out );
   11981             :       static void readStaticDataFromFile (std::istream& in );
   11982             :       friend class SgWarningDirectiveStatement;
   11983             :    };
   11984             : /* #line 11985 "../../../src/frontend/SageIII//StorageClasses.h" */
   11985             : 
   11986             : 
   11987             : 
   11988             : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarStorageClassDeclatationMacros.macro" */
   11989             : /* 
   11990             :    JH (01/01/2006) ROSETTA generated class declarations for SgErrorDirectiveStatementStorageClass 
   11991             :    used for the ast file IO. Do not chance by hand! 
   11992             : */
   11993           0 : class SgErrorDirectiveStatementStorageClass  : public SgC_PreprocessorDirectiveStatementStorageClass
   11994             :    {
   11995             : 
   11996             :     protected: 
   11997             : 
   11998             : 
   11999             : /* #line 12000 "../../../src/frontend/SageIII//StorageClasses.h" */
   12000             : 
   12001             : 
   12002             : 
   12003             : /* #line 10 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarStorageClassDeclatationMacros.macro" */
   12004             : 
   12005             : 
   12006             :     public:
   12007             :       void pickOutIRNodeData ( SgErrorDirectiveStatement* source );
   12008             :       static void arrangeStaticDataOfEasyStorageClassesInOneBlock ( );
   12009             :       static void deleteStaticDataOfEasyStorageClasses ( );
   12010             :       static void pickOutStaticDataMembers ( );
   12011             :       static void rebuildStaticDataMembers ( );
   12012             :       static void writeEasyStorageDataToFile (std::ostream& out);
   12013             :       static void readEasyStorageDataFromFile (std::istream& in);
   12014             :       static void writeStaticDataToFile (std::ostream& out );
   12015             :       static void readStaticDataFromFile (std::istream& in );
   12016             :       friend class SgErrorDirectiveStatement;
   12017             :    };
   12018             : /* #line 12019 "../../../src/frontend/SageIII//StorageClasses.h" */
   12019             : 
   12020             : 
   12021             : 
   12022             : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarStorageClassDeclatationMacros.macro" */
   12023             : /* 
   12024             :    JH (01/01/2006) ROSETTA generated class declarations for SgEmptyDirectiveStatementStorageClass 
   12025             :    used for the ast file IO. Do not chance by hand! 
   12026             : */
   12027           0 : class SgEmptyDirectiveStatementStorageClass  : public SgC_PreprocessorDirectiveStatementStorageClass
   12028             :    {
   12029             : 
   12030             :     protected: 
   12031             : 
   12032             : 
   12033             : /* #line 12034 "../../../src/frontend/SageIII//StorageClasses.h" */
   12034             : 
   12035             : 
   12036             : 
   12037             : /* #line 10 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarStorageClassDeclatationMacros.macro" */
   12038             : 
   12039             : 
   12040             :     public:
   12041             :       void pickOutIRNodeData ( SgEmptyDirectiveStatement* source );
   12042             :       static void arrangeStaticDataOfEasyStorageClassesInOneBlock ( );
   12043             :       static void deleteStaticDataOfEasyStorageClasses ( );
   12044             :       static void pickOutStaticDataMembers ( );
   12045             :       static void rebuildStaticDataMembers ( );
   12046             :       static void writeEasyStorageDataToFile (std::ostream& out);
   12047             :       static void readEasyStorageDataFromFile (std::istream& in);
   12048             :       static void writeStaticDataToFile (std::ostream& out );
   12049             :       static void readStaticDataFromFile (std::istream& in );
   12050             :       friend class SgEmptyDirectiveStatement;
   12051             :    };
   12052             : /* #line 12053 "../../../src/frontend/SageIII//StorageClasses.h" */
   12053             : 
   12054             : 
   12055             : 
   12056             : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarStorageClassDeclatationMacros.macro" */
   12057             : /* 
   12058             :    JH (01/01/2006) ROSETTA generated class declarations for SgIncludeNextDirectiveStatementStorageClass 
   12059             :    used for the ast file IO. Do not chance by hand! 
   12060             : */
   12061           0 : class SgIncludeNextDirectiveStatementStorageClass  : public SgC_PreprocessorDirectiveStatementStorageClass
   12062             :    {
   12063             : 
   12064             :     protected: 
   12065             : 
   12066             : 
   12067             : /* #line 12068 "../../../src/frontend/SageIII//StorageClasses.h" */
   12068             : 
   12069             : 
   12070             : 
   12071             : /* #line 10 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarStorageClassDeclatationMacros.macro" */
   12072             : 
   12073             : 
   12074             :     public:
   12075             :       void pickOutIRNodeData ( SgIncludeNextDirectiveStatement* source );
   12076             :       static void arrangeStaticDataOfEasyStorageClassesInOneBlock ( );
   12077             :       static void deleteStaticDataOfEasyStorageClasses ( );
   12078             :       static void pickOutStaticDataMembers ( );
   12079             :       static void rebuildStaticDataMembers ( );
   12080             :       static void writeEasyStorageDataToFile (std::ostream& out);
   12081             :       static void readEasyStorageDataFromFile (std::istream& in);
   12082             :       static void writeStaticDataToFile (std::ostream& out );
   12083             :       static void readStaticDataFromFile (std::istream& in );
   12084             :       friend class SgIncludeNextDirectiveStatement;
   12085             :    };
   12086             : /* #line 12087 "../../../src/frontend/SageIII//StorageClasses.h" */
   12087             : 
   12088             : 
   12089             : 
   12090             : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarStorageClassDeclatationMacros.macro" */
   12091             : /* 
   12092             :    JH (01/01/2006) ROSETTA generated class declarations for SgIdentDirectiveStatementStorageClass 
   12093             :    used for the ast file IO. Do not chance by hand! 
   12094             : */
   12095           0 : class SgIdentDirectiveStatementStorageClass  : public SgC_PreprocessorDirectiveStatementStorageClass
   12096             :    {
   12097             : 
   12098             :     protected: 
   12099             : 
   12100             : 
   12101             : /* #line 12102 "../../../src/frontend/SageIII//StorageClasses.h" */
   12102             : 
   12103             : 
   12104             : 
   12105             : /* #line 10 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarStorageClassDeclatationMacros.macro" */
   12106             : 
   12107             : 
   12108             :     public:
   12109             :       void pickOutIRNodeData ( SgIdentDirectiveStatement* source );
   12110             :       static void arrangeStaticDataOfEasyStorageClassesInOneBlock ( );
   12111             :       static void deleteStaticDataOfEasyStorageClasses ( );
   12112             :       static void pickOutStaticDataMembers ( );
   12113             :       static void rebuildStaticDataMembers ( );
   12114             :       static void writeEasyStorageDataToFile (std::ostream& out);
   12115             :       static void readEasyStorageDataFromFile (std::istream& in);
   12116             :       static void writeStaticDataToFile (std::ostream& out );
   12117             :       static void readStaticDataFromFile (std::istream& in );
   12118             :       friend class SgIdentDirectiveStatement;
   12119             :    };
   12120             : /* #line 12121 "../../../src/frontend/SageIII//StorageClasses.h" */
   12121             : 
   12122             : 
   12123             : 
   12124             : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarStorageClassDeclatationMacros.macro" */
   12125             : /* 
   12126             :    JH (01/01/2006) ROSETTA generated class declarations for SgLinemarkerDirectiveStatementStorageClass 
   12127             :    used for the ast file IO. Do not chance by hand! 
   12128             : */
   12129           0 : class SgLinemarkerDirectiveStatementStorageClass  : public SgC_PreprocessorDirectiveStatementStorageClass
   12130             :    {
   12131             : 
   12132             :     protected: 
   12133             : 
   12134             : 
   12135             : /* #line 12136 "../../../src/frontend/SageIII//StorageClasses.h" */
   12136             : 
   12137             :       int storageOf_linenumber;
   12138             :        EasyStorage < std::string > storageOf_filename;
   12139             :        EasyStorage < SgUnsignedCharList > storageOf_flaglist;
   12140             : 
   12141             : 
   12142             : /* #line 10 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarStorageClassDeclatationMacros.macro" */
   12143             : 
   12144             : 
   12145             :     public:
   12146             :       void pickOutIRNodeData ( SgLinemarkerDirectiveStatement* source );
   12147             :       static void arrangeStaticDataOfEasyStorageClassesInOneBlock ( );
   12148             :       static void deleteStaticDataOfEasyStorageClasses ( );
   12149             :       static void pickOutStaticDataMembers ( );
   12150             :       static void rebuildStaticDataMembers ( );
   12151             :       static void writeEasyStorageDataToFile (std::ostream& out);
   12152             :       static void readEasyStorageDataFromFile (std::istream& in);
   12153             :       static void writeStaticDataToFile (std::ostream& out );
   12154             :       static void readStaticDataFromFile (std::istream& in );
   12155             :       friend class SgLinemarkerDirectiveStatement;
   12156             :    };
   12157             : /* #line 12158 "../../../src/frontend/SageIII//StorageClasses.h" */
   12158             : 
   12159             : 
   12160             : 
   12161             : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarStorageClassDeclatationMacros.macro" */
   12162             : /* 
   12163             :    JH (01/01/2006) ROSETTA generated class declarations for SgOmpThreadprivateStatementStorageClass 
   12164             :    used for the ast file IO. Do not chance by hand! 
   12165             : */
   12166           0 : class SgOmpThreadprivateStatementStorageClass  : public SgDeclarationStatementStorageClass
   12167             :    {
   12168             : 
   12169             :     protected: 
   12170             : 
   12171             : 
   12172             : /* #line 12173 "../../../src/frontend/SageIII//StorageClasses.h" */
   12173             : 
   12174             :        EasyStorage < SgVarRefExpPtrList > storageOf_variables;
   12175             : 
   12176             : 
   12177             : /* #line 10 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarStorageClassDeclatationMacros.macro" */
   12178             : 
   12179             : 
   12180             :     public:
   12181             :       void pickOutIRNodeData ( SgOmpThreadprivateStatement* source );
   12182             :       static void arrangeStaticDataOfEasyStorageClassesInOneBlock ( );
   12183             :       static void deleteStaticDataOfEasyStorageClasses ( );
   12184             :       static void pickOutStaticDataMembers ( );
   12185             :       static void rebuildStaticDataMembers ( );
   12186             :       static void writeEasyStorageDataToFile (std::ostream& out);
   12187             :       static void readEasyStorageDataFromFile (std::istream& in);
   12188             :       static void writeStaticDataToFile (std::ostream& out );
   12189             :       static void readStaticDataFromFile (std::istream& in );
   12190             :       friend class SgOmpThreadprivateStatement;
   12191             :    };
   12192             : /* #line 12193 "../../../src/frontend/SageIII//StorageClasses.h" */
   12193             : 
   12194             : 
   12195             : 
   12196             : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarStorageClassDeclatationMacros.macro" */
   12197             : /* 
   12198             :    JH (01/01/2006) ROSETTA generated class declarations for SgOmpRequiresStatementStorageClass 
   12199             :    used for the ast file IO. Do not chance by hand! 
   12200             : */
   12201           0 : class SgOmpRequiresStatementStorageClass  : public SgDeclarationStatementStorageClass
   12202             :    {
   12203             : 
   12204             :     protected: 
   12205             : 
   12206             : 
   12207             : /* #line 12208 "../../../src/frontend/SageIII//StorageClasses.h" */
   12208             : 
   12209             :        EasyStorage < SgOmpClausePtrList > storageOf_clauses;
   12210             : 
   12211             : 
   12212             : /* #line 10 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarStorageClassDeclatationMacros.macro" */
   12213             : 
   12214             : 
   12215             :     public:
   12216             :       void pickOutIRNodeData ( SgOmpRequiresStatement* source );
   12217             :       static void arrangeStaticDataOfEasyStorageClassesInOneBlock ( );
   12218             :       static void deleteStaticDataOfEasyStorageClasses ( );
   12219             :       static void pickOutStaticDataMembers ( );
   12220             :       static void rebuildStaticDataMembers ( );
   12221             :       static void writeEasyStorageDataToFile (std::ostream& out);
   12222             :       static void readEasyStorageDataFromFile (std::istream& in);
   12223             :       static void writeStaticDataToFile (std::ostream& out );
   12224             :       static void readStaticDataFromFile (std::istream& in );
   12225             :       friend class SgOmpRequiresStatement;
   12226             :    };
   12227             : /* #line 12228 "../../../src/frontend/SageIII//StorageClasses.h" */
   12228             : 
   12229             : 
   12230             : 
   12231             : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarStorageClassDeclatationMacros.macro" */
   12232             : /* 
   12233             :    JH (01/01/2006) ROSETTA generated class declarations for SgFortranIncludeLineStorageClass 
   12234             :    used for the ast file IO. Do not chance by hand! 
   12235             : */
   12236           0 : class SgFortranIncludeLineStorageClass  : public SgDeclarationStatementStorageClass
   12237             :    {
   12238             : 
   12239             :     protected: 
   12240             : 
   12241             : 
   12242             : /* #line 12243 "../../../src/frontend/SageIII//StorageClasses.h" */
   12243             : 
   12244             :        EasyStorage < std::string > storageOf_filename;
   12245             : 
   12246             : 
   12247             : /* #line 10 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarStorageClassDeclatationMacros.macro" */
   12248             : 
   12249             : 
   12250             :     public:
   12251             :       void pickOutIRNodeData ( SgFortranIncludeLine* source );
   12252             :       static void arrangeStaticDataOfEasyStorageClassesInOneBlock ( );
   12253             :       static void deleteStaticDataOfEasyStorageClasses ( );
   12254             :       static void pickOutStaticDataMembers ( );
   12255             :       static void rebuildStaticDataMembers ( );
   12256             :       static void writeEasyStorageDataToFile (std::ostream& out);
   12257             :       static void readEasyStorageDataFromFile (std::istream& in);
   12258             :       static void writeStaticDataToFile (std::ostream& out );
   12259             :       static void readStaticDataFromFile (std::istream& in );
   12260             :       friend class SgFortranIncludeLine;
   12261             :    };
   12262             : /* #line 12263 "../../../src/frontend/SageIII//StorageClasses.h" */
   12263             : 
   12264             : 
   12265             : 
   12266             : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarStorageClassDeclatationMacros.macro" */
   12267             : /* 
   12268             :    JH (01/01/2006) ROSETTA generated class declarations for SgOmpTaskwaitStatementStorageClass 
   12269             :    used for the ast file IO. Do not chance by hand! 
   12270             : */
   12271           0 : class SgOmpTaskwaitStatementStorageClass  : public SgDeclarationStatementStorageClass
   12272             :    {
   12273             : 
   12274             :     protected: 
   12275             : 
   12276             : 
   12277             : /* #line 12278 "../../../src/frontend/SageIII//StorageClasses.h" */
   12278             : 
   12279             :        EasyStorage < SgOmpClausePtrList > storageOf_clauses;
   12280             : 
   12281             : 
   12282             : /* #line 10 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarStorageClassDeclatationMacros.macro" */
   12283             : 
   12284             : 
   12285             :     public:
   12286             :       void pickOutIRNodeData ( SgOmpTaskwaitStatement* source );
   12287             :       static void arrangeStaticDataOfEasyStorageClassesInOneBlock ( );
   12288             :       static void deleteStaticDataOfEasyStorageClasses ( );
   12289             :       static void pickOutStaticDataMembers ( );
   12290             :       static void rebuildStaticDataMembers ( );
   12291             :       static void writeEasyStorageDataToFile (std::ostream& out);
   12292             :       static void readEasyStorageDataFromFile (std::istream& in);
   12293             :       static void writeStaticDataToFile (std::ostream& out );
   12294             :       static void readStaticDataFromFile (std::istream& in );
   12295             :       friend class SgOmpTaskwaitStatement;
   12296             :    };
   12297             : /* #line 12298 "../../../src/frontend/SageIII//StorageClasses.h" */
   12298             : 
   12299             : 
   12300             : 
   12301             : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarStorageClassDeclatationMacros.macro" */
   12302             : /* 
   12303             :    JH (01/01/2006) ROSETTA generated class declarations for SgStmtDeclarationStatementStorageClass 
   12304             :    used for the ast file IO. Do not chance by hand! 
   12305             : */
   12306           0 : class SgStmtDeclarationStatementStorageClass  : public SgDeclarationStatementStorageClass
   12307             :    {
   12308             : 
   12309             :     protected: 
   12310             : 
   12311             : 
   12312             : /* #line 12313 "../../../src/frontend/SageIII//StorageClasses.h" */
   12313             : 
   12314             :      unsigned long storageOf_statement;
   12315             : 
   12316             : 
   12317             : /* #line 10 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarStorageClassDeclatationMacros.macro" */
   12318             : 
   12319             : 
   12320             :     public:
   12321             :       void pickOutIRNodeData ( SgStmtDeclarationStatement* source );
   12322             :       static void arrangeStaticDataOfEasyStorageClassesInOneBlock ( );
   12323             :       static void deleteStaticDataOfEasyStorageClasses ( );
   12324             :       static void pickOutStaticDataMembers ( );
   12325             :       static void rebuildStaticDataMembers ( );
   12326             :       static void writeEasyStorageDataToFile (std::ostream& out);
   12327             :       static void readEasyStorageDataFromFile (std::istream& in);
   12328             :       static void writeStaticDataToFile (std::ostream& out );
   12329             :       static void readStaticDataFromFile (std::istream& in );
   12330             :       friend class SgStmtDeclarationStatement;
   12331             :    };
   12332             : /* #line 12333 "../../../src/frontend/SageIII//StorageClasses.h" */
   12333             : 
   12334             : 
   12335             : 
   12336             : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarStorageClassDeclatationMacros.macro" */
   12337             : /* 
   12338             :    JH (01/01/2006) ROSETTA generated class declarations for SgStaticAssertionDeclarationStorageClass 
   12339             :    used for the ast file IO. Do not chance by hand! 
   12340             : */
   12341          28 : class SgStaticAssertionDeclarationStorageClass  : public SgDeclarationStatementStorageClass
   12342             :    {
   12343             : 
   12344             :     protected: 
   12345             : 
   12346             : 
   12347             : /* #line 12348 "../../../src/frontend/SageIII//StorageClasses.h" */
   12348             : 
   12349             :      unsigned long storageOf_condition;
   12350             :       SgNameStorageClass storageOf_string_literal;
   12351             : 
   12352             : 
   12353             : /* #line 10 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarStorageClassDeclatationMacros.macro" */
   12354             : 
   12355             : 
   12356             :     public:
   12357             :       void pickOutIRNodeData ( SgStaticAssertionDeclaration* source );
   12358             :       static void arrangeStaticDataOfEasyStorageClassesInOneBlock ( );
   12359             :       static void deleteStaticDataOfEasyStorageClasses ( );
   12360             :       static void pickOutStaticDataMembers ( );
   12361             :       static void rebuildStaticDataMembers ( );
   12362             :       static void writeEasyStorageDataToFile (std::ostream& out);
   12363             :       static void readEasyStorageDataFromFile (std::istream& in);
   12364             :       static void writeStaticDataToFile (std::ostream& out );
   12365             :       static void readStaticDataFromFile (std::istream& in );
   12366             :       friend class SgStaticAssertionDeclaration;
   12367             :    };
   12368             : /* #line 12369 "../../../src/frontend/SageIII//StorageClasses.h" */
   12369             : 
   12370             : 
   12371             : 
   12372             : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarStorageClassDeclatationMacros.macro" */
   12373             : /* 
   12374             :    JH (01/01/2006) ROSETTA generated class declarations for SgOmpDeclareSimdStatementStorageClass 
   12375             :    used for the ast file IO. Do not chance by hand! 
   12376             : */
   12377           0 : class SgOmpDeclareSimdStatementStorageClass  : public SgDeclarationStatementStorageClass
   12378             :    {
   12379             : 
   12380             :     protected: 
   12381             : 
   12382             : 
   12383             : /* #line 12384 "../../../src/frontend/SageIII//StorageClasses.h" */
   12384             : 
   12385             :        EasyStorage < SgOmpClausePtrList > storageOf_clauses;
   12386             : 
   12387             : 
   12388             : /* #line 10 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarStorageClassDeclatationMacros.macro" */
   12389             : 
   12390             : 
   12391             :     public:
   12392             :       void pickOutIRNodeData ( SgOmpDeclareSimdStatement* source );
   12393             :       static void arrangeStaticDataOfEasyStorageClassesInOneBlock ( );
   12394             :       static void deleteStaticDataOfEasyStorageClasses ( );
   12395             :       static void pickOutStaticDataMembers ( );
   12396             :       static void rebuildStaticDataMembers ( );
   12397             :       static void writeEasyStorageDataToFile (std::ostream& out);
   12398             :       static void readEasyStorageDataFromFile (std::istream& in);
   12399             :       static void writeStaticDataToFile (std::ostream& out );
   12400             :       static void readStaticDataFromFile (std::istream& in );
   12401             :       friend class SgOmpDeclareSimdStatement;
   12402             :    };
   12403             : /* #line 12404 "../../../src/frontend/SageIII//StorageClasses.h" */
   12404             : 
   12405             : 
   12406             : 
   12407             : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarStorageClassDeclatationMacros.macro" */
   12408             : /* 
   12409             :    JH (01/01/2006) ROSETTA generated class declarations for SgMicrosoftAttributeDeclarationStorageClass 
   12410             :    used for the ast file IO. Do not chance by hand! 
   12411             : */
   12412           0 : class SgMicrosoftAttributeDeclarationStorageClass  : public SgDeclarationStatementStorageClass
   12413             :    {
   12414             : 
   12415             :     protected: 
   12416             : 
   12417             : 
   12418             : /* #line 12419 "../../../src/frontend/SageIII//StorageClasses.h" */
   12419             : 
   12420             :       SgNameStorageClass storageOf_attribute_string;
   12421             : 
   12422             : 
   12423             : /* #line 10 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarStorageClassDeclatationMacros.macro" */
   12424             : 
   12425             : 
   12426             :     public:
   12427             :       void pickOutIRNodeData ( SgMicrosoftAttributeDeclaration* source );
   12428             :       static void arrangeStaticDataOfEasyStorageClassesInOneBlock ( );
   12429             :       static void deleteStaticDataOfEasyStorageClasses ( );
   12430             :       static void pickOutStaticDataMembers ( );
   12431             :       static void rebuildStaticDataMembers ( );
   12432             :       static void writeEasyStorageDataToFile (std::ostream& out);
   12433             :       static void readEasyStorageDataFromFile (std::istream& in);
   12434             :       static void writeStaticDataToFile (std::ostream& out );
   12435             :       static void readStaticDataFromFile (std::istream& in );
   12436             :       friend class SgMicrosoftAttributeDeclaration;
   12437             :    };
   12438             : /* #line 12439 "../../../src/frontend/SageIII//StorageClasses.h" */
   12439             : 
   12440             : 
   12441             : 
   12442             : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarStorageClassDeclatationMacros.macro" */
   12443             : /* 
   12444             :    JH (01/01/2006) ROSETTA generated class declarations for SgNonrealDeclStorageClass 
   12445             :    used for the ast file IO. Do not chance by hand! 
   12446             : */
   12447       10160 : class SgNonrealDeclStorageClass  : public SgDeclarationStatementStorageClass
   12448             :    {
   12449             : 
   12450             :     protected: 
   12451             : 
   12452             : 
   12453             : /* #line 12454 "../../../src/frontend/SageIII//StorageClasses.h" */
   12454             : 
   12455             :       SgNameStorageClass storageOf_name;
   12456             :      unsigned long storageOf_nonreal_decl_scope;
   12457             :      unsigned long storageOf_type;
   12458             :       int storageOf_template_parameter_position;
   12459             :       int storageOf_template_parameter_depth;
   12460             :      unsigned long storageOf_templateDeclaration;
   12461             :        EasyStorage < SgTemplateArgumentPtrList > storageOf_tpl_args;
   12462             :        EasyStorage < SgTemplateParameterPtrList > storageOf_tpl_params;
   12463             :       bool storageOf_is_class_member;
   12464             :       bool storageOf_is_template_param;
   12465             :       bool storageOf_is_template_template_param;
   12466             :       bool storageOf_is_nonreal_template;
   12467             :       bool storageOf_is_nonreal_function;
   12468             : 
   12469             : 
   12470             : /* #line 10 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarStorageClassDeclatationMacros.macro" */
   12471             : 
   12472             : 
   12473             :     public:
   12474             :       void pickOutIRNodeData ( SgNonrealDecl* source );
   12475             :       static void arrangeStaticDataOfEasyStorageClassesInOneBlock ( );
   12476             :       static void deleteStaticDataOfEasyStorageClasses ( );
   12477             :       static void pickOutStaticDataMembers ( );
   12478             :       static void rebuildStaticDataMembers ( );
   12479             :       static void writeEasyStorageDataToFile (std::ostream& out);
   12480             :       static void readEasyStorageDataFromFile (std::istream& in);
   12481             :       static void writeStaticDataToFile (std::ostream& out );
   12482             :       static void readStaticDataFromFile (std::istream& in );
   12483             :       friend class SgNonrealDecl;
   12484             :    };
   12485             : /* #line 12486 "../../../src/frontend/SageIII//StorageClasses.h" */
   12486             : 
   12487             : 
   12488             : 
   12489             : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarStorageClassDeclatationMacros.macro" */
   12490             : /* 
   12491             :    JH (01/01/2006) ROSETTA generated class declarations for SgEmptyDeclarationStorageClass 
   12492             :    used for the ast file IO. Do not chance by hand! 
   12493             : */
   12494           0 : class SgEmptyDeclarationStorageClass  : public SgDeclarationStatementStorageClass
   12495             :    {
   12496             : 
   12497             :     protected: 
   12498             : 
   12499             : 
   12500             : /* #line 12501 "../../../src/frontend/SageIII//StorageClasses.h" */
   12501             : 
   12502             : 
   12503             : 
   12504             : /* #line 10 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarStorageClassDeclatationMacros.macro" */
   12505             : 
   12506             : 
   12507             :     public:
   12508             :       void pickOutIRNodeData ( SgEmptyDeclaration* source );
   12509             :       static void arrangeStaticDataOfEasyStorageClassesInOneBlock ( );
   12510             :       static void deleteStaticDataOfEasyStorageClasses ( );
   12511             :       static void pickOutStaticDataMembers ( );
   12512             :       static void rebuildStaticDataMembers ( );
   12513             :       static void writeEasyStorageDataToFile (std::ostream& out);
   12514             :       static void readEasyStorageDataFromFile (std::istream& in);
   12515             :       static void writeStaticDataToFile (std::ostream& out );
   12516             :       static void readStaticDataFromFile (std::istream& in );
   12517             :       friend class SgEmptyDeclaration;
   12518             :    };
   12519             : /* #line 12520 "../../../src/frontend/SageIII//StorageClasses.h" */
   12520             : 
   12521             : 
   12522             : 
   12523             : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarStorageClassDeclatationMacros.macro" */
   12524             : /* 
   12525             :    JH (01/01/2006) ROSETTA generated class declarations for SgExprStatementStorageClass 
   12526             :    used for the ast file IO. Do not chance by hand! 
   12527             : */
   12528        4416 : class SgExprStatementStorageClass  : public SgStatementStorageClass
   12529             :    {
   12530             : 
   12531             :     protected: 
   12532             : 
   12533             : 
   12534             : /* #line 12535 "../../../src/frontend/SageIII//StorageClasses.h" */
   12535             : 
   12536             :      unsigned long storageOf_expression;
   12537             : 
   12538             : 
   12539             : /* #line 10 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarStorageClassDeclatationMacros.macro" */
   12540             : 
   12541             : 
   12542             :     public:
   12543             :       void pickOutIRNodeData ( SgExprStatement* source );
   12544             :       static void arrangeStaticDataOfEasyStorageClassesInOneBlock ( );
   12545             :       static void deleteStaticDataOfEasyStorageClasses ( );
   12546             :       static void pickOutStaticDataMembers ( );
   12547             :       static void rebuildStaticDataMembers ( );
   12548             :       static void writeEasyStorageDataToFile (std::ostream& out);
   12549             :       static void readEasyStorageDataFromFile (std::istream& in);
   12550             :       static void writeStaticDataToFile (std::ostream& out );
   12551             :       static void readStaticDataFromFile (std::istream& in );
   12552             :       friend class SgExprStatement;
   12553             :    };
   12554             : /* #line 12555 "../../../src/frontend/SageIII//StorageClasses.h" */
   12555             : 
   12556             : 
   12557             : 
   12558             : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarStorageClassDeclatationMacros.macro" */
   12559             : /* 
   12560             :    JH (01/01/2006) ROSETTA generated class declarations for SgLabelStatementStorageClass 
   12561             :    used for the ast file IO. Do not chance by hand! 
   12562             : */
   12563           0 : class SgLabelStatementStorageClass  : public SgStatementStorageClass
   12564             :    {
   12565             : 
   12566             :     protected: 
   12567             : 
   12568             : 
   12569             : /* #line 12570 "../../../src/frontend/SageIII//StorageClasses.h" */
   12570             : 
   12571             :       SgNameStorageClass storageOf_label;
   12572             :      unsigned long storageOf_scope;
   12573             :      unsigned long storageOf_statement;
   12574             :       bool storageOf_gnu_extension_unused;
   12575             : 
   12576             : 
   12577             : /* #line 10 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarStorageClassDeclatationMacros.macro" */
   12578             : 
   12579             : 
   12580             :     public:
   12581             :       void pickOutIRNodeData ( SgLabelStatement* source );
   12582             :       static void arrangeStaticDataOfEasyStorageClassesInOneBlock ( );
   12583             :       static void deleteStaticDataOfEasyStorageClasses ( );
   12584             :       static void pickOutStaticDataMembers ( );
   12585             :       static void rebuildStaticDataMembers ( );
   12586             :       static void writeEasyStorageDataToFile (std::ostream& out);
   12587             :       static void readEasyStorageDataFromFile (std::istream& in);
   12588             :       static void writeStaticDataToFile (std::ostream& out );
   12589             :       static void readStaticDataFromFile (std::istream& in );
   12590             :       friend class SgLabelStatement;
   12591             :    };
   12592             : /* #line 12593 "../../../src/frontend/SageIII//StorageClasses.h" */
   12593             : 
   12594             : 
   12595             : 
   12596             : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarStorageClassDeclatationMacros.macro" */
   12597             : /* 
   12598             :    JH (01/01/2006) ROSETTA generated class declarations for SgCaseOptionStmtStorageClass 
   12599             :    used for the ast file IO. Do not chance by hand! 
   12600             : */
   12601           0 : class SgCaseOptionStmtStorageClass  : public SgStatementStorageClass
   12602             :    {
   12603             : 
   12604             :     protected: 
   12605             : 
   12606             : 
   12607             : /* #line 12608 "../../../src/frontend/SageIII//StorageClasses.h" */
   12608             : 
   12609             :      unsigned long storageOf_key;
   12610             :      unsigned long storageOf_body;
   12611             :      unsigned long storageOf_key_range_end;
   12612             :        EasyStorage < std::string > storageOf_case_construct_name;
   12613             : 
   12614             : 
   12615             : /* #line 10 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarStorageClassDeclatationMacros.macro" */
   12616             : 
   12617             : 
   12618             :     public:
   12619             :       void pickOutIRNodeData ( SgCaseOptionStmt* source );
   12620             :       static void arrangeStaticDataOfEasyStorageClassesInOneBlock ( );
   12621             :       static void deleteStaticDataOfEasyStorageClasses ( );
   12622             :       static void pickOutStaticDataMembers ( );
   12623             :       static void rebuildStaticDataMembers ( );
   12624             :       static void writeEasyStorageDataToFile (std::ostream& out);
   12625             :       static void readEasyStorageDataFromFile (std::istream& in);
   12626             :       static void writeStaticDataToFile (std::ostream& out );
   12627             :       static void readStaticDataFromFile (std::istream& in );
   12628             :       friend class SgCaseOptionStmt;
   12629             :    };
   12630             : /* #line 12631 "../../../src/frontend/SageIII//StorageClasses.h" */
   12631             : 
   12632             : 
   12633             : 
   12634             : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarStorageClassDeclatationMacros.macro" */
   12635             : /* 
   12636             :    JH (01/01/2006) ROSETTA generated class declarations for SgTryStmtStorageClass 
   12637             :    used for the ast file IO. Do not chance by hand! 
   12638             : */
   12639         108 : class SgTryStmtStorageClass  : public SgStatementStorageClass
   12640             :    {
   12641             : 
   12642             :     protected: 
   12643             : 
   12644             : 
   12645             : /* #line 12646 "../../../src/frontend/SageIII//StorageClasses.h" */
   12646             : 
   12647             :      unsigned long storageOf_body;
   12648             :      unsigned long storageOf_catch_statement_seq_root;
   12649             :      unsigned long storageOf_else_body;
   12650             :      unsigned long storageOf_finally_body;
   12651             : 
   12652             : 
   12653             : /* #line 10 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarStorageClassDeclatationMacros.macro" */
   12654             : 
   12655             : 
   12656             :     public:
   12657             :       void pickOutIRNodeData ( SgTryStmt* source );
   12658             :       static void arrangeStaticDataOfEasyStorageClassesInOneBlock ( );
   12659             :       static void deleteStaticDataOfEasyStorageClasses ( );
   12660             :       static void pickOutStaticDataMembers ( );
   12661             :       static void rebuildStaticDataMembers ( );
   12662             :       static void writeEasyStorageDataToFile (std::ostream& out);
   12663             :       static void readEasyStorageDataFromFile (std::istream& in);
   12664             :       static void writeStaticDataToFile (std::ostream& out );
   12665             :       static void readStaticDataFromFile (std::istream& in );
   12666             :       friend class SgTryStmt;
   12667             :    };
   12668             : /* #line 12669 "../../../src/frontend/SageIII//StorageClasses.h" */
   12669             : 
   12670             : 
   12671             : 
   12672             : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarStorageClassDeclatationMacros.macro" */
   12673             : /* 
   12674             :    JH (01/01/2006) ROSETTA generated class declarations for SgDefaultOptionStmtStorageClass 
   12675             :    used for the ast file IO. Do not chance by hand! 
   12676             : */
   12677           0 : class SgDefaultOptionStmtStorageClass  : public SgStatementStorageClass
   12678             :    {
   12679             : 
   12680             :     protected: 
   12681             : 
   12682             : 
   12683             : /* #line 12684 "../../../src/frontend/SageIII//StorageClasses.h" */
   12684             : 
   12685             :      unsigned long storageOf_body;
   12686             :        EasyStorage < std::string > storageOf_default_construct_name;
   12687             : 
   12688             : 
   12689             : /* #line 10 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarStorageClassDeclatationMacros.macro" */
   12690             : 
   12691             : 
   12692             :     public:
   12693             :       void pickOutIRNodeData ( SgDefaultOptionStmt* source );
   12694             :       static void arrangeStaticDataOfEasyStorageClassesInOneBlock ( );
   12695             :       static void deleteStaticDataOfEasyStorageClasses ( );
   12696             :       static void pickOutStaticDataMembers ( );
   12697             :       static void rebuildStaticDataMembers ( );
   12698             :       static void writeEasyStorageDataToFile (std::ostream& out);
   12699             :       static void readEasyStorageDataFromFile (std::istream& in);
   12700             :       static void writeStaticDataToFile (std::ostream& out );
   12701             :       static void readStaticDataFromFile (std::istream& in );
   12702             :       friend class SgDefaultOptionStmt;
   12703             :    };
   12704             : /* #line 12705 "../../../src/frontend/SageIII//StorageClasses.h" */
   12705             : 
   12706             : 
   12707             : 
   12708             : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarStorageClassDeclatationMacros.macro" */
   12709             : /* 
   12710             :    JH (01/01/2006) ROSETTA generated class declarations for SgBreakStmtStorageClass 
   12711             :    used for the ast file IO. Do not chance by hand! 
   12712             : */
   12713          60 : class SgBreakStmtStorageClass  : public SgStatementStorageClass
   12714             :    {
   12715             : 
   12716             :     protected: 
   12717             : 
   12718             : 
   12719             : /* #line 12720 "../../../src/frontend/SageIII//StorageClasses.h" */
   12720             : 
   12721             :        EasyStorage < std::string > storageOf_do_string_label;
   12722             : 
   12723             : 
   12724             : /* #line 10 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarStorageClassDeclatationMacros.macro" */
   12725             : 
   12726             : 
   12727             :     public:
   12728             :       void pickOutIRNodeData ( SgBreakStmt* source );
   12729             :       static void arrangeStaticDataOfEasyStorageClassesInOneBlock ( );
   12730             :       static void deleteStaticDataOfEasyStorageClasses ( );
   12731             :       static void pickOutStaticDataMembers ( );
   12732             :       static void rebuildStaticDataMembers ( );
   12733             :       static void writeEasyStorageDataToFile (std::ostream& out);
   12734             :       static void readEasyStorageDataFromFile (std::istream& in);
   12735             :       static void writeStaticDataToFile (std::ostream& out );
   12736             :       static void readStaticDataFromFile (std::istream& in );
   12737             :       friend class SgBreakStmt;
   12738             :    };
   12739             : /* #line 12740 "../../../src/frontend/SageIII//StorageClasses.h" */
   12740             : 
   12741             : 
   12742             : 
   12743             : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarStorageClassDeclatationMacros.macro" */
   12744             : /* 
   12745             :    JH (01/01/2006) ROSETTA generated class declarations for SgContinueStmtStorageClass 
   12746             :    used for the ast file IO. Do not chance by hand! 
   12747             : */
   12748           4 : class SgContinueStmtStorageClass  : public SgStatementStorageClass
   12749             :    {
   12750             : 
   12751             :     protected: 
   12752             : 
   12753             : 
   12754             : /* #line 12755 "../../../src/frontend/SageIII//StorageClasses.h" */
   12755             : 
   12756             :        EasyStorage < std::string > storageOf_do_string_label;
   12757             : 
   12758             : 
   12759             : /* #line 10 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarStorageClassDeclatationMacros.macro" */
   12760             : 
   12761             : 
   12762             :     public:
   12763             :       void pickOutIRNodeData ( SgContinueStmt* source );
   12764             :       static void arrangeStaticDataOfEasyStorageClassesInOneBlock ( );
   12765             :       static void deleteStaticDataOfEasyStorageClasses ( );
   12766             :       static void pickOutStaticDataMembers ( );
   12767             :       static void rebuildStaticDataMembers ( );
   12768             :       static void writeEasyStorageDataToFile (std::ostream& out);
   12769             :       static void readEasyStorageDataFromFile (std::istream& in);
   12770             :       static void writeStaticDataToFile (std::ostream& out );
   12771             :       static void readStaticDataFromFile (std::istream& in );
   12772             :       friend class SgContinueStmt;
   12773             :    };
   12774             : /* #line 12775 "../../../src/frontend/SageIII//StorageClasses.h" */
   12775             : 
   12776             : 
   12777             : 
   12778             : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarStorageClassDeclatationMacros.macro" */
   12779             : /* 
   12780             :    JH (01/01/2006) ROSETTA generated class declarations for SgReturnStmtStorageClass 
   12781             :    used for the ast file IO. Do not chance by hand! 
   12782             : */
   12783        2810 : class SgReturnStmtStorageClass  : public SgStatementStorageClass
   12784             :    {
   12785             : 
   12786             :     protected: 
   12787             : 
   12788             : 
   12789             : /* #line 12790 "../../../src/frontend/SageIII//StorageClasses.h" */
   12790             : 
   12791             :      unsigned long storageOf_expression;
   12792             : 
   12793             : 
   12794             : /* #line 10 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarStorageClassDeclatationMacros.macro" */
   12795             : 
   12796             : 
   12797             :     public:
   12798             :       void pickOutIRNodeData ( SgReturnStmt* source );
   12799             :       static void arrangeStaticDataOfEasyStorageClassesInOneBlock ( );
   12800             :       static void deleteStaticDataOfEasyStorageClasses ( );
   12801             :       static void pickOutStaticDataMembers ( );
   12802             :       static void rebuildStaticDataMembers ( );
   12803             :       static void writeEasyStorageDataToFile (std::ostream& out);
   12804             :       static void readEasyStorageDataFromFile (std::istream& in);
   12805             :       static void writeStaticDataToFile (std::ostream& out );
   12806             :       static void readStaticDataFromFile (std::istream& in );
   12807             :       friend class SgReturnStmt;
   12808             :    };
   12809             : /* #line 12810 "../../../src/frontend/SageIII//StorageClasses.h" */
   12810             : 
   12811             : 
   12812             : 
   12813             : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarStorageClassDeclatationMacros.macro" */
   12814             : /* 
   12815             :    JH (01/01/2006) ROSETTA generated class declarations for SgGotoStatementStorageClass 
   12816             :    used for the ast file IO. Do not chance by hand! 
   12817             : */
   12818           0 : class SgGotoStatementStorageClass  : public SgStatementStorageClass
   12819             :    {
   12820             : 
   12821             :     protected: 
   12822             : 
   12823             : 
   12824             : /* #line 12825 "../../../src/frontend/SageIII//StorageClasses.h" */
   12825             : 
   12826             :      unsigned long storageOf_label;
   12827             :      unsigned long storageOf_label_expression;
   12828             :      unsigned long storageOf_selector_expression;
   12829             : 
   12830             : 
   12831             : /* #line 10 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarStorageClassDeclatationMacros.macro" */
   12832             : 
   12833             : 
   12834             :     public:
   12835             :       void pickOutIRNodeData ( SgGotoStatement* source );
   12836             :       static void arrangeStaticDataOfEasyStorageClassesInOneBlock ( );
   12837             :       static void deleteStaticDataOfEasyStorageClasses ( );
   12838             :       static void pickOutStaticDataMembers ( );
   12839             :       static void rebuildStaticDataMembers ( );
   12840             :       static void writeEasyStorageDataToFile (std::ostream& out);
   12841             :       static void readEasyStorageDataFromFile (std::istream& in);
   12842             :       static void writeStaticDataToFile (std::ostream& out );
   12843             :       static void readStaticDataFromFile (std::istream& in );
   12844             :       friend class SgGotoStatement;
   12845             :    };
   12846             : /* #line 12847 "../../../src/frontend/SageIII//StorageClasses.h" */
   12847             : 
   12848             : 
   12849             : 
   12850             : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarStorageClassDeclatationMacros.macro" */
   12851             : /* 
   12852             :    JH (01/01/2006) ROSETTA generated class declarations for SgSpawnStmtStorageClass 
   12853             :    used for the ast file IO. Do not chance by hand! 
   12854             : */
   12855           0 : class SgSpawnStmtStorageClass  : public SgStatementStorageClass
   12856             :    {
   12857             : 
   12858             :     protected: 
   12859             : 
   12860             : 
   12861             : /* #line 12862 "../../../src/frontend/SageIII//StorageClasses.h" */
   12862             : 
   12863             :      unsigned long storageOf_the_func;
   12864             : 
   12865             : 
   12866             : /* #line 10 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarStorageClassDeclatationMacros.macro" */
   12867             : 
   12868             : 
   12869             :     public:
   12870             :       void pickOutIRNodeData ( SgSpawnStmt* source );
   12871             :       static void arrangeStaticDataOfEasyStorageClassesInOneBlock ( );
   12872             :       static void deleteStaticDataOfEasyStorageClasses ( );
   12873             :       static void pickOutStaticDataMembers ( );
   12874             :       static void rebuildStaticDataMembers ( );
   12875             :       static void writeEasyStorageDataToFile (std::ostream& out);
   12876             :       static void readEasyStorageDataFromFile (std::istream& in);
   12877             :       static void writeStaticDataToFile (std::ostream& out );
   12878             :       static void readStaticDataFromFile (std::istream& in );
   12879             :       friend class SgSpawnStmt;
   12880             :    };
   12881             : /* #line 12882 "../../../src/frontend/SageIII//StorageClasses.h" */
   12882             : 
   12883             : 
   12884             : 
   12885             : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarStorageClassDeclatationMacros.macro" */
   12886             : /* 
   12887             :    JH (01/01/2006) ROSETTA generated class declarations for SgNullStatementStorageClass 
   12888             :    used for the ast file IO. Do not chance by hand! 
   12889             : */
   12890          40 : class SgNullStatementStorageClass  : public SgStatementStorageClass
   12891             :    {
   12892             : 
   12893             :     protected: 
   12894             : 
   12895             : 
   12896             : /* #line 12897 "../../../src/frontend/SageIII//StorageClasses.h" */
   12897             : 
   12898             : 
   12899             : 
   12900             : /* #line 10 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarStorageClassDeclatationMacros.macro" */
   12901             : 
   12902             : 
   12903             :     public:
   12904             :       void pickOutIRNodeData ( SgNullStatement* source );
   12905             :       static void arrangeStaticDataOfEasyStorageClassesInOneBlock ( );
   12906             :       static void deleteStaticDataOfEasyStorageClasses ( );
   12907             :       static void pickOutStaticDataMembers ( );
   12908             :       static void rebuildStaticDataMembers ( );
   12909             :       static void writeEasyStorageDataToFile (std::ostream& out);
   12910             :       static void readEasyStorageDataFromFile (std::istream& in);
   12911             :       static void writeStaticDataToFile (std::ostream& out );
   12912             :       static void readStaticDataFromFile (std::istream& in );
   12913             :       friend class SgNullStatement;
   12914             :    };
   12915             : /* #line 12916 "../../../src/frontend/SageIII//StorageClasses.h" */
   12916             : 
   12917             : 
   12918             : 
   12919             : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarStorageClassDeclatationMacros.macro" */
   12920             : /* 
   12921             :    JH (01/01/2006) ROSETTA generated class declarations for SgVariantStatementStorageClass 
   12922             :    used for the ast file IO. Do not chance by hand! 
   12923             : */
   12924           0 : class SgVariantStatementStorageClass  : public SgStatementStorageClass
   12925             :    {
   12926             : 
   12927             :     protected: 
   12928             : 
   12929             : 
   12930             : /* #line 12931 "../../../src/frontend/SageIII//StorageClasses.h" */
   12931             : 
   12932             : 
   12933             : 
   12934             : /* #line 10 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarStorageClassDeclatationMacros.macro" */
   12935             : 
   12936             : 
   12937             :     public:
   12938             :       void pickOutIRNodeData ( SgVariantStatement* source );
   12939             :       static void arrangeStaticDataOfEasyStorageClassesInOneBlock ( );
   12940             :       static void deleteStaticDataOfEasyStorageClasses ( );
   12941             :       static void pickOutStaticDataMembers ( );
   12942             :       static void rebuildStaticDataMembers ( );
   12943             :       static void writeEasyStorageDataToFile (std::ostream& out);
   12944             :       static void readEasyStorageDataFromFile (std::istream& in);
   12945             :       static void writeStaticDataToFile (std::ostream& out );
   12946             :       static void readStaticDataFromFile (std::istream& in );
   12947             :       friend class SgVariantStatement;
   12948             :    };
   12949             : /* #line 12950 "../../../src/frontend/SageIII//StorageClasses.h" */
   12950             : 
   12951             : 
   12952             : 
   12953             : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarStorageClassDeclatationMacros.macro" */
   12954             : /* 
   12955             :    JH (01/01/2006) ROSETTA generated class declarations for SgForInitStatementStorageClass 
   12956             :    used for the ast file IO. Do not chance by hand! 
   12957             : */
   12958          80 : class SgForInitStatementStorageClass  : public SgStatementStorageClass
   12959             :    {
   12960             : 
   12961             :     protected: 
   12962             : 
   12963             : 
   12964             : /* #line 12965 "../../../src/frontend/SageIII//StorageClasses.h" */
   12965             : 
   12966             :        EasyStorage < SgStatementPtrList > storageOf_init_stmt;
   12967             : 
   12968             : 
   12969             : /* #line 10 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarStorageClassDeclatationMacros.macro" */
   12970             : 
   12971             : 
   12972             :     public:
   12973             :       void pickOutIRNodeData ( SgForInitStatement* source );
   12974             :       static void arrangeStaticDataOfEasyStorageClassesInOneBlock ( );
   12975             :       static void deleteStaticDataOfEasyStorageClasses ( );
   12976             :       static void pickOutStaticDataMembers ( );
   12977             :       static void rebuildStaticDataMembers ( );
   12978             :       static void writeEasyStorageDataToFile (std::ostream& out);
   12979             :       static void readEasyStorageDataFromFile (std::istream& in);
   12980             :       static void writeStaticDataToFile (std::ostream& out );
   12981             :       static void readStaticDataFromFile (std::istream& in );
   12982             :       friend class SgForInitStatement;
   12983             :    };
   12984             : /* #line 12985 "../../../src/frontend/SageIII//StorageClasses.h" */
   12985             : 
   12986             : 
   12987             : 
   12988             : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarStorageClassDeclatationMacros.macro" */
   12989             : /* 
   12990             :    JH (01/01/2006) ROSETTA generated class declarations for SgCatchStatementSeqStorageClass 
   12991             :    used for the ast file IO. Do not chance by hand! 
   12992             : */
   12993         108 : class SgCatchStatementSeqStorageClass  : public SgStatementStorageClass
   12994             :    {
   12995             : 
   12996             :     protected: 
   12997             : 
   12998             : 
   12999             : /* #line 13000 "../../../src/frontend/SageIII//StorageClasses.h" */
   13000             : 
   13001             :        EasyStorage < SgStatementPtrList > storageOf_catch_statement_seq;
   13002             : 
   13003             : 
   13004             : /* #line 10 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarStorageClassDeclatationMacros.macro" */
   13005             : 
   13006             : 
   13007             :     public:
   13008             :       void pickOutIRNodeData ( SgCatchStatementSeq* source );
   13009             :       static void arrangeStaticDataOfEasyStorageClassesInOneBlock ( );
   13010             :       static void deleteStaticDataOfEasyStorageClasses ( );
   13011             :       static void pickOutStaticDataMembers ( );
   13012             :       static void rebuildStaticDataMembers ( );
   13013             :       static void writeEasyStorageDataToFile (std::ostream& out);
   13014             :       static void readEasyStorageDataFromFile (std::istream& in);
   13015             :       static void writeStaticDataToFile (std::ostream& out );
   13016             :       static void readStaticDataFromFile (std::istream& in );
   13017             :       friend class SgCatchStatementSeq;
   13018             :    };
   13019             : /* #line 13020 "../../../src/frontend/SageIII//StorageClasses.h" */
   13020             : 
   13021             : 
   13022             : 
   13023             : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarStorageClassDeclatationMacros.macro" */
   13024             : /* 
   13025             :    JH (01/01/2006) ROSETTA generated class declarations for SgProcessControlStatementStorageClass 
   13026             :    used for the ast file IO. Do not chance by hand! 
   13027             : */
   13028           0 : class SgProcessControlStatementStorageClass  : public SgStatementStorageClass
   13029             :    {
   13030             : 
   13031             :     protected: 
   13032             : 
   13033             : 
   13034             : /* #line 13035 "../../../src/frontend/SageIII//StorageClasses.h" */
   13035             : 
   13036             :       SgProcessControlStatement::control_enum storageOf_control_kind;
   13037             :      unsigned long storageOf_code;
   13038             :      unsigned long storageOf_quiet;
   13039             : 
   13040             : 
   13041             : /* #line 10 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarStorageClassDeclatationMacros.macro" */
   13042             : 
   13043             : 
   13044             :     public:
   13045             :       void pickOutIRNodeData ( SgProcessControlStatement* source );
   13046             :       static void arrangeStaticDataOfEasyStorageClassesInOneBlock ( );
   13047             :       static void deleteStaticDataOfEasyStorageClasses ( );
   13048             :       static void pickOutStaticDataMembers ( );
   13049             :       static void rebuildStaticDataMembers ( );
   13050             :       static void writeEasyStorageDataToFile (std::ostream& out);
   13051             :       static void readEasyStorageDataFromFile (std::istream& in);
   13052             :       static void writeStaticDataToFile (std::ostream& out );
   13053             :       static void readStaticDataFromFile (std::istream& in );
   13054             :       friend class SgProcessControlStatement;
   13055             :    };
   13056             : /* #line 13057 "../../../src/frontend/SageIII//StorageClasses.h" */
   13057             : 
   13058             : 
   13059             : 
   13060             : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarStorageClassDeclatationMacros.macro" */
   13061             : /* 
   13062             :    JH (01/01/2006) ROSETTA generated class declarations for SgIOStatementStorageClass 
   13063             :    used for the ast file IO. Do not chance by hand! 
   13064             : */
   13065           0 : class SgIOStatementStorageClass  : public SgStatementStorageClass
   13066             :    {
   13067             : 
   13068             :     protected: 
   13069             : 
   13070             : 
   13071             : /* #line 13072 "../../../src/frontend/SageIII//StorageClasses.h" */
   13072             : 
   13073             :       SgIOStatement::io_statement_enum storageOf_io_statement;
   13074             :      unsigned long storageOf_io_stmt_list;
   13075             :      unsigned long storageOf_unit;
   13076             :      unsigned long storageOf_iostat;
   13077             :      unsigned long storageOf_err;
   13078             :      unsigned long storageOf_iomsg;
   13079             : 
   13080             : 
   13081             : /* #line 10 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarStorageClassDeclatationMacros.macro" */
   13082             : 
   13083             : 
   13084             :     public:
   13085             :       void pickOutIRNodeData ( SgIOStatement* source );
   13086             :       static void arrangeStaticDataOfEasyStorageClassesInOneBlock ( );
   13087             :       static void deleteStaticDataOfEasyStorageClasses ( );
   13088             :       static void pickOutStaticDataMembers ( );
   13089             :       static void rebuildStaticDataMembers ( );
   13090             :       static void writeEasyStorageDataToFile (std::ostream& out);
   13091             :       static void readEasyStorageDataFromFile (std::istream& in);
   13092             :       static void writeStaticDataToFile (std::ostream& out );
   13093             :       static void readStaticDataFromFile (std::istream& in );
   13094             :       friend class SgIOStatement;
   13095             :    };
   13096             : /* #line 13097 "../../../src/frontend/SageIII//StorageClasses.h" */
   13097             : 
   13098             : 
   13099             : 
   13100             : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarStorageClassDeclatationMacros.macro" */
   13101             : /* 
   13102             :    JH (01/01/2006) ROSETTA generated class declarations for SgPrintStatementStorageClass 
   13103             :    used for the ast file IO. Do not chance by hand! 
   13104             : */
   13105           1 : class SgPrintStatementStorageClass  : public SgIOStatementStorageClass
   13106             :    {
   13107             : 
   13108             :     protected: 
   13109             : 
   13110             : 
   13111             : /* #line 13112 "../../../src/frontend/SageIII//StorageClasses.h" */
   13112             : 
   13113             :      unsigned long storageOf_format;
   13114             : 
   13115             : 
   13116             : /* #line 10 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarStorageClassDeclatationMacros.macro" */
   13117             : 
   13118             : 
   13119             :     public:
   13120             :       void pickOutIRNodeData ( SgPrintStatement* source );
   13121             :       static void arrangeStaticDataOfEasyStorageClassesInOneBlock ( );
   13122             :       static void deleteStaticDataOfEasyStorageClasses ( );
   13123             :       static void pickOutStaticDataMembers ( );
   13124             :       static void rebuildStaticDataMembers ( );
   13125             :       static void writeEasyStorageDataToFile (std::ostream& out);
   13126             :       static void readEasyStorageDataFromFile (std::istream& in);
   13127             :       static void writeStaticDataToFile (std::ostream& out );
   13128             :       static void readStaticDataFromFile (std::istream& in );
   13129             :       friend class SgPrintStatement;
   13130             :    };
   13131             : /* #line 13132 "../../../src/frontend/SageIII//StorageClasses.h" */
   13132             : 
   13133             : 
   13134             : 
   13135             : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarStorageClassDeclatationMacros.macro" */
   13136             : /* 
   13137             :    JH (01/01/2006) ROSETTA generated class declarations for SgReadStatementStorageClass 
   13138             :    used for the ast file IO. Do not chance by hand! 
   13139             : */
   13140           0 : class SgReadStatementStorageClass  : public SgIOStatementStorageClass
   13141             :    {
   13142             : 
   13143             :     protected: 
   13144             : 
   13145             : 
   13146             : /* #line 13147 "../../../src/frontend/SageIII//StorageClasses.h" */
   13147             : 
   13148             :      unsigned long storageOf_format;
   13149             :      unsigned long storageOf_namelist;
   13150             :      unsigned long storageOf_advance;
   13151             :      unsigned long storageOf_asynchronous;
   13152             :      unsigned long storageOf_blank;
   13153             :      unsigned long storageOf_decimal;
   13154             :      unsigned long storageOf_delim;
   13155             :      unsigned long storageOf_end;
   13156             :      unsigned long storageOf_eor;
   13157             :      unsigned long storageOf_id;
   13158             :      unsigned long storageOf_pad;
   13159             :      unsigned long storageOf_pos;
   13160             :      unsigned long storageOf_rec;
   13161             :      unsigned long storageOf_round;
   13162             :      unsigned long storageOf_sign;
   13163             :      unsigned long storageOf_size;
   13164             : 
   13165             : 
   13166             : /* #line 10 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarStorageClassDeclatationMacros.macro" */
   13167             : 
   13168             : 
   13169             :     public:
   13170             :       void pickOutIRNodeData ( SgReadStatement* source );
   13171             :       static void arrangeStaticDataOfEasyStorageClassesInOneBlock ( );
   13172             :       static void deleteStaticDataOfEasyStorageClasses ( );
   13173             :       static void pickOutStaticDataMembers ( );
   13174             :       static void rebuildStaticDataMembers ( );
   13175             :       static void writeEasyStorageDataToFile (std::ostream& out);
   13176             :       static void readEasyStorageDataFromFile (std::istream& in);
   13177             :       static void writeStaticDataToFile (std::ostream& out );
   13178             :       static void readStaticDataFromFile (std::istream& in );
   13179             :       friend class SgReadStatement;
   13180             :    };
   13181             : /* #line 13182 "../../../src/frontend/SageIII//StorageClasses.h" */
   13182             : 
   13183             : 
   13184             : 
   13185             : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarStorageClassDeclatationMacros.macro" */
   13186             : /* 
   13187             :    JH (01/01/2006) ROSETTA generated class declarations for SgWriteStatementStorageClass 
   13188             :    used for the ast file IO. Do not chance by hand! 
   13189             : */
   13190           0 : class SgWriteStatementStorageClass  : public SgIOStatementStorageClass
   13191             :    {
   13192             : 
   13193             :     protected: 
   13194             : 
   13195             : 
   13196             : /* #line 13197 "../../../src/frontend/SageIII//StorageClasses.h" */
   13197             : 
   13198             :      unsigned long storageOf_format;
   13199             :      unsigned long storageOf_namelist;
   13200             :      unsigned long storageOf_advance;
   13201             :      unsigned long storageOf_asynchronous;
   13202             :      unsigned long storageOf_blank;
   13203             :      unsigned long storageOf_decimal;
   13204             :      unsigned long storageOf_delim;
   13205             :      unsigned long storageOf_end;
   13206             :      unsigned long storageOf_eor;
   13207             :      unsigned long storageOf_id;
   13208             :      unsigned long storageOf_pad;
   13209             :      unsigned long storageOf_pos;
   13210             :      unsigned long storageOf_rec;
   13211             :      unsigned long storageOf_round;
   13212             :      unsigned long storageOf_sign;
   13213             :      unsigned long storageOf_size;
   13214             : 
   13215             : 
   13216             : /* #line 10 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarStorageClassDeclatationMacros.macro" */
   13217             : 
   13218             : 
   13219             :     public:
   13220             :       void pickOutIRNodeData ( SgWriteStatement* source );
   13221             :       static void arrangeStaticDataOfEasyStorageClassesInOneBlock ( );
   13222             :       static void deleteStaticDataOfEasyStorageClasses ( );
   13223             :       static void pickOutStaticDataMembers ( );
   13224             :       static void rebuildStaticDataMembers ( );
   13225             :       static void writeEasyStorageDataToFile (std::ostream& out);
   13226             :       static void readEasyStorageDataFromFile (std::istream& in);
   13227             :       static void writeStaticDataToFile (std::ostream& out );
   13228             :       static void readStaticDataFromFile (std::istream& in );
   13229             :       friend class SgWriteStatement;
   13230             :    };
   13231             : /* #line 13232 "../../../src/frontend/SageIII//StorageClasses.h" */
   13232             : 
   13233             : 
   13234             : 
   13235             : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarStorageClassDeclatationMacros.macro" */
   13236             : /* 
   13237             :    JH (01/01/2006) ROSETTA generated class declarations for SgOpenStatementStorageClass 
   13238             :    used for the ast file IO. Do not chance by hand! 
   13239             : */
   13240           0 : class SgOpenStatementStorageClass  : public SgIOStatementStorageClass
   13241             :    {
   13242             : 
   13243             :     protected: 
   13244             : 
   13245             : 
   13246             : /* #line 13247 "../../../src/frontend/SageIII//StorageClasses.h" */
   13247             : 
   13248             :      unsigned long storageOf_file;
   13249             :      unsigned long storageOf_status;
   13250             :      unsigned long storageOf_access;
   13251             :      unsigned long storageOf_form;
   13252             :      unsigned long storageOf_recl;
   13253             :      unsigned long storageOf_blank;
   13254             :      unsigned long storageOf_position;
   13255             :      unsigned long storageOf_action;
   13256             :      unsigned long storageOf_delim;
   13257             :      unsigned long storageOf_pad;
   13258             :      unsigned long storageOf_round;
   13259             :      unsigned long storageOf_sign;
   13260             :      unsigned long storageOf_asynchronous;
   13261             : 
   13262             : 
   13263             : /* #line 10 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarStorageClassDeclatationMacros.macro" */
   13264             : 
   13265             : 
   13266             :     public:
   13267             :       void pickOutIRNodeData ( SgOpenStatement* source );
   13268             :       static void arrangeStaticDataOfEasyStorageClassesInOneBlock ( );
   13269             :       static void deleteStaticDataOfEasyStorageClasses ( );
   13270             :       static void pickOutStaticDataMembers ( );
   13271             :       static void rebuildStaticDataMembers ( );
   13272             :       static void writeEasyStorageDataToFile (std::ostream& out);
   13273             :       static void readEasyStorageDataFromFile (std::istream& in);
   13274             :       static void writeStaticDataToFile (std::ostream& out );
   13275             :       static void readStaticDataFromFile (std::istream& in );
   13276             :       friend class SgOpenStatement;
   13277             :    };
   13278             : /* #line 13279 "../../../src/frontend/SageIII//StorageClasses.h" */
   13279             : 
   13280             : 
   13281             : 
   13282             : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarStorageClassDeclatationMacros.macro" */
   13283             : /* 
   13284             :    JH (01/01/2006) ROSETTA generated class declarations for SgCloseStatementStorageClass 
   13285             :    used for the ast file IO. Do not chance by hand! 
   13286             : */
   13287           0 : class SgCloseStatementStorageClass  : public SgIOStatementStorageClass
   13288             :    {
   13289             : 
   13290             :     protected: 
   13291             : 
   13292             : 
   13293             : /* #line 13294 "../../../src/frontend/SageIII//StorageClasses.h" */
   13294             : 
   13295             :      unsigned long storageOf_status;
   13296             : 
   13297             : 
   13298             : /* #line 10 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarStorageClassDeclatationMacros.macro" */
   13299             : 
   13300             : 
   13301             :     public:
   13302             :       void pickOutIRNodeData ( SgCloseStatement* source );
   13303             :       static void arrangeStaticDataOfEasyStorageClassesInOneBlock ( );
   13304             :       static void deleteStaticDataOfEasyStorageClasses ( );
   13305             :       static void pickOutStaticDataMembers ( );
   13306             :       static void rebuildStaticDataMembers ( );
   13307             :       static void writeEasyStorageDataToFile (std::ostream& out);
   13308             :       static void readEasyStorageDataFromFile (std::istream& in);
   13309             :       static void writeStaticDataToFile (std::ostream& out );
   13310             :       static void readStaticDataFromFile (std::istream& in );
   13311             :       friend class SgCloseStatement;
   13312             :    };
   13313             : /* #line 13314 "../../../src/frontend/SageIII//StorageClasses.h" */
   13314             : 
   13315             : 
   13316             : 
   13317             : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarStorageClassDeclatationMacros.macro" */
   13318             : /* 
   13319             :    JH (01/01/2006) ROSETTA generated class declarations for SgInquireStatementStorageClass 
   13320             :    used for the ast file IO. Do not chance by hand! 
   13321             : */
   13322           0 : class SgInquireStatementStorageClass  : public SgIOStatementStorageClass
   13323             :    {
   13324             : 
   13325             :     protected: 
   13326             : 
   13327             : 
   13328             : /* #line 13329 "../../../src/frontend/SageIII//StorageClasses.h" */
   13329             : 
   13330             :      unsigned long storageOf_file;
   13331             :      unsigned long storageOf_access;
   13332             :      unsigned long storageOf_form;
   13333             :      unsigned long storageOf_recl;
   13334             :      unsigned long storageOf_blank;
   13335             :      unsigned long storageOf_exist;
   13336             :      unsigned long storageOf_opened;
   13337             :      unsigned long storageOf_number;
   13338             :      unsigned long storageOf_named;
   13339             :      unsigned long storageOf_name;
   13340             :      unsigned long storageOf_sequential;
   13341             :      unsigned long storageOf_direct;
   13342             :      unsigned long storageOf_formatted;
   13343             :      unsigned long storageOf_unformatted;
   13344             :      unsigned long storageOf_nextrec;
   13345             :      unsigned long storageOf_position;
   13346             :      unsigned long storageOf_action;
   13347             :      unsigned long storageOf_read;
   13348             :      unsigned long storageOf_write;
   13349             :      unsigned long storageOf_readwrite;
   13350             :      unsigned long storageOf_delim;
   13351             :      unsigned long storageOf_pad;
   13352             :      unsigned long storageOf_asynchronous;
   13353             :      unsigned long storageOf_decimal;
   13354             :      unsigned long storageOf_stream;
   13355             :      unsigned long storageOf_size;
   13356             :      unsigned long storageOf_pending;
   13357             :      unsigned long storageOf_iolengthExp;
   13358             : 
   13359             : 
   13360             : /* #line 10 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarStorageClassDeclatationMacros.macro" */
   13361             : 
   13362             : 
   13363             :     public:
   13364             :       void pickOutIRNodeData ( SgInquireStatement* source );
   13365             :       static void arrangeStaticDataOfEasyStorageClassesInOneBlock ( );
   13366             :       static void deleteStaticDataOfEasyStorageClasses ( );
   13367             :       static void pickOutStaticDataMembers ( );
   13368             :       static void rebuildStaticDataMembers ( );
   13369             :       static void writeEasyStorageDataToFile (std::ostream& out);
   13370             :       static void readEasyStorageDataFromFile (std::istream& in);
   13371             :       static void writeStaticDataToFile (std::ostream& out );
   13372             :       static void readStaticDataFromFile (std::istream& in );
   13373             :       friend class SgInquireStatement;
   13374             :    };
   13375             : /* #line 13376 "../../../src/frontend/SageIII//StorageClasses.h" */
   13376             : 
   13377             : 
   13378             : 
   13379             : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarStorageClassDeclatationMacros.macro" */
   13380             : /* 
   13381             :    JH (01/01/2006) ROSETTA generated class declarations for SgFlushStatementStorageClass 
   13382             :    used for the ast file IO. Do not chance by hand! 
   13383             : */
   13384           0 : class SgFlushStatementStorageClass  : public SgIOStatementStorageClass
   13385             :    {
   13386             : 
   13387             :     protected: 
   13388             : 
   13389             : 
   13390             : /* #line 13391 "../../../src/frontend/SageIII//StorageClasses.h" */
   13391             : 
   13392             : 
   13393             : 
   13394             : /* #line 10 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarStorageClassDeclatationMacros.macro" */
   13395             : 
   13396             : 
   13397             :     public:
   13398             :       void pickOutIRNodeData ( SgFlushStatement* source );
   13399             :       static void arrangeStaticDataOfEasyStorageClassesInOneBlock ( );
   13400             :       static void deleteStaticDataOfEasyStorageClasses ( );
   13401             :       static void pickOutStaticDataMembers ( );
   13402             :       static void rebuildStaticDataMembers ( );
   13403             :       static void writeEasyStorageDataToFile (std::ostream& out);
   13404             :       static void readEasyStorageDataFromFile (std::istream& in);
   13405             :       static void writeStaticDataToFile (std::ostream& out );
   13406             :       static void readStaticDataFromFile (std::istream& in );
   13407             :       friend class SgFlushStatement;
   13408             :    };
   13409             : /* #line 13410 "../../../src/frontend/SageIII//StorageClasses.h" */
   13410             : 
   13411             : 
   13412             : 
   13413             : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarStorageClassDeclatationMacros.macro" */
   13414             : /* 
   13415             :    JH (01/01/2006) ROSETTA generated class declarations for SgBackspaceStatementStorageClass 
   13416             :    used for the ast file IO. Do not chance by hand! 
   13417             : */
   13418           0 : class SgBackspaceStatementStorageClass  : public SgIOStatementStorageClass
   13419             :    {
   13420             : 
   13421             :     protected: 
   13422             : 
   13423             : 
   13424             : /* #line 13425 "../../../src/frontend/SageIII//StorageClasses.h" */
   13425             : 
   13426             : 
   13427             : 
   13428             : /* #line 10 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarStorageClassDeclatationMacros.macro" */
   13429             : 
   13430             : 
   13431             :     public:
   13432             :       void pickOutIRNodeData ( SgBackspaceStatement* source );
   13433             :       static void arrangeStaticDataOfEasyStorageClassesInOneBlock ( );
   13434             :       static void deleteStaticDataOfEasyStorageClasses ( );
   13435             :       static void pickOutStaticDataMembers ( );
   13436             :       static void rebuildStaticDataMembers ( );
   13437             :       static void writeEasyStorageDataToFile (std::ostream& out);
   13438             :       static void readEasyStorageDataFromFile (std::istream& in);
   13439             :       static void writeStaticDataToFile (std::ostream& out );
   13440             :       static void readStaticDataFromFile (std::istream& in );
   13441             :       friend class SgBackspaceStatement;
   13442             :    };
   13443             : /* #line 13444 "../../../src/frontend/SageIII//StorageClasses.h" */
   13444             : 
   13445             : 
   13446             : 
   13447             : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarStorageClassDeclatationMacros.macro" */
   13448             : /* 
   13449             :    JH (01/01/2006) ROSETTA generated class declarations for SgRewindStatementStorageClass 
   13450             :    used for the ast file IO. Do not chance by hand! 
   13451             : */
   13452           0 : class SgRewindStatementStorageClass  : public SgIOStatementStorageClass
   13453             :    {
   13454             : 
   13455             :     protected: 
   13456             : 
   13457             : 
   13458             : /* #line 13459 "../../../src/frontend/SageIII//StorageClasses.h" */
   13459             : 
   13460             : 
   13461             : 
   13462             : /* #line 10 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarStorageClassDeclatationMacros.macro" */
   13463             : 
   13464             : 
   13465             :     public:
   13466             :       void pickOutIRNodeData ( SgRewindStatement* source );
   13467             :       static void arrangeStaticDataOfEasyStorageClassesInOneBlock ( );
   13468             :       static void deleteStaticDataOfEasyStorageClasses ( );
   13469             :       static void pickOutStaticDataMembers ( );
   13470             :       static void rebuildStaticDataMembers ( );
   13471             :       static void writeEasyStorageDataToFile (std::ostream& out);
   13472             :       static void readEasyStorageDataFromFile (std::istream& in);
   13473             :       static void writeStaticDataToFile (std::ostream& out );
   13474             :       static void readStaticDataFromFile (std::istream& in );
   13475             :       friend class SgRewindStatement;
   13476             :    };
   13477             : /* #line 13478 "../../../src/frontend/SageIII//StorageClasses.h" */
   13478             : 
   13479             : 
   13480             : 
   13481             : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarStorageClassDeclatationMacros.macro" */
   13482             : /* 
   13483             :    JH (01/01/2006) ROSETTA generated class declarations for SgEndfileStatementStorageClass 
   13484             :    used for the ast file IO. Do not chance by hand! 
   13485             : */
   13486           0 : class SgEndfileStatementStorageClass  : public SgIOStatementStorageClass
   13487             :    {
   13488             : 
   13489             :     protected: 
   13490             : 
   13491             : 
   13492             : /* #line 13493 "../../../src/frontend/SageIII//StorageClasses.h" */
   13493             : 
   13494             : 
   13495             : 
   13496             : /* #line 10 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarStorageClassDeclatationMacros.macro" */
   13497             : 
   13498             : 
   13499             :     public:
   13500             :       void pickOutIRNodeData ( SgEndfileStatement* source );
   13501             :       static void arrangeStaticDataOfEasyStorageClassesInOneBlock ( );
   13502             :       static void deleteStaticDataOfEasyStorageClasses ( );
   13503             :       static void pickOutStaticDataMembers ( );
   13504             :       static void rebuildStaticDataMembers ( );
   13505             :       static void writeEasyStorageDataToFile (std::ostream& out);
   13506             :       static void readEasyStorageDataFromFile (std::istream& in);
   13507             :       static void writeStaticDataToFile (std::ostream& out );
   13508             :       static void readStaticDataFromFile (std::istream& in );
   13509             :       friend class SgEndfileStatement;
   13510             :    };
   13511             : /* #line 13512 "../../../src/frontend/SageIII//StorageClasses.h" */
   13512             : 
   13513             : 
   13514             : 
   13515             : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarStorageClassDeclatationMacros.macro" */
   13516             : /* 
   13517             :    JH (01/01/2006) ROSETTA generated class declarations for SgWaitStatementStorageClass 
   13518             :    used for the ast file IO. Do not chance by hand! 
   13519             : */
   13520           0 : class SgWaitStatementStorageClass  : public SgIOStatementStorageClass
   13521             :    {
   13522             : 
   13523             :     protected: 
   13524             : 
   13525             : 
   13526             : /* #line 13527 "../../../src/frontend/SageIII//StorageClasses.h" */
   13527             : 
   13528             : 
   13529             : 
   13530             : /* #line 10 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarStorageClassDeclatationMacros.macro" */
   13531             : 
   13532             : 
   13533             :     public:
   13534             :       void pickOutIRNodeData ( SgWaitStatement* source );
   13535             :       static void arrangeStaticDataOfEasyStorageClassesInOneBlock ( );
   13536             :       static void deleteStaticDataOfEasyStorageClasses ( );
   13537             :       static void pickOutStaticDataMembers ( );
   13538             :       static void rebuildStaticDataMembers ( );
   13539             :       static void writeEasyStorageDataToFile (std::ostream& out);
   13540             :       static void readEasyStorageDataFromFile (std::istream& in);
   13541             :       static void writeStaticDataToFile (std::ostream& out );
   13542             :       static void readStaticDataFromFile (std::istream& in );
   13543             :       friend class SgWaitStatement;
   13544             :    };
   13545             : /* #line 13546 "../../../src/frontend/SageIII//StorageClasses.h" */
   13546             : 
   13547             : 
   13548             : 
   13549             : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarStorageClassDeclatationMacros.macro" */
   13550             : /* 
   13551             :    JH (01/01/2006) ROSETTA generated class declarations for SgWhereStatementStorageClass 
   13552             :    used for the ast file IO. Do not chance by hand! 
   13553             : */
   13554           0 : class SgWhereStatementStorageClass  : public SgStatementStorageClass
   13555             :    {
   13556             : 
   13557             :     protected: 
   13558             : 
   13559             : 
   13560             : /* #line 13561 "../../../src/frontend/SageIII//StorageClasses.h" */
   13561             : 
   13562             :      unsigned long storageOf_condition;
   13563             :      unsigned long storageOf_body;
   13564             :      unsigned long storageOf_elsewhere;
   13565             :      unsigned long storageOf_end_numeric_label;
   13566             :        EasyStorage < std::string > storageOf_string_label;
   13567             :       bool storageOf_has_end_statement;
   13568             : 
   13569             : 
   13570             : /* #line 10 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarStorageClassDeclatationMacros.macro" */
   13571             : 
   13572             : 
   13573             :     public:
   13574             :       void pickOutIRNodeData ( SgWhereStatement* source );
   13575             :       static void arrangeStaticDataOfEasyStorageClassesInOneBlock ( );
   13576             :       static void deleteStaticDataOfEasyStorageClasses ( );
   13577             :       static void pickOutStaticDataMembers ( );
   13578             :       static void rebuildStaticDataMembers ( );
   13579             :       static void writeEasyStorageDataToFile (std::ostream& out);
   13580             :       static void readEasyStorageDataFromFile (std::istream& in);
   13581             :       static void writeStaticDataToFile (std::ostream& out );
   13582             :       static void readStaticDataFromFile (std::istream& in );
   13583             :       friend class SgWhereStatement;
   13584             :    };
   13585             : /* #line 13586 "../../../src/frontend/SageIII//StorageClasses.h" */
   13586             : 
   13587             : 
   13588             : 
   13589             : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarStorageClassDeclatationMacros.macro" */
   13590             : /* 
   13591             :    JH (01/01/2006) ROSETTA generated class declarations for SgElseWhereStatementStorageClass 
   13592             :    used for the ast file IO. Do not chance by hand! 
   13593             : */
   13594           0 : class SgElseWhereStatementStorageClass  : public SgStatementStorageClass
   13595             :    {
   13596             : 
   13597             :     protected: 
   13598             : 
   13599             : 
   13600             : /* #line 13601 "../../../src/frontend/SageIII//StorageClasses.h" */
   13601             : 
   13602             :      unsigned long storageOf_condition;
   13603             :      unsigned long storageOf_body;
   13604             :      unsigned long storageOf_elsewhere;
   13605             : 
   13606             : 
   13607             : /* #line 10 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarStorageClassDeclatationMacros.macro" */
   13608             : 
   13609             : 
   13610             :     public:
   13611             :       void pickOutIRNodeData ( SgElseWhereStatement* source );
   13612             :       static void arrangeStaticDataOfEasyStorageClassesInOneBlock ( );
   13613             :       static void deleteStaticDataOfEasyStorageClasses ( );
   13614             :       static void pickOutStaticDataMembers ( );
   13615             :       static void rebuildStaticDataMembers ( );
   13616             :       static void writeEasyStorageDataToFile (std::ostream& out);
   13617             :       static void readEasyStorageDataFromFile (std::istream& in);
   13618             :       static void writeStaticDataToFile (std::ostream& out );
   13619             :       static void readStaticDataFromFile (std::istream& in );
   13620             :       friend class SgElseWhereStatement;
   13621             :    };
   13622             : /* #line 13623 "../../../src/frontend/SageIII//StorageClasses.h" */
   13623             : 
   13624             : 
   13625             : 
   13626             : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarStorageClassDeclatationMacros.macro" */
   13627             : /* 
   13628             :    JH (01/01/2006) ROSETTA generated class declarations for SgNullifyStatementStorageClass 
   13629             :    used for the ast file IO. Do not chance by hand! 
   13630             : */
   13631           0 : class SgNullifyStatementStorageClass  : public SgStatementStorageClass
   13632             :    {
   13633             : 
   13634             :     protected: 
   13635             : 
   13636             : 
   13637             : /* #line 13638 "../../../src/frontend/SageIII//StorageClasses.h" */
   13638             : 
   13639             :      unsigned long storageOf_pointer_list;
   13640             : 
   13641             : 
   13642             : /* #line 10 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarStorageClassDeclatationMacros.macro" */
   13643             : 
   13644             : 
   13645             :     public:
   13646             :       void pickOutIRNodeData ( SgNullifyStatement* source );
   13647             :       static void arrangeStaticDataOfEasyStorageClassesInOneBlock ( );
   13648             :       static void deleteStaticDataOfEasyStorageClasses ( );
   13649             :       static void pickOutStaticDataMembers ( );
   13650             :       static void rebuildStaticDataMembers ( );
   13651             :       static void writeEasyStorageDataToFile (std::ostream& out);
   13652             :       static void readEasyStorageDataFromFile (std::istream& in);
   13653             :       static void writeStaticDataToFile (std::ostream& out );
   13654             :       static void readStaticDataFromFile (std::istream& in );
   13655             :       friend class SgNullifyStatement;
   13656             :    };
   13657             : /* #line 13658 "../../../src/frontend/SageIII//StorageClasses.h" */
   13658             : 
   13659             : 
   13660             : 
   13661             : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarStorageClassDeclatationMacros.macro" */
   13662             : /* 
   13663             :    JH (01/01/2006) ROSETTA generated class declarations for SgArithmeticIfStatementStorageClass 
   13664             :    used for the ast file IO. Do not chance by hand! 
   13665             : */
   13666           0 : class SgArithmeticIfStatementStorageClass  : public SgStatementStorageClass
   13667             :    {
   13668             : 
   13669             :     protected: 
   13670             : 
   13671             : 
   13672             : /* #line 13673 "../../../src/frontend/SageIII//StorageClasses.h" */
   13673             : 
   13674             :      unsigned long storageOf_conditional;
   13675             :      unsigned long storageOf_less_label;
   13676             :      unsigned long storageOf_equal_label;
   13677             :      unsigned long storageOf_greater_label;
   13678             : 
   13679             : 
   13680             : /* #line 10 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarStorageClassDeclatationMacros.macro" */
   13681             : 
   13682             : 
   13683             :     public:
   13684             :       void pickOutIRNodeData ( SgArithmeticIfStatement* source );
   13685             :       static void arrangeStaticDataOfEasyStorageClassesInOneBlock ( );
   13686             :       static void deleteStaticDataOfEasyStorageClasses ( );
   13687             :       static void pickOutStaticDataMembers ( );
   13688             :       static void rebuildStaticDataMembers ( );
   13689             :       static void writeEasyStorageDataToFile (std::ostream& out);
   13690             :       static void readEasyStorageDataFromFile (std::istream& in);
   13691             :       static void writeStaticDataToFile (std::ostream& out );
   13692             :       static void readStaticDataFromFile (std::istream& in );
   13693             :       friend class SgArithmeticIfStatement;
   13694             :    };
   13695             : /* #line 13696 "../../../src/frontend/SageIII//StorageClasses.h" */
   13696             : 
   13697             : 
   13698             : 
   13699             : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarStorageClassDeclatationMacros.macro" */
   13700             : /* 
   13701             :    JH (01/01/2006) ROSETTA generated class declarations for SgAssignStatementStorageClass 
   13702             :    used for the ast file IO. Do not chance by hand! 
   13703             : */
   13704           0 : class SgAssignStatementStorageClass  : public SgStatementStorageClass
   13705             :    {
   13706             : 
   13707             :     protected: 
   13708             : 
   13709             : 
   13710             : /* #line 13711 "../../../src/frontend/SageIII//StorageClasses.h" */
   13711             : 
   13712             :      unsigned long storageOf_label;
   13713             :      unsigned long storageOf_value;
   13714             : 
   13715             : 
   13716             : /* #line 10 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarStorageClassDeclatationMacros.macro" */
   13717             : 
   13718             : 
   13719             :     public:
   13720             :       void pickOutIRNodeData ( SgAssignStatement* source );
   13721             :       static void arrangeStaticDataOfEasyStorageClassesInOneBlock ( );
   13722             :       static void deleteStaticDataOfEasyStorageClasses ( );
   13723             :       static void pickOutStaticDataMembers ( );
   13724             :       static void rebuildStaticDataMembers ( );
   13725             :       static void writeEasyStorageDataToFile (std::ostream& out);
   13726             :       static void readEasyStorageDataFromFile (std::istream& in);
   13727             :       static void writeStaticDataToFile (std::ostream& out );
   13728             :       static void readStaticDataFromFile (std::istream& in );
   13729             :       friend class SgAssignStatement;
   13730             :    };
   13731             : /* #line 13732 "../../../src/frontend/SageIII//StorageClasses.h" */
   13732             : 
   13733             : 
   13734             : 
   13735             : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarStorageClassDeclatationMacros.macro" */
   13736             : /* 
   13737             :    JH (01/01/2006) ROSETTA generated class declarations for SgComputedGotoStatementStorageClass 
   13738             :    used for the ast file IO. Do not chance by hand! 
   13739             : */
   13740           0 : class SgComputedGotoStatementStorageClass  : public SgStatementStorageClass
   13741             :    {
   13742             : 
   13743             :     protected: 
   13744             : 
   13745             : 
   13746             : /* #line 13747 "../../../src/frontend/SageIII//StorageClasses.h" */
   13747             : 
   13748             :      unsigned long storageOf_labelList;
   13749             :      unsigned long storageOf_label_index;
   13750             : 
   13751             : 
   13752             : /* #line 10 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarStorageClassDeclatationMacros.macro" */
   13753             : 
   13754             : 
   13755             :     public:
   13756             :       void pickOutIRNodeData ( SgComputedGotoStatement* source );
   13757             :       static void arrangeStaticDataOfEasyStorageClassesInOneBlock ( );
   13758             :       static void deleteStaticDataOfEasyStorageClasses ( );
   13759             :       static void pickOutStaticDataMembers ( );
   13760             :       static void rebuildStaticDataMembers ( );
   13761             :       static void writeEasyStorageDataToFile (std::ostream& out);
   13762             :       static void readEasyStorageDataFromFile (std::istream& in);
   13763             :       static void writeStaticDataToFile (std::ostream& out );
   13764             :       static void readStaticDataFromFile (std::istream& in );
   13765             :       friend class SgComputedGotoStatement;
   13766             :    };
   13767             : /* #line 13768 "../../../src/frontend/SageIII//StorageClasses.h" */
   13768             : 
   13769             : 
   13770             : 
   13771             : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarStorageClassDeclatationMacros.macro" */
   13772             : /* 
   13773             :    JH (01/01/2006) ROSETTA generated class declarations for SgAssignedGotoStatementStorageClass 
   13774             :    used for the ast file IO. Do not chance by hand! 
   13775             : */
   13776           0 : class SgAssignedGotoStatementStorageClass  : public SgStatementStorageClass
   13777             :    {
   13778             : 
   13779             :     protected: 
   13780             : 
   13781             : 
   13782             : /* #line 13783 "../../../src/frontend/SageIII//StorageClasses.h" */
   13783             : 
   13784             :      unsigned long storageOf_targets;
   13785             : 
   13786             : 
   13787             : /* #line 10 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarStorageClassDeclatationMacros.macro" */
   13788             : 
   13789             : 
   13790             :     public:
   13791             :       void pickOutIRNodeData ( SgAssignedGotoStatement* source );
   13792             :       static void arrangeStaticDataOfEasyStorageClassesInOneBlock ( );
   13793             :       static void deleteStaticDataOfEasyStorageClasses ( );
   13794             :       static void pickOutStaticDataMembers ( );
   13795             :       static void rebuildStaticDataMembers ( );
   13796             :       static void writeEasyStorageDataToFile (std::ostream& out);
   13797             :       static void readEasyStorageDataFromFile (std::istream& in);
   13798             :       static void writeStaticDataToFile (std::ostream& out );
   13799             :       static void readStaticDataFromFile (std::istream& in );
   13800             :       friend class SgAssignedGotoStatement;
   13801             :    };
   13802             : /* #line 13803 "../../../src/frontend/SageIII//StorageClasses.h" */
   13803             : 
   13804             : 
   13805             : 
   13806             : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarStorageClassDeclatationMacros.macro" */
   13807             : /* 
   13808             :    JH (01/01/2006) ROSETTA generated class declarations for SgAllocateStatementStorageClass 
   13809             :    used for the ast file IO. Do not chance by hand! 
   13810             : */
   13811           0 : class SgAllocateStatementStorageClass  : public SgStatementStorageClass
   13812             :    {
   13813             : 
   13814             :     protected: 
   13815             : 
   13816             : 
   13817             : /* #line 13818 "../../../src/frontend/SageIII//StorageClasses.h" */
   13818             : 
   13819             :      unsigned long storageOf_expr_list;
   13820             :      unsigned long storageOf_stat_expression;
   13821             :      unsigned long storageOf_errmsg_expression;
   13822             :      unsigned long storageOf_source_expression;
   13823             : 
   13824             : 
   13825             : /* #line 10 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarStorageClassDeclatationMacros.macro" */
   13826             : 
   13827             : 
   13828             :     public:
   13829             :       void pickOutIRNodeData ( SgAllocateStatement* source );
   13830             :       static void arrangeStaticDataOfEasyStorageClassesInOneBlock ( );
   13831             :       static void deleteStaticDataOfEasyStorageClasses ( );
   13832             :       static void pickOutStaticDataMembers ( );
   13833             :       static void rebuildStaticDataMembers ( );
   13834             :       static void writeEasyStorageDataToFile (std::ostream& out);
   13835             :       static void readEasyStorageDataFromFile (std::istream& in);
   13836             :       static void writeStaticDataToFile (std::ostream& out );
   13837             :       static void readStaticDataFromFile (std::istream& in );
   13838             :       friend class SgAllocateStatement;
   13839             :    };
   13840             : /* #line 13841 "../../../src/frontend/SageIII//StorageClasses.h" */
   13841             : 
   13842             : 
   13843             : 
   13844             : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarStorageClassDeclatationMacros.macro" */
   13845             : /* 
   13846             :    JH (01/01/2006) ROSETTA generated class declarations for SgDeallocateStatementStorageClass 
   13847             :    used for the ast file IO. Do not chance by hand! 
   13848             : */
   13849           0 : class SgDeallocateStatementStorageClass  : public SgStatementStorageClass
   13850             :    {
   13851             : 
   13852             :     protected: 
   13853             : 
   13854             : 
   13855             : /* #line 13856 "../../../src/frontend/SageIII//StorageClasses.h" */
   13856             : 
   13857             :      unsigned long storageOf_expr_list;
   13858             :      unsigned long storageOf_stat_expression;
   13859             :      unsigned long storageOf_errmsg_expression;
   13860             : 
   13861             : 
   13862             : /* #line 10 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarStorageClassDeclatationMacros.macro" */
   13863             : 
   13864             : 
   13865             :     public:
   13866             :       void pickOutIRNodeData ( SgDeallocateStatement* source );
   13867             :       static void arrangeStaticDataOfEasyStorageClassesInOneBlock ( );
   13868             :       static void deleteStaticDataOfEasyStorageClasses ( );
   13869             :       static void pickOutStaticDataMembers ( );
   13870             :       static void rebuildStaticDataMembers ( );
   13871             :       static void writeEasyStorageDataToFile (std::ostream& out);
   13872             :       static void readEasyStorageDataFromFile (std::istream& in);
   13873             :       static void writeStaticDataToFile (std::ostream& out );
   13874             :       static void readStaticDataFromFile (std::istream& in );
   13875             :       friend class SgDeallocateStatement;
   13876             :    };
   13877             : /* #line 13878 "../../../src/frontend/SageIII//StorageClasses.h" */
   13878             : 
   13879             : 
   13880             : 
   13881             : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarStorageClassDeclatationMacros.macro" */
   13882             : /* 
   13883             :    JH (01/01/2006) ROSETTA generated class declarations for SgUpcNotifyStatementStorageClass 
   13884             :    used for the ast file IO. Do not chance by hand! 
   13885             : */
   13886           0 : class SgUpcNotifyStatementStorageClass  : public SgStatementStorageClass
   13887             :    {
   13888             : 
   13889             :     protected: 
   13890             : 
   13891             : 
   13892             : /* #line 13893 "../../../src/frontend/SageIII//StorageClasses.h" */
   13893             : 
   13894             :      unsigned long storageOf_notify_expression;
   13895             : 
   13896             : 
   13897             : /* #line 10 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarStorageClassDeclatationMacros.macro" */
   13898             : 
   13899             : 
   13900             :     public:
   13901             :       void pickOutIRNodeData ( SgUpcNotifyStatement* source );
   13902             :       static void arrangeStaticDataOfEasyStorageClassesInOneBlock ( );
   13903             :       static void deleteStaticDataOfEasyStorageClasses ( );
   13904             :       static void pickOutStaticDataMembers ( );
   13905             :       static void rebuildStaticDataMembers ( );
   13906             :       static void writeEasyStorageDataToFile (std::ostream& out);
   13907             :       static void readEasyStorageDataFromFile (std::istream& in);
   13908             :       static void writeStaticDataToFile (std::ostream& out );
   13909             :       static void readStaticDataFromFile (std::istream& in );
   13910             :       friend class SgUpcNotifyStatement;
   13911             :    };
   13912             : /* #line 13913 "../../../src/frontend/SageIII//StorageClasses.h" */
   13913             : 
   13914             : 
   13915             : 
   13916             : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarStorageClassDeclatationMacros.macro" */
   13917             : /* 
   13918             :    JH (01/01/2006) ROSETTA generated class declarations for SgUpcWaitStatementStorageClass 
   13919             :    used for the ast file IO. Do not chance by hand! 
   13920             : */
   13921           0 : class SgUpcWaitStatementStorageClass  : public SgStatementStorageClass
   13922             :    {
   13923             : 
   13924             :     protected: 
   13925             : 
   13926             : 
   13927             : /* #line 13928 "../../../src/frontend/SageIII//StorageClasses.h" */
   13928             : 
   13929             :      unsigned long storageOf_wait_expression;
   13930             : 
   13931             : 
   13932             : /* #line 10 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarStorageClassDeclatationMacros.macro" */
   13933             : 
   13934             : 
   13935             :     public:
   13936             :       void pickOutIRNodeData ( SgUpcWaitStatement* source );
   13937             :       static void arrangeStaticDataOfEasyStorageClassesInOneBlock ( );
   13938             :       static void deleteStaticDataOfEasyStorageClasses ( );
   13939             :       static void pickOutStaticDataMembers ( );
   13940             :       static void rebuildStaticDataMembers ( );
   13941             :       static void writeEasyStorageDataToFile (std::ostream& out);
   13942             :       static void readEasyStorageDataFromFile (std::istream& in);
   13943             :       static void writeStaticDataToFile (std::ostream& out );
   13944             :       static void readStaticDataFromFile (std::istream& in );
   13945             :       friend class SgUpcWaitStatement;
   13946             :    };
   13947             : /* #line 13948 "../../../src/frontend/SageIII//StorageClasses.h" */
   13948             : 
   13949             : 
   13950             : 
   13951             : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarStorageClassDeclatationMacros.macro" */
   13952             : /* 
   13953             :    JH (01/01/2006) ROSETTA generated class declarations for SgUpcBarrierStatementStorageClass 
   13954             :    used for the ast file IO. Do not chance by hand! 
   13955             : */
   13956           0 : class SgUpcBarrierStatementStorageClass  : public SgStatementStorageClass
   13957             :    {
   13958             : 
   13959             :     protected: 
   13960             : 
   13961             : 
   13962             : /* #line 13963 "../../../src/frontend/SageIII//StorageClasses.h" */
   13963             : 
   13964             :      unsigned long storageOf_barrier_expression;
   13965             : 
   13966             : 
   13967             : /* #line 10 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarStorageClassDeclatationMacros.macro" */
   13968             : 
   13969             : 
   13970             :     public:
   13971             :       void pickOutIRNodeData ( SgUpcBarrierStatement* source );
   13972             :       static void arrangeStaticDataOfEasyStorageClassesInOneBlock ( );
   13973             :       static void deleteStaticDataOfEasyStorageClasses ( );
   13974             :       static void pickOutStaticDataMembers ( );
   13975             :       static void rebuildStaticDataMembers ( );
   13976             :       static void writeEasyStorageDataToFile (std::ostream& out);
   13977             :       static void readEasyStorageDataFromFile (std::istream& in);
   13978             :       static void writeStaticDataToFile (std::ostream& out );
   13979             :       static void readStaticDataFromFile (std::istream& in );
   13980             :       friend class SgUpcBarrierStatement;
   13981             :    };
   13982             : /* #line 13983 "../../../src/frontend/SageIII//StorageClasses.h" */
   13983             : 
   13984             : 
   13985             : 
   13986             : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarStorageClassDeclatationMacros.macro" */
   13987             : /* 
   13988             :    JH (01/01/2006) ROSETTA generated class declarations for SgUpcFenceStatementStorageClass 
   13989             :    used for the ast file IO. Do not chance by hand! 
   13990             : */
   13991           0 : class SgUpcFenceStatementStorageClass  : public SgStatementStorageClass
   13992             :    {
   13993             : 
   13994             :     protected: 
   13995             : 
   13996             : 
   13997             : /* #line 13998 "../../../src/frontend/SageIII//StorageClasses.h" */
   13998             : 
   13999             : 
   14000             : 
   14001             : /* #line 10 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarStorageClassDeclatationMacros.macro" */
   14002             : 
   14003             : 
   14004             :     public:
   14005             :       void pickOutIRNodeData ( SgUpcFenceStatement* source );
   14006             :       static void arrangeStaticDataOfEasyStorageClassesInOneBlock ( );
   14007             :       static void deleteStaticDataOfEasyStorageClasses ( );
   14008             :       static void pickOutStaticDataMembers ( );
   14009             :       static void rebuildStaticDataMembers ( );
   14010             :       static void writeEasyStorageDataToFile (std::ostream& out);
   14011             :       static void readEasyStorageDataFromFile (std::istream& in);
   14012             :       static void writeStaticDataToFile (std::ostream& out );
   14013             :       static void readStaticDataFromFile (std::istream& in );
   14014             :       friend class SgUpcFenceStatement;
   14015             :    };
   14016             : /* #line 14017 "../../../src/frontend/SageIII//StorageClasses.h" */
   14017             : 
   14018             : 
   14019             : 
   14020             : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarStorageClassDeclatationMacros.macro" */
   14021             : /* 
   14022             :    JH (01/01/2006) ROSETTA generated class declarations for SgUpirBaseStatementStorageClass 
   14023             :    used for the ast file IO. Do not chance by hand! 
   14024             : */
   14025           0 : class SgUpirBaseStatementStorageClass  : public SgStatementStorageClass
   14026             :    {
   14027             : 
   14028             :     protected: 
   14029             : 
   14030             : 
   14031             : /* #line 14032 "../../../src/frontend/SageIII//StorageClasses.h" */
   14032             : 
   14033             :      unsigned long storageOf_upir_parent;
   14034             :        EasyStorage < SgStatementPtrList > storageOf_upir_children;
   14035             : 
   14036             : 
   14037             : /* #line 10 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarStorageClassDeclatationMacros.macro" */
   14038             : 
   14039             : 
   14040             :     public:
   14041             :       void pickOutIRNodeData ( SgUpirBaseStatement* source );
   14042             :       static void arrangeStaticDataOfEasyStorageClassesInOneBlock ( );
   14043             :       static void deleteStaticDataOfEasyStorageClasses ( );
   14044             :       static void pickOutStaticDataMembers ( );
   14045             :       static void rebuildStaticDataMembers ( );
   14046             :       static void writeEasyStorageDataToFile (std::ostream& out);
   14047             :       static void readEasyStorageDataFromFile (std::istream& in);
   14048             :       static void writeStaticDataToFile (std::ostream& out );
   14049             :       static void readStaticDataFromFile (std::istream& in );
   14050             :       friend class SgUpirBaseStatement;
   14051             :    };
   14052             : /* #line 14053 "../../../src/frontend/SageIII//StorageClasses.h" */
   14053             : 
   14054             : 
   14055             : 
   14056             : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarStorageClassDeclatationMacros.macro" */
   14057             : /* 
   14058             :    JH (01/01/2006) ROSETTA generated class declarations for SgOmpTaskyieldStatementStorageClass 
   14059             :    used for the ast file IO. Do not chance by hand! 
   14060             : */
   14061           0 : class SgOmpTaskyieldStatementStorageClass  : public SgUpirBaseStatementStorageClass
   14062             :    {
   14063             : 
   14064             :     protected: 
   14065             : 
   14066             : 
   14067             : /* #line 14068 "../../../src/frontend/SageIII//StorageClasses.h" */
   14068             : 
   14069             : 
   14070             : 
   14071             : /* #line 10 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarStorageClassDeclatationMacros.macro" */
   14072             : 
   14073             : 
   14074             :     public:
   14075             :       void pickOutIRNodeData ( SgOmpTaskyieldStatement* source );
   14076             :       static void arrangeStaticDataOfEasyStorageClassesInOneBlock ( );
   14077             :       static void deleteStaticDataOfEasyStorageClasses ( );
   14078             :       static void pickOutStaticDataMembers ( );
   14079             :       static void rebuildStaticDataMembers ( );
   14080             :       static void writeEasyStorageDataToFile (std::ostream& out);
   14081             :       static void readEasyStorageDataFromFile (std::istream& in);
   14082             :       static void writeStaticDataToFile (std::ostream& out );
   14083             :       static void readStaticDataFromFile (std::istream& in );
   14084             :       friend class SgOmpTaskyieldStatement;
   14085             :    };
   14086             : /* #line 14087 "../../../src/frontend/SageIII//StorageClasses.h" */
   14087             : 
   14088             : 
   14089             : 
   14090             : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarStorageClassDeclatationMacros.macro" */
   14091             : /* 
   14092             :    JH (01/01/2006) ROSETTA generated class declarations for SgOmpBarrierStatementStorageClass 
   14093             :    used for the ast file IO. Do not chance by hand! 
   14094             : */
   14095           0 : class SgOmpBarrierStatementStorageClass  : public SgUpirBaseStatementStorageClass
   14096             :    {
   14097             : 
   14098             :     protected: 
   14099             : 
   14100             : 
   14101             : /* #line 14102 "../../../src/frontend/SageIII//StorageClasses.h" */
   14102             : 
   14103             : 
   14104             : 
   14105             : /* #line 10 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarStorageClassDeclatationMacros.macro" */
   14106             : 
   14107             : 
   14108             :     public:
   14109             :       void pickOutIRNodeData ( SgOmpBarrierStatement* source );
   14110             :       static void arrangeStaticDataOfEasyStorageClassesInOneBlock ( );
   14111             :       static void deleteStaticDataOfEasyStorageClasses ( );
   14112             :       static void pickOutStaticDataMembers ( );
   14113             :       static void rebuildStaticDataMembers ( );
   14114             :       static void writeEasyStorageDataToFile (std::ostream& out);
   14115             :       static void readEasyStorageDataFromFile (std::istream& in);
   14116             :       static void writeStaticDataToFile (std::ostream& out );
   14117             :       static void readStaticDataFromFile (std::istream& in );
   14118             :       friend class SgOmpBarrierStatement;
   14119             :    };
   14120             : /* #line 14121 "../../../src/frontend/SageIII//StorageClasses.h" */
   14121             : 
   14122             : 
   14123             : 
   14124             : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarStorageClassDeclatationMacros.macro" */
   14125             : /* 
   14126             :    JH (01/01/2006) ROSETTA generated class declarations for SgUpirBodyStatementStorageClass 
   14127             :    used for the ast file IO. Do not chance by hand! 
   14128             : */
   14129           0 : class SgUpirBodyStatementStorageClass  : public SgUpirBaseStatementStorageClass
   14130             :    {
   14131             : 
   14132             :     protected: 
   14133             : 
   14134             : 
   14135             : /* #line 14136 "../../../src/frontend/SageIII//StorageClasses.h" */
   14136             : 
   14137             :      unsigned long storageOf_body;
   14138             : 
   14139             : 
   14140             : /* #line 10 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarStorageClassDeclatationMacros.macro" */
   14141             : 
   14142             : 
   14143             :     public:
   14144             :       void pickOutIRNodeData ( SgUpirBodyStatement* source );
   14145             :       static void arrangeStaticDataOfEasyStorageClassesInOneBlock ( );
   14146             :       static void deleteStaticDataOfEasyStorageClasses ( );
   14147             :       static void pickOutStaticDataMembers ( );
   14148             :       static void rebuildStaticDataMembers ( );
   14149             :       static void writeEasyStorageDataToFile (std::ostream& out);
   14150             :       static void readEasyStorageDataFromFile (std::istream& in);
   14151             :       static void writeStaticDataToFile (std::ostream& out );
   14152             :       static void readStaticDataFromFile (std::istream& in );
   14153             :       friend class SgUpirBodyStatement;
   14154             :    };
   14155             : /* #line 14156 "../../../src/frontend/SageIII//StorageClasses.h" */
   14156             : 
   14157             : 
   14158             : 
   14159             : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarStorageClassDeclatationMacros.macro" */
   14160             : /* 
   14161             :    JH (01/01/2006) ROSETTA generated class declarations for SgOmpMasterStatementStorageClass 
   14162             :    used for the ast file IO. Do not chance by hand! 
   14163             : */
   14164           0 : class SgOmpMasterStatementStorageClass  : public SgUpirBodyStatementStorageClass
   14165             :    {
   14166             : 
   14167             :     protected: 
   14168             : 
   14169             : 
   14170             : /* #line 14171 "../../../src/frontend/SageIII//StorageClasses.h" */
   14171             : 
   14172             : 
   14173             : 
   14174             : /* #line 10 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarStorageClassDeclatationMacros.macro" */
   14175             : 
   14176             : 
   14177             :     public:
   14178             :       void pickOutIRNodeData ( SgOmpMasterStatement* source );
   14179             :       static void arrangeStaticDataOfEasyStorageClassesInOneBlock ( );
   14180             :       static void deleteStaticDataOfEasyStorageClasses ( );
   14181             :       static void pickOutStaticDataMembers ( );
   14182             :       static void rebuildStaticDataMembers ( );
   14183             :       static void writeEasyStorageDataToFile (std::ostream& out);
   14184             :       static void readEasyStorageDataFromFile (std::istream& in);
   14185             :       static void writeStaticDataToFile (std::ostream& out );
   14186             :       static void readStaticDataFromFile (std::istream& in );
   14187             :       friend class SgOmpMasterStatement;
   14188             :    };
   14189             : /* #line 14190 "../../../src/frontend/SageIII//StorageClasses.h" */
   14190             : 
   14191             : 
   14192             : 
   14193             : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarStorageClassDeclatationMacros.macro" */
   14194             : /* 
   14195             :    JH (01/01/2006) ROSETTA generated class declarations for SgOmpSectionStatementStorageClass 
   14196             :    used for the ast file IO. Do not chance by hand! 
   14197             : */
   14198           0 : class SgOmpSectionStatementStorageClass  : public SgUpirBodyStatementStorageClass
   14199             :    {
   14200             : 
   14201             :     protected: 
   14202             : 
   14203             : 
   14204             : /* #line 14205 "../../../src/frontend/SageIII//StorageClasses.h" */
   14205             : 
   14206             : 
   14207             : 
   14208             : /* #line 10 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarStorageClassDeclatationMacros.macro" */
   14209             : 
   14210             : 
   14211             :     public:
   14212             :       void pickOutIRNodeData ( SgOmpSectionStatement* source );
   14213             :       static void arrangeStaticDataOfEasyStorageClassesInOneBlock ( );
   14214             :       static void deleteStaticDataOfEasyStorageClasses ( );
   14215             :       static void pickOutStaticDataMembers ( );
   14216             :       static void rebuildStaticDataMembers ( );
   14217             :       static void writeEasyStorageDataToFile (std::ostream& out);
   14218             :       static void readEasyStorageDataFromFile (std::istream& in);
   14219             :       static void writeStaticDataToFile (std::ostream& out );
   14220             :       static void readStaticDataFromFile (std::istream& in );
   14221             :       friend class SgOmpSectionStatement;
   14222             :    };
   14223             : /* #line 14224 "../../../src/frontend/SageIII//StorageClasses.h" */
   14224             : 
   14225             : 
   14226             : 
   14227             : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarStorageClassDeclatationMacros.macro" */
   14228             : /* 
   14229             :    JH (01/01/2006) ROSETTA generated class declarations for SgOmpWorkshareStatementStorageClass 
   14230             :    used for the ast file IO. Do not chance by hand! 
   14231             : */
   14232           0 : class SgOmpWorkshareStatementStorageClass  : public SgUpirBodyStatementStorageClass
   14233             :    {
   14234             : 
   14235             :     protected: 
   14236             : 
   14237             : 
   14238             : /* #line 14239 "../../../src/frontend/SageIII//StorageClasses.h" */
   14239             : 
   14240             : 
   14241             : 
   14242             : /* #line 10 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarStorageClassDeclatationMacros.macro" */
   14243             : 
   14244             : 
   14245             :     public:
   14246             :       void pickOutIRNodeData ( SgOmpWorkshareStatement* source );
   14247             :       static void arrangeStaticDataOfEasyStorageClassesInOneBlock ( );
   14248             :       static void deleteStaticDataOfEasyStorageClasses ( );
   14249             :       static void pickOutStaticDataMembers ( );
   14250             :       static void rebuildStaticDataMembers ( );
   14251             :       static void writeEasyStorageDataToFile (std::ostream& out);
   14252             :       static void readEasyStorageDataFromFile (std::istream& in);
   14253             :       static void writeStaticDataToFile (std::ostream& out );
   14254             :       static void readStaticDataFromFile (std::istream& in );
   14255             :       friend class SgOmpWorkshareStatement;
   14256             :    };
   14257             : /* #line 14258 "../../../src/frontend/SageIII//StorageClasses.h" */
   14258             : 
   14259             : 
   14260             : 
   14261             : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarStorageClassDeclatationMacros.macro" */
   14262             : /* 
   14263             :    JH (01/01/2006) ROSETTA generated class declarations for SgUpirFieldBodyStatementStorageClass 
   14264             :    used for the ast file IO. Do not chance by hand! 
   14265             : */
   14266           0 : class SgUpirFieldBodyStatementStorageClass  : public SgUpirBodyStatementStorageClass
   14267             :    {
   14268             : 
   14269             :     protected: 
   14270             : 
   14271             : 
   14272             : /* #line 14273 "../../../src/frontend/SageIII//StorageClasses.h" */
   14273             : 
   14274             :        EasyStorage < SgOmpClausePtrList > storageOf_clauses;
   14275             : 
   14276             : 
   14277             : /* #line 10 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarStorageClassDeclatationMacros.macro" */
   14278             : 
   14279             : 
   14280             :     public:
   14281             :       void pickOutIRNodeData ( SgUpirFieldBodyStatement* source );
   14282             :       static void arrangeStaticDataOfEasyStorageClassesInOneBlock ( );
   14283             :       static void deleteStaticDataOfEasyStorageClasses ( );
   14284             :       static void pickOutStaticDataMembers ( );
   14285             :       static void rebuildStaticDataMembers ( );
   14286             :       static void writeEasyStorageDataToFile (std::ostream& out);
   14287             :       static void readEasyStorageDataFromFile (std::istream& in);
   14288             :       static void writeStaticDataToFile (std::ostream& out );
   14289             :       static void readStaticDataFromFile (std::istream& in );
   14290             :       friend class SgUpirFieldBodyStatement;
   14291             :    };
   14292             : /* #line 14293 "../../../src/frontend/SageIII//StorageClasses.h" */
   14293             : 
   14294             : 
   14295             : 
   14296             : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarStorageClassDeclatationMacros.macro" */
   14297             : /* 
   14298             :    JH (01/01/2006) ROSETTA generated class declarations for SgUpirSpmdStatementStorageClass 
   14299             :    used for the ast file IO. Do not chance by hand! 
   14300             : */
   14301           0 : class SgUpirSpmdStatementStorageClass  : public SgUpirFieldBodyStatementStorageClass
   14302             :    {
   14303             : 
   14304             :     protected: 
   14305             : 
   14306             : 
   14307             : /* #line 14308 "../../../src/frontend/SageIII//StorageClasses.h" */
   14308             : 
   14309             : 
   14310             : 
   14311             : /* #line 10 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarStorageClassDeclatationMacros.macro" */
   14312             : 
   14313             : 
   14314             :     public:
   14315             :       void pickOutIRNodeData ( SgUpirSpmdStatement* source );
   14316             :       static void arrangeStaticDataOfEasyStorageClassesInOneBlock ( );
   14317             :       static void deleteStaticDataOfEasyStorageClasses ( );
   14318             :       static void pickOutStaticDataMembers ( );
   14319             :       static void rebuildStaticDataMembers ( );
   14320             :       static void writeEasyStorageDataToFile (std::ostream& out);
   14321             :       static void readEasyStorageDataFromFile (std::istream& in);
   14322             :       static void writeStaticDataToFile (std::ostream& out );
   14323             :       static void readStaticDataFromFile (std::istream& in );
   14324             :       friend class SgUpirSpmdStatement;
   14325             :    };
   14326             : /* #line 14327 "../../../src/frontend/SageIII//StorageClasses.h" */
   14327             : 
   14328             : 
   14329             : 
   14330             : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarStorageClassDeclatationMacros.macro" */
   14331             : /* 
   14332             :    JH (01/01/2006) ROSETTA generated class declarations for SgOmpTeamsStatementStorageClass 
   14333             :    used for the ast file IO. Do not chance by hand! 
   14334             : */
   14335           0 : class SgOmpTeamsStatementStorageClass  : public SgUpirFieldBodyStatementStorageClass
   14336             :    {
   14337             : 
   14338             :     protected: 
   14339             : 
   14340             : 
   14341             : /* #line 14342 "../../../src/frontend/SageIII//StorageClasses.h" */
   14342             : 
   14343             : 
   14344             : 
   14345             : /* #line 10 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarStorageClassDeclatationMacros.macro" */
   14346             : 
   14347             : 
   14348             :     public:
   14349             :       void pickOutIRNodeData ( SgOmpTeamsStatement* source );
   14350             :       static void arrangeStaticDataOfEasyStorageClassesInOneBlock ( );
   14351             :       static void deleteStaticDataOfEasyStorageClasses ( );
   14352             :       static void pickOutStaticDataMembers ( );
   14353             :       static void rebuildStaticDataMembers ( );
   14354             :       static void writeEasyStorageDataToFile (std::ostream& out);
   14355             :       static void readEasyStorageDataFromFile (std::istream& in);
   14356             :       static void writeStaticDataToFile (std::ostream& out );
   14357             :       static void readStaticDataFromFile (std::istream& in );
   14358             :       friend class SgOmpTeamsStatement;
   14359             :    };
   14360             : /* #line 14361 "../../../src/frontend/SageIII//StorageClasses.h" */
   14361             : 
   14362             : 
   14363             : 
   14364             : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarStorageClassDeclatationMacros.macro" */
   14365             : /* 
   14366             :    JH (01/01/2006) ROSETTA generated class declarations for SgOmpSingleStatementStorageClass 
   14367             :    used for the ast file IO. Do not chance by hand! 
   14368             : */
   14369           0 : class SgOmpSingleStatementStorageClass  : public SgUpirFieldBodyStatementStorageClass
   14370             :    {
   14371             : 
   14372             :     protected: 
   14373             : 
   14374             : 
   14375             : /* #line 14376 "../../../src/frontend/SageIII//StorageClasses.h" */
   14376             : 
   14377             : 
   14378             : 
   14379             : /* #line 10 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarStorageClassDeclatationMacros.macro" */
   14380             : 
   14381             : 
   14382             :     public:
   14383             :       void pickOutIRNodeData ( SgOmpSingleStatement* source );
   14384             :       static void arrangeStaticDataOfEasyStorageClassesInOneBlock ( );
   14385             :       static void deleteStaticDataOfEasyStorageClasses ( );
   14386             :       static void pickOutStaticDataMembers ( );
   14387             :       static void rebuildStaticDataMembers ( );
   14388             :       static void writeEasyStorageDataToFile (std::ostream& out);
   14389             :       static void readEasyStorageDataFromFile (std::istream& in);
   14390             :       static void writeStaticDataToFile (std::ostream& out );
   14391             :       static void readStaticDataFromFile (std::istream& in );
   14392             :       friend class SgOmpSingleStatement;
   14393             :    };
   14394             : /* #line 14395 "../../../src/frontend/SageIII//StorageClasses.h" */
   14395             : 
   14396             : 
   14397             : 
   14398             : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarStorageClassDeclatationMacros.macro" */
   14399             : /* 
   14400             :    JH (01/01/2006) ROSETTA generated class declarations for SgOmpAtomicStatementStorageClass 
   14401             :    used for the ast file IO. Do not chance by hand! 
   14402             : */
   14403           0 : class SgOmpAtomicStatementStorageClass  : public SgUpirFieldBodyStatementStorageClass
   14404             :    {
   14405             : 
   14406             :     protected: 
   14407             : 
   14408             : 
   14409             : /* #line 14410 "../../../src/frontend/SageIII//StorageClasses.h" */
   14410             : 
   14411             : 
   14412             : 
   14413             : /* #line 10 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarStorageClassDeclatationMacros.macro" */
   14414             : 
   14415             : 
   14416             :     public:
   14417             :       void pickOutIRNodeData ( SgOmpAtomicStatement* source );
   14418             :       static void arrangeStaticDataOfEasyStorageClassesInOneBlock ( );
   14419             :       static void deleteStaticDataOfEasyStorageClasses ( );
   14420             :       static void pickOutStaticDataMembers ( );
   14421             :       static void rebuildStaticDataMembers ( );
   14422             :       static void writeEasyStorageDataToFile (std::ostream& out);
   14423             :       static void readEasyStorageDataFromFile (std::istream& in);
   14424             :       static void writeStaticDataToFile (std::ostream& out );
   14425             :       static void readStaticDataFromFile (std::istream& in );
   14426             :       friend class SgOmpAtomicStatement;
   14427             :    };
   14428             : /* #line 14429 "../../../src/frontend/SageIII//StorageClasses.h" */
   14429             : 
   14430             : 
   14431             : 
   14432             : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarStorageClassDeclatationMacros.macro" */
   14433             : /* 
   14434             :    JH (01/01/2006) ROSETTA generated class declarations for SgOmpScanStatementStorageClass 
   14435             :    used for the ast file IO. Do not chance by hand! 
   14436             : */
   14437           0 : class SgOmpScanStatementStorageClass  : public SgUpirFieldBodyStatementStorageClass
   14438             :    {
   14439             : 
   14440             :     protected: 
   14441             : 
   14442             : 
   14443             : /* #line 14444 "../../../src/frontend/SageIII//StorageClasses.h" */
   14444             : 
   14445             : 
   14446             : 
   14447             : /* #line 10 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarStorageClassDeclatationMacros.macro" */
   14448             : 
   14449             : 
   14450             :     public:
   14451             :       void pickOutIRNodeData ( SgOmpScanStatement* source );
   14452             :       static void arrangeStaticDataOfEasyStorageClassesInOneBlock ( );
   14453             :       static void deleteStaticDataOfEasyStorageClasses ( );
   14454             :       static void pickOutStaticDataMembers ( );
   14455             :       static void rebuildStaticDataMembers ( );
   14456             :       static void writeEasyStorageDataToFile (std::ostream& out);
   14457             :       static void readEasyStorageDataFromFile (std::istream& in);
   14458             :       static void writeStaticDataToFile (std::ostream& out );
   14459             :       static void readStaticDataFromFile (std::istream& in );
   14460             :       friend class SgOmpScanStatement;
   14461             :    };
   14462             : /* #line 14463 "../../../src/frontend/SageIII//StorageClasses.h" */
   14463             : 
   14464             : 
   14465             : 
   14466             : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarStorageClassDeclatationMacros.macro" */
   14467             : /* 
   14468             :    JH (01/01/2006) ROSETTA generated class declarations for SgOmpMetadirectiveStatementStorageClass 
   14469             :    used for the ast file IO. Do not chance by hand! 
   14470             : */
   14471           0 : class SgOmpMetadirectiveStatementStorageClass  : public SgUpirFieldBodyStatementStorageClass
   14472             :    {
   14473             : 
   14474             :     protected: 
   14475             : 
   14476             : 
   14477             : /* #line 14478 "../../../src/frontend/SageIII//StorageClasses.h" */
   14478             : 
   14479             : 
   14480             : 
   14481             : /* #line 10 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarStorageClassDeclatationMacros.macro" */
   14482             : 
   14483             : 
   14484             :     public:
   14485             :       void pickOutIRNodeData ( SgOmpMetadirectiveStatement* source );
   14486             :       static void arrangeStaticDataOfEasyStorageClassesInOneBlock ( );
   14487             :       static void deleteStaticDataOfEasyStorageClasses ( );
   14488             :       static void pickOutStaticDataMembers ( );
   14489             :       static void rebuildStaticDataMembers ( );
   14490             :       static void writeEasyStorageDataToFile (std::ostream& out);
   14491             :       static void readEasyStorageDataFromFile (std::istream& in);
   14492             :       static void writeStaticDataToFile (std::ostream& out );
   14493             :       static void readStaticDataFromFile (std::istream& in );
   14494             :       friend class SgOmpMetadirectiveStatement;
   14495             :    };
   14496             : /* #line 14497 "../../../src/frontend/SageIII//StorageClasses.h" */
   14497             : 
   14498             : 
   14499             : 
   14500             : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarStorageClassDeclatationMacros.macro" */
   14501             : /* 
   14502             :    JH (01/01/2006) ROSETTA generated class declarations for SgOmpLoopStatementStorageClass 
   14503             :    used for the ast file IO. Do not chance by hand! 
   14504             : */
   14505           0 : class SgOmpLoopStatementStorageClass  : public SgUpirFieldBodyStatementStorageClass
   14506             :    {
   14507             : 
   14508             :     protected: 
   14509             : 
   14510             : 
   14511             : /* #line 14512 "../../../src/frontend/SageIII//StorageClasses.h" */
   14512             : 
   14513             : 
   14514             : 
   14515             : /* #line 10 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarStorageClassDeclatationMacros.macro" */
   14516             : 
   14517             : 
   14518             :     public:
   14519             :       void pickOutIRNodeData ( SgOmpLoopStatement* source );
   14520             :       static void arrangeStaticDataOfEasyStorageClassesInOneBlock ( );
   14521             :       static void deleteStaticDataOfEasyStorageClasses ( );
   14522             :       static void pickOutStaticDataMembers ( );
   14523             :       static void rebuildStaticDataMembers ( );
   14524             :       static void writeEasyStorageDataToFile (std::ostream& out);
   14525             :       static void readEasyStorageDataFromFile (std::istream& in);
   14526             :       static void writeStaticDataToFile (std::ostream& out );
   14527             :       static void readStaticDataFromFile (std::istream& in );
   14528             :       friend class SgOmpLoopStatement;
   14529             :    };
   14530             : /* #line 14531 "../../../src/frontend/SageIII//StorageClasses.h" */
   14531             : 
   14532             : 
   14533             : 
   14534             : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarStorageClassDeclatationMacros.macro" */
   14535             : /* 
   14536             :    JH (01/01/2006) ROSETTA generated class declarations for SgOmpOrderedStatementStorageClass 
   14537             :    used for the ast file IO. Do not chance by hand! 
   14538             : */
   14539           0 : class SgOmpOrderedStatementStorageClass  : public SgUpirFieldBodyStatementStorageClass
   14540             :    {
   14541             : 
   14542             :     protected: 
   14543             : 
   14544             : 
   14545             : /* #line 14546 "../../../src/frontend/SageIII//StorageClasses.h" */
   14546             : 
   14547             : 
   14548             : 
   14549             : /* #line 10 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarStorageClassDeclatationMacros.macro" */
   14550             : 
   14551             : 
   14552             :     public:
   14553             :       void pickOutIRNodeData ( SgOmpOrderedStatement* source );
   14554             :       static void arrangeStaticDataOfEasyStorageClassesInOneBlock ( );
   14555             :       static void deleteStaticDataOfEasyStorageClasses ( );
   14556             :       static void pickOutStaticDataMembers ( );
   14557             :       static void rebuildStaticDataMembers ( );
   14558             :       static void writeEasyStorageDataToFile (std::ostream& out);
   14559             :       static void readEasyStorageDataFromFile (std::istream& in);
   14560             :       static void writeStaticDataToFile (std::ostream& out );
   14561             :       static void readStaticDataFromFile (std::istream& in );
   14562             :       friend class SgOmpOrderedStatement;
   14563             :    };
   14564             : /* #line 14565 "../../../src/frontend/SageIII//StorageClasses.h" */
   14565             : 
   14566             : 
   14567             : 
   14568             : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarStorageClassDeclatationMacros.macro" */
   14569             : /* 
   14570             :    JH (01/01/2006) ROSETTA generated class declarations for SgOmpTaskgroupStatementStorageClass 
   14571             :    used for the ast file IO. Do not chance by hand! 
   14572             : */
   14573           0 : class SgOmpTaskgroupStatementStorageClass  : public SgUpirFieldBodyStatementStorageClass
   14574             :    {
   14575             : 
   14576             :     protected: 
   14577             : 
   14578             : 
   14579             : /* #line 14580 "../../../src/frontend/SageIII//StorageClasses.h" */
   14580             : 
   14581             : 
   14582             : 
   14583             : /* #line 10 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarStorageClassDeclatationMacros.macro" */
   14584             : 
   14585             : 
   14586             :     public:
   14587             :       void pickOutIRNodeData ( SgOmpTaskgroupStatement* source );
   14588             :       static void arrangeStaticDataOfEasyStorageClassesInOneBlock ( );
   14589             :       static void deleteStaticDataOfEasyStorageClasses ( );
   14590             :       static void pickOutStaticDataMembers ( );
   14591             :       static void rebuildStaticDataMembers ( );
   14592             :       static void writeEasyStorageDataToFile (std::ostream& out);
   14593             :       static void readEasyStorageDataFromFile (std::istream& in);
   14594             :       static void writeStaticDataToFile (std::ostream& out );
   14595             :       static void readStaticDataFromFile (std::istream& in );
   14596             :       friend class SgOmpTaskgroupStatement;
   14597             :    };
   14598             : /* #line 14599 "../../../src/frontend/SageIII//StorageClasses.h" */
   14599             : 
   14600             : 
   14601             : 
   14602             : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarStorageClassDeclatationMacros.macro" */
   14603             : /* 
   14604             :    JH (01/01/2006) ROSETTA generated class declarations for SgOmpTaskloopStatementStorageClass 
   14605             :    used for the ast file IO. Do not chance by hand! 
   14606             : */
   14607           0 : class SgOmpTaskloopStatementStorageClass  : public SgUpirFieldBodyStatementStorageClass
   14608             :    {
   14609             : 
   14610             :     protected: 
   14611             : 
   14612             : 
   14613             : /* #line 14614 "../../../src/frontend/SageIII//StorageClasses.h" */
   14614             : 
   14615             : 
   14616             : 
   14617             : /* #line 10 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarStorageClassDeclatationMacros.macro" */
   14618             : 
   14619             : 
   14620             :     public:
   14621             :       void pickOutIRNodeData ( SgOmpTaskloopStatement* source );
   14622             :       static void arrangeStaticDataOfEasyStorageClassesInOneBlock ( );
   14623             :       static void deleteStaticDataOfEasyStorageClasses ( );
   14624             :       static void pickOutStaticDataMembers ( );
   14625             :       static void rebuildStaticDataMembers ( );
   14626             :       static void writeEasyStorageDataToFile (std::ostream& out);
   14627             :       static void readEasyStorageDataFromFile (std::istream& in);
   14628             :       static void writeStaticDataToFile (std::ostream& out );
   14629             :       static void readStaticDataFromFile (std::istream& in );
   14630             :       friend class SgOmpTaskloopStatement;
   14631             :    };
   14632             : /* #line 14633 "../../../src/frontend/SageIII//StorageClasses.h" */
   14633             : 
   14634             : 
   14635             : 
   14636             : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarStorageClassDeclatationMacros.macro" */
   14637             : /* 
   14638             :    JH (01/01/2006) ROSETTA generated class declarations for SgOmpDepobjStatementStorageClass 
   14639             :    used for the ast file IO. Do not chance by hand! 
   14640             : */
   14641           0 : class SgOmpDepobjStatementStorageClass  : public SgUpirFieldBodyStatementStorageClass
   14642             :    {
   14643             : 
   14644             :     protected: 
   14645             : 
   14646             : 
   14647             : /* #line 14648 "../../../src/frontend/SageIII//StorageClasses.h" */
   14648             : 
   14649             :       SgNameStorageClass storageOf_name;
   14650             : 
   14651             : 
   14652             : /* #line 10 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarStorageClassDeclatationMacros.macro" */
   14653             : 
   14654             : 
   14655             :     public:
   14656             :       void pickOutIRNodeData ( SgOmpDepobjStatement* source );
   14657             :       static void arrangeStaticDataOfEasyStorageClassesInOneBlock ( );
   14658             :       static void deleteStaticDataOfEasyStorageClasses ( );
   14659             :       static void pickOutStaticDataMembers ( );
   14660             :       static void rebuildStaticDataMembers ( );
   14661             :       static void writeEasyStorageDataToFile (std::ostream& out);
   14662             :       static void readEasyStorageDataFromFile (std::istream& in);
   14663             :       static void writeStaticDataToFile (std::ostream& out );
   14664             :       static void readStaticDataFromFile (std::istream& in );
   14665             :       friend class SgOmpDepobjStatement;
   14666             :    };
   14667             : /* #line 14668 "../../../src/frontend/SageIII//StorageClasses.h" */
   14668             : 
   14669             : 
   14670             : 
   14671             : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarStorageClassDeclatationMacros.macro" */
   14672             : /* 
   14673             :    JH (01/01/2006) ROSETTA generated class declarations for SgOmpTargetEnterDataStatementStorageClass 
   14674             :    used for the ast file IO. Do not chance by hand! 
   14675             : */
   14676           0 : class SgOmpTargetEnterDataStatementStorageClass  : public SgUpirFieldBodyStatementStorageClass
   14677             :    {
   14678             : 
   14679             :     protected: 
   14680             : 
   14681             : 
   14682             : /* #line 14683 "../../../src/frontend/SageIII//StorageClasses.h" */
   14683             : 
   14684             : 
   14685             : 
   14686             : /* #line 10 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarStorageClassDeclatationMacros.macro" */
   14687             : 
   14688             : 
   14689             :     public:
   14690             :       void pickOutIRNodeData ( SgOmpTargetEnterDataStatement* source );
   14691             :       static void arrangeStaticDataOfEasyStorageClassesInOneBlock ( );
   14692             :       static void deleteStaticDataOfEasyStorageClasses ( );
   14693             :       static void pickOutStaticDataMembers ( );
   14694             :       static void rebuildStaticDataMembers ( );
   14695             :       static void writeEasyStorageDataToFile (std::ostream& out);
   14696             :       static void readEasyStorageDataFromFile (std::istream& in);
   14697             :       static void writeStaticDataToFile (std::ostream& out );
   14698             :       static void readStaticDataFromFile (std::istream& in );
   14699             :       friend class SgOmpTargetEnterDataStatement;
   14700             :    };
   14701             : /* #line 14702 "../../../src/frontend/SageIII//StorageClasses.h" */
   14702             : 
   14703             : 
   14704             : 
   14705             : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarStorageClassDeclatationMacros.macro" */
   14706             : /* 
   14707             :    JH (01/01/2006) ROSETTA generated class declarations for SgOmpTargetExitDataStatementStorageClass 
   14708             :    used for the ast file IO. Do not chance by hand! 
   14709             : */
   14710           0 : class SgOmpTargetExitDataStatementStorageClass  : public SgUpirFieldBodyStatementStorageClass
   14711             :    {
   14712             : 
   14713             :     protected: 
   14714             : 
   14715             : 
   14716             : /* #line 14717 "../../../src/frontend/SageIII//StorageClasses.h" */
   14717             : 
   14718             : 
   14719             : 
   14720             : /* #line 10 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarStorageClassDeclatationMacros.macro" */
   14721             : 
   14722             : 
   14723             :     public:
   14724             :       void pickOutIRNodeData ( SgOmpTargetExitDataStatement* source );
   14725             :       static void arrangeStaticDataOfEasyStorageClassesInOneBlock ( );
   14726             :       static void deleteStaticDataOfEasyStorageClasses ( );
   14727             :       static void pickOutStaticDataMembers ( );
   14728             :       static void rebuildStaticDataMembers ( );
   14729             :       static void writeEasyStorageDataToFile (std::ostream& out);
   14730             :       static void readEasyStorageDataFromFile (std::istream& in);
   14731             :       static void writeStaticDataToFile (std::ostream& out );
   14732             :       static void readStaticDataFromFile (std::istream& in );
   14733             :       friend class SgOmpTargetExitDataStatement;
   14734             :    };
   14735             : /* #line 14736 "../../../src/frontend/SageIII//StorageClasses.h" */
   14736             : 
   14737             : 
   14738             : 
   14739             : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarStorageClassDeclatationMacros.macro" */
   14740             : /* 
   14741             :    JH (01/01/2006) ROSETTA generated class declarations for SgOmpParallelMasterStatementStorageClass 
   14742             :    used for the ast file IO. Do not chance by hand! 
   14743             : */
   14744           0 : class SgOmpParallelMasterStatementStorageClass  : public SgUpirFieldBodyStatementStorageClass
   14745             :    {
   14746             : 
   14747             :     protected: 
   14748             : 
   14749             : 
   14750             : /* #line 14751 "../../../src/frontend/SageIII//StorageClasses.h" */
   14751             : 
   14752             : 
   14753             : 
   14754             : /* #line 10 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarStorageClassDeclatationMacros.macro" */
   14755             : 
   14756             : 
   14757             :     public:
   14758             :       void pickOutIRNodeData ( SgOmpParallelMasterStatement* source );
   14759             :       static void arrangeStaticDataOfEasyStorageClassesInOneBlock ( );
   14760             :       static void deleteStaticDataOfEasyStorageClasses ( );
   14761             :       static void pickOutStaticDataMembers ( );
   14762             :       static void rebuildStaticDataMembers ( );
   14763             :       static void writeEasyStorageDataToFile (std::ostream& out);
   14764             :       static void readEasyStorageDataFromFile (std::istream& in);
   14765             :       static void writeStaticDataToFile (std::ostream& out );
   14766             :       static void readStaticDataFromFile (std::istream& in );
   14767             :       friend class SgOmpParallelMasterStatement;
   14768             :    };
   14769             : /* #line 14770 "../../../src/frontend/SageIII//StorageClasses.h" */
   14770             : 
   14771             : 
   14772             : 
   14773             : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarStorageClassDeclatationMacros.macro" */
   14774             : /* 
   14775             :    JH (01/01/2006) ROSETTA generated class declarations for SgOmpMasterTaskloopStatementStorageClass 
   14776             :    used for the ast file IO. Do not chance by hand! 
   14777             : */
   14778           0 : class SgOmpMasterTaskloopStatementStorageClass  : public SgUpirFieldBodyStatementStorageClass
   14779             :    {
   14780             : 
   14781             :     protected: 
   14782             : 
   14783             : 
   14784             : /* #line 14785 "../../../src/frontend/SageIII//StorageClasses.h" */
   14785             : 
   14786             : 
   14787             : 
   14788             : /* #line 10 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarStorageClassDeclatationMacros.macro" */
   14789             : 
   14790             : 
   14791             :     public:
   14792             :       void pickOutIRNodeData ( SgOmpMasterTaskloopStatement* source );
   14793             :       static void arrangeStaticDataOfEasyStorageClassesInOneBlock ( );
   14794             :       static void deleteStaticDataOfEasyStorageClasses ( );
   14795             :       static void pickOutStaticDataMembers ( );
   14796             :       static void rebuildStaticDataMembers ( );
   14797             :       static void writeEasyStorageDataToFile (std::ostream& out);
   14798             :       static void readEasyStorageDataFromFile (std::istream& in);
   14799             :       static void writeStaticDataToFile (std::ostream& out );
   14800             :       static void readStaticDataFromFile (std::istream& in );
   14801             :       friend class SgOmpMasterTaskloopStatement;
   14802             :    };
   14803             : /* #line 14804 "../../../src/frontend/SageIII//StorageClasses.h" */
   14804             : 
   14805             : 
   14806             : 
   14807             : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarStorageClassDeclatationMacros.macro" */
   14808             : /* 
   14809             :    JH (01/01/2006) ROSETTA generated class declarations for SgOmpTaskStatementStorageClass 
   14810             :    used for the ast file IO. Do not chance by hand! 
   14811             : */
   14812           0 : class SgOmpTaskStatementStorageClass  : public SgUpirFieldBodyStatementStorageClass
   14813             :    {
   14814             : 
   14815             :     protected: 
   14816             : 
   14817             : 
   14818             : /* #line 14819 "../../../src/frontend/SageIII//StorageClasses.h" */
   14819             : 
   14820             : 
   14821             : 
   14822             : /* #line 10 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarStorageClassDeclatationMacros.macro" */
   14823             : 
   14824             : 
   14825             :     public:
   14826             :       void pickOutIRNodeData ( SgOmpTaskStatement* source );
   14827             :       static void arrangeStaticDataOfEasyStorageClassesInOneBlock ( );
   14828             :       static void deleteStaticDataOfEasyStorageClasses ( );
   14829             :       static void pickOutStaticDataMembers ( );
   14830             :       static void rebuildStaticDataMembers ( );
   14831             :       static void writeEasyStorageDataToFile (std::ostream& out);
   14832             :       static void readEasyStorageDataFromFile (std::istream& in);
   14833             :       static void writeStaticDataToFile (std::ostream& out );
   14834             :       static void readStaticDataFromFile (std::istream& in );
   14835             :       friend class SgOmpTaskStatement;
   14836             :    };
   14837             : /* #line 14838 "../../../src/frontend/SageIII//StorageClasses.h" */
   14838             : 
   14839             : 
   14840             : 
   14841             : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarStorageClassDeclatationMacros.macro" */
   14842             : /* 
   14843             :    JH (01/01/2006) ROSETTA generated class declarations for SgOmpDoStatementStorageClass 
   14844             :    used for the ast file IO. Do not chance by hand! 
   14845             : */
   14846           0 : class SgOmpDoStatementStorageClass  : public SgUpirFieldBodyStatementStorageClass
   14847             :    {
   14848             : 
   14849             :     protected: 
   14850             : 
   14851             : 
   14852             : /* #line 14853 "../../../src/frontend/SageIII//StorageClasses.h" */
   14853             : 
   14854             : 
   14855             : 
   14856             : /* #line 10 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarStorageClassDeclatationMacros.macro" */
   14857             : 
   14858             : 
   14859             :     public:
   14860             :       void pickOutIRNodeData ( SgOmpDoStatement* source );
   14861             :       static void arrangeStaticDataOfEasyStorageClassesInOneBlock ( );
   14862             :       static void deleteStaticDataOfEasyStorageClasses ( );
   14863             :       static void pickOutStaticDataMembers ( );
   14864             :       static void rebuildStaticDataMembers ( );
   14865             :       static void writeEasyStorageDataToFile (std::ostream& out);
   14866             :       static void readEasyStorageDataFromFile (std::istream& in);
   14867             :       static void writeStaticDataToFile (std::ostream& out );
   14868             :       static void readStaticDataFromFile (std::istream& in );
   14869             :       friend class SgOmpDoStatement;
   14870             :    };
   14871             : /* #line 14872 "../../../src/frontend/SageIII//StorageClasses.h" */
   14872             : 
   14873             : 
   14874             : 
   14875             : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarStorageClassDeclatationMacros.macro" */
   14876             : /* 
   14877             :    JH (01/01/2006) ROSETTA generated class declarations for SgOmpSectionsStatementStorageClass 
   14878             :    used for the ast file IO. Do not chance by hand! 
   14879             : */
   14880           0 : class SgOmpSectionsStatementStorageClass  : public SgUpirFieldBodyStatementStorageClass
   14881             :    {
   14882             : 
   14883             :     protected: 
   14884             : 
   14885             : 
   14886             : /* #line 14887 "../../../src/frontend/SageIII//StorageClasses.h" */
   14887             : 
   14888             : 
   14889             : 
   14890             : /* #line 10 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarStorageClassDeclatationMacros.macro" */
   14891             : 
   14892             : 
   14893             :     public:
   14894             :       void pickOutIRNodeData ( SgOmpSectionsStatement* source );
   14895             :       static void arrangeStaticDataOfEasyStorageClassesInOneBlock ( );
   14896             :       static void deleteStaticDataOfEasyStorageClasses ( );
   14897             :       static void pickOutStaticDataMembers ( );
   14898             :       static void rebuildStaticDataMembers ( );
   14899             :       static void writeEasyStorageDataToFile (std::ostream& out);
   14900             :       static void readEasyStorageDataFromFile (std::istream& in);
   14901             :       static void writeStaticDataToFile (std::ostream& out );
   14902             :       static void readStaticDataFromFile (std::istream& in );
   14903             :       friend class SgOmpSectionsStatement;
   14904             :    };
   14905             : /* #line 14906 "../../../src/frontend/SageIII//StorageClasses.h" */
   14906             : 
   14907             : 
   14908             : 
   14909             : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarStorageClassDeclatationMacros.macro" */
   14910             : /* 
   14911             :    JH (01/01/2006) ROSETTA generated class declarations for SgUpirTaskStatementStorageClass 
   14912             :    used for the ast file IO. Do not chance by hand! 
   14913             : */
   14914           0 : class SgUpirTaskStatementStorageClass  : public SgUpirFieldBodyStatementStorageClass
   14915             :    {
   14916             : 
   14917             :     protected: 
   14918             : 
   14919             : 
   14920             : /* #line 14921 "../../../src/frontend/SageIII//StorageClasses.h" */
   14921             : 
   14922             : 
   14923             : 
   14924             : /* #line 10 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarStorageClassDeclatationMacros.macro" */
   14925             : 
   14926             : 
   14927             :     public:
   14928             :       void pickOutIRNodeData ( SgUpirTaskStatement* source );
   14929             :       static void arrangeStaticDataOfEasyStorageClassesInOneBlock ( );
   14930             :       static void deleteStaticDataOfEasyStorageClasses ( );
   14931             :       static void pickOutStaticDataMembers ( );
   14932             :       static void rebuildStaticDataMembers ( );
   14933             :       static void writeEasyStorageDataToFile (std::ostream& out);
   14934             :       static void readEasyStorageDataFromFile (std::istream& in);
   14935             :       static void writeStaticDataToFile (std::ostream& out );
   14936             :       static void readStaticDataFromFile (std::istream& in );
   14937             :       friend class SgUpirTaskStatement;
   14938             :    };
   14939             : /* #line 14940 "../../../src/frontend/SageIII//StorageClasses.h" */
   14940             : 
   14941             : 
   14942             : 
   14943             : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarStorageClassDeclatationMacros.macro" */
   14944             : /* 
   14945             :    JH (01/01/2006) ROSETTA generated class declarations for SgOmpTargetDataStatementStorageClass 
   14946             :    used for the ast file IO. Do not chance by hand! 
   14947             : */
   14948           0 : class SgOmpTargetDataStatementStorageClass  : public SgUpirFieldBodyStatementStorageClass
   14949             :    {
   14950             : 
   14951             :     protected: 
   14952             : 
   14953             : 
   14954             : /* #line 14955 "../../../src/frontend/SageIII//StorageClasses.h" */
   14955             : 
   14956             : 
   14957             : 
   14958             : /* #line 10 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarStorageClassDeclatationMacros.macro" */
   14959             : 
   14960             : 
   14961             :     public:
   14962             :       void pickOutIRNodeData ( SgOmpTargetDataStatement* source );
   14963             :       static void arrangeStaticDataOfEasyStorageClassesInOneBlock ( );
   14964             :       static void deleteStaticDataOfEasyStorageClasses ( );
   14965             :       static void pickOutStaticDataMembers ( );
   14966             :       static void rebuildStaticDataMembers ( );
   14967             :       static void writeEasyStorageDataToFile (std::ostream& out);
   14968             :       static void readEasyStorageDataFromFile (std::istream& in);
   14969             :       static void writeStaticDataToFile (std::ostream& out );
   14970             :       static void readStaticDataFromFile (std::istream& in );
   14971             :       friend class SgOmpTargetDataStatement;
   14972             :    };
   14973             : /* #line 14974 "../../../src/frontend/SageIII//StorageClasses.h" */
   14974             : 
   14975             : 
   14976             : 
   14977             : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarStorageClassDeclatationMacros.macro" */
   14978             : /* 
   14979             :    JH (01/01/2006) ROSETTA generated class declarations for SgOmpTargetParallelForStatementStorageClass 
   14980             :    used for the ast file IO. Do not chance by hand! 
   14981             : */
   14982           0 : class SgOmpTargetParallelForStatementStorageClass  : public SgUpirFieldBodyStatementStorageClass
   14983             :    {
   14984             : 
   14985             :     protected: 
   14986             : 
   14987             : 
   14988             : /* #line 14989 "../../../src/frontend/SageIII//StorageClasses.h" */
   14989             : 
   14990             : 
   14991             : 
   14992             : /* #line 10 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarStorageClassDeclatationMacros.macro" */
   14993             : 
   14994             : 
   14995             :     public:
   14996             :       void pickOutIRNodeData ( SgOmpTargetParallelForStatement* source );
   14997             :       static void arrangeStaticDataOfEasyStorageClassesInOneBlock ( );
   14998             :       static void deleteStaticDataOfEasyStorageClasses ( );
   14999             :       static void pickOutStaticDataMembers ( );
   15000             :       static void rebuildStaticDataMembers ( );
   15001             :       static void writeEasyStorageDataToFile (std::ostream& out);
   15002             :       static void readEasyStorageDataFromFile (std::istream& in);
   15003             :       static void writeStaticDataToFile (std::ostream& out );
   15004             :       static void readStaticDataFromFile (std::istream& in );
   15005             :       friend class SgOmpTargetParallelForStatement;
   15006             :    };
   15007             : /* #line 15008 "../../../src/frontend/SageIII//StorageClasses.h" */
   15008             : 
   15009             : 
   15010             : 
   15011             : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarStorageClassDeclatationMacros.macro" */
   15012             : /* 
   15013             :    JH (01/01/2006) ROSETTA generated class declarations for SgOmpParallelLoopStatementStorageClass 
   15014             :    used for the ast file IO. Do not chance by hand! 
   15015             : */
   15016           0 : class SgOmpParallelLoopStatementStorageClass  : public SgUpirFieldBodyStatementStorageClass
   15017             :    {
   15018             : 
   15019             :     protected: 
   15020             : 
   15021             : 
   15022             : /* #line 15023 "../../../src/frontend/SageIII//StorageClasses.h" */
   15023             : 
   15024             : 
   15025             : 
   15026             : /* #line 10 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarStorageClassDeclatationMacros.macro" */
   15027             : 
   15028             : 
   15029             :     public:
   15030             :       void pickOutIRNodeData ( SgOmpParallelLoopStatement* source );
   15031             :       static void arrangeStaticDataOfEasyStorageClassesInOneBlock ( );
   15032             :       static void deleteStaticDataOfEasyStorageClasses ( );
   15033             :       static void pickOutStaticDataMembers ( );
   15034             :       static void rebuildStaticDataMembers ( );
   15035             :       static void writeEasyStorageDataToFile (std::ostream& out);
   15036             :       static void readEasyStorageDataFromFile (std::istream& in);
   15037             :       static void writeStaticDataToFile (std::ostream& out );
   15038             :       static void readStaticDataFromFile (std::istream& in );
   15039             :       friend class SgOmpParallelLoopStatement;
   15040             :    };
   15041             : /* #line 15042 "../../../src/frontend/SageIII//StorageClasses.h" */
   15042             : 
   15043             : 
   15044             : 
   15045             : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarStorageClassDeclatationMacros.macro" */
   15046             : /* 
   15047             :    JH (01/01/2006) ROSETTA generated class declarations for SgOmpTargetParallelStatementStorageClass 
   15048             :    used for the ast file IO. Do not chance by hand! 
   15049             : */
   15050           0 : class SgOmpTargetParallelStatementStorageClass  : public SgUpirFieldBodyStatementStorageClass
   15051             :    {
   15052             : 
   15053             :     protected: 
   15054             : 
   15055             : 
   15056             : /* #line 15057 "../../../src/frontend/SageIII//StorageClasses.h" */
   15057             : 
   15058             : 
   15059             : 
   15060             : /* #line 10 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarStorageClassDeclatationMacros.macro" */
   15061             : 
   15062             : 
   15063             :     public:
   15064             :       void pickOutIRNodeData ( SgOmpTargetParallelStatement* source );
   15065             :       static void arrangeStaticDataOfEasyStorageClassesInOneBlock ( );
   15066             :       static void deleteStaticDataOfEasyStorageClasses ( );
   15067             :       static void pickOutStaticDataMembers ( );
   15068             :       static void rebuildStaticDataMembers ( );
   15069             :       static void writeEasyStorageDataToFile (std::ostream& out);
   15070             :       static void readEasyStorageDataFromFile (std::istream& in);
   15071             :       static void writeStaticDataToFile (std::ostream& out );
   15072             :       static void readStaticDataFromFile (std::istream& in );
   15073             :       friend class SgOmpTargetParallelStatement;
   15074             :    };
   15075             : /* #line 15076 "../../../src/frontend/SageIII//StorageClasses.h" */
   15076             : 
   15077             : 
   15078             : 
   15079             : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarStorageClassDeclatationMacros.macro" */
   15080             : /* 
   15081             :    JH (01/01/2006) ROSETTA generated class declarations for SgOmpTargetParallelForSimdStatementStorageClass 
   15082             :    used for the ast file IO. Do not chance by hand! 
   15083             : */
   15084           0 : class SgOmpTargetParallelForSimdStatementStorageClass  : public SgUpirFieldBodyStatementStorageClass
   15085             :    {
   15086             : 
   15087             :     protected: 
   15088             : 
   15089             : 
   15090             : /* #line 15091 "../../../src/frontend/SageIII//StorageClasses.h" */
   15091             : 
   15092             : 
   15093             : 
   15094             : /* #line 10 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarStorageClassDeclatationMacros.macro" */
   15095             : 
   15096             : 
   15097             :     public:
   15098             :       void pickOutIRNodeData ( SgOmpTargetParallelForSimdStatement* source );
   15099             :       static void arrangeStaticDataOfEasyStorageClassesInOneBlock ( );
   15100             :       static void deleteStaticDataOfEasyStorageClasses ( );
   15101             :       static void pickOutStaticDataMembers ( );
   15102             :       static void rebuildStaticDataMembers ( );
   15103             :       static void writeEasyStorageDataToFile (std::ostream& out);
   15104             :       static void readEasyStorageDataFromFile (std::istream& in);
   15105             :       static void writeStaticDataToFile (std::ostream& out );
   15106             :       static void readStaticDataFromFile (std::istream& in );
   15107             :       friend class SgOmpTargetParallelForSimdStatement;
   15108             :    };
   15109             : /* #line 15110 "../../../src/frontend/SageIII//StorageClasses.h" */
   15110             : 
   15111             : 
   15112             : 
   15113             : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarStorageClassDeclatationMacros.macro" */
   15114             : /* 
   15115             :    JH (01/01/2006) ROSETTA generated class declarations for SgOmpTargetParallelLoopStatementStorageClass 
   15116             :    used for the ast file IO. Do not chance by hand! 
   15117             : */
   15118           0 : class SgOmpTargetParallelLoopStatementStorageClass  : public SgUpirFieldBodyStatementStorageClass
   15119             :    {
   15120             : 
   15121             :     protected: 
   15122             : 
   15123             : 
   15124             : /* #line 15125 "../../../src/frontend/SageIII//StorageClasses.h" */
   15125             : 
   15126             : 
   15127             : 
   15128             : /* #line 10 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarStorageClassDeclatationMacros.macro" */
   15129             : 
   15130             : 
   15131             :     public:
   15132             :       void pickOutIRNodeData ( SgOmpTargetParallelLoopStatement* source );
   15133             :       static void arrangeStaticDataOfEasyStorageClassesInOneBlock ( );
   15134             :       static void deleteStaticDataOfEasyStorageClasses ( );
   15135             :       static void pickOutStaticDataMembers ( );
   15136             :       static void rebuildStaticDataMembers ( );
   15137             :       static void writeEasyStorageDataToFile (std::ostream& out);
   15138             :       static void readEasyStorageDataFromFile (std::istream& in);
   15139             :       static void writeStaticDataToFile (std::ostream& out );
   15140             :       static void readStaticDataFromFile (std::istream& in );
   15141             :       friend class SgOmpTargetParallelLoopStatement;
   15142             :    };
   15143             : /* #line 15144 "../../../src/frontend/SageIII//StorageClasses.h" */
   15144             : 
   15145             : 
   15146             : 
   15147             : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarStorageClassDeclatationMacros.macro" */
   15148             : /* 
   15149             :    JH (01/01/2006) ROSETTA generated class declarations for SgOmpTargetSimdStatementStorageClass 
   15150             :    used for the ast file IO. Do not chance by hand! 
   15151             : */
   15152           0 : class SgOmpTargetSimdStatementStorageClass  : public SgUpirFieldBodyStatementStorageClass
   15153             :    {
   15154             : 
   15155             :     protected: 
   15156             : 
   15157             : 
   15158             : /* #line 15159 "../../../src/frontend/SageIII//StorageClasses.h" */
   15159             : 
   15160             : 
   15161             : 
   15162             : /* #line 10 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarStorageClassDeclatationMacros.macro" */
   15163             : 
   15164             : 
   15165             :     public:
   15166             :       void pickOutIRNodeData ( SgOmpTargetSimdStatement* source );
   15167             :       static void arrangeStaticDataOfEasyStorageClassesInOneBlock ( );
   15168             :       static void deleteStaticDataOfEasyStorageClasses ( );
   15169             :       static void pickOutStaticDataMembers ( );
   15170             :       static void rebuildStaticDataMembers ( );
   15171             :       static void writeEasyStorageDataToFile (std::ostream& out);
   15172             :       static void readEasyStorageDataFromFile (std::istream& in);
   15173             :       static void writeStaticDataToFile (std::ostream& out );
   15174             :       static void readStaticDataFromFile (std::istream& in );
   15175             :       friend class SgOmpTargetSimdStatement;
   15176             :    };
   15177             : /* #line 15178 "../../../src/frontend/SageIII//StorageClasses.h" */
   15178             : 
   15179             : 
   15180             : 
   15181             : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarStorageClassDeclatationMacros.macro" */
   15182             : /* 
   15183             :    JH (01/01/2006) ROSETTA generated class declarations for SgOmpTargetTeamsStatementStorageClass 
   15184             :    used for the ast file IO. Do not chance by hand! 
   15185             : */
   15186           0 : class SgOmpTargetTeamsStatementStorageClass  : public SgUpirFieldBodyStatementStorageClass
   15187             :    {
   15188             : 
   15189             :     protected: 
   15190             : 
   15191             : 
   15192             : /* #line 15193 "../../../src/frontend/SageIII//StorageClasses.h" */
   15193             : 
   15194             : 
   15195             : 
   15196             : /* #line 10 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarStorageClassDeclatationMacros.macro" */
   15197             : 
   15198             : 
   15199             :     public:
   15200             :       void pickOutIRNodeData ( SgOmpTargetTeamsStatement* source );
   15201             :       static void arrangeStaticDataOfEasyStorageClassesInOneBlock ( );
   15202             :       static void deleteStaticDataOfEasyStorageClasses ( );
   15203             :       static void pickOutStaticDataMembers ( );
   15204             :       static void rebuildStaticDataMembers ( );
   15205             :       static void writeEasyStorageDataToFile (std::ostream& out);
   15206             :       static void readEasyStorageDataFromFile (std::istream& in);
   15207             :       static void writeStaticDataToFile (std::ostream& out );
   15208             :       static void readStaticDataFromFile (std::istream& in );
   15209             :       friend class SgOmpTargetTeamsStatement;
   15210             :    };
   15211             : /* #line 15212 "../../../src/frontend/SageIII//StorageClasses.h" */
   15212             : 
   15213             : 
   15214             : 
   15215             : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarStorageClassDeclatationMacros.macro" */
   15216             : /* 
   15217             :    JH (01/01/2006) ROSETTA generated class declarations for SgOmpTargetTeamsDistributeStatementStorageClass 
   15218             :    used for the ast file IO. Do not chance by hand! 
   15219             : */
   15220           0 : class SgOmpTargetTeamsDistributeStatementStorageClass  : public SgUpirFieldBodyStatementStorageClass
   15221             :    {
   15222             : 
   15223             :     protected: 
   15224             : 
   15225             : 
   15226             : /* #line 15227 "../../../src/frontend/SageIII//StorageClasses.h" */
   15227             : 
   15228             : 
   15229             : 
   15230             : /* #line 10 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarStorageClassDeclatationMacros.macro" */
   15231             : 
   15232             : 
   15233             :     public:
   15234             :       void pickOutIRNodeData ( SgOmpTargetTeamsDistributeStatement* source );
   15235             :       static void arrangeStaticDataOfEasyStorageClassesInOneBlock ( );
   15236             :       static void deleteStaticDataOfEasyStorageClasses ( );
   15237             :       static void pickOutStaticDataMembers ( );
   15238             :       static void rebuildStaticDataMembers ( );
   15239             :       static void writeEasyStorageDataToFile (std::ostream& out);
   15240             :       static void readEasyStorageDataFromFile (std::istream& in);
   15241             :       static void writeStaticDataToFile (std::ostream& out );
   15242             :       static void readStaticDataFromFile (std::istream& in );
   15243             :       friend class SgOmpTargetTeamsDistributeStatement;
   15244             :    };
   15245             : /* #line 15246 "../../../src/frontend/SageIII//StorageClasses.h" */
   15246             : 
   15247             : 
   15248             : 
   15249             : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarStorageClassDeclatationMacros.macro" */
   15250             : /* 
   15251             :    JH (01/01/2006) ROSETTA generated class declarations for SgOmpTargetTeamsDistributeSimdStatementStorageClass 
   15252             :    used for the ast file IO. Do not chance by hand! 
   15253             : */
   15254           0 : class SgOmpTargetTeamsDistributeSimdStatementStorageClass  : public SgUpirFieldBodyStatementStorageClass
   15255             :    {
   15256             : 
   15257             :     protected: 
   15258             : 
   15259             : 
   15260             : /* #line 15261 "../../../src/frontend/SageIII//StorageClasses.h" */
   15261             : 
   15262             : 
   15263             : 
   15264             : /* #line 10 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarStorageClassDeclatationMacros.macro" */
   15265             : 
   15266             : 
   15267             :     public:
   15268             :       void pickOutIRNodeData ( SgOmpTargetTeamsDistributeSimdStatement* source );
   15269             :       static void arrangeStaticDataOfEasyStorageClassesInOneBlock ( );
   15270             :       static void deleteStaticDataOfEasyStorageClasses ( );
   15271             :       static void pickOutStaticDataMembers ( );
   15272             :       static void rebuildStaticDataMembers ( );
   15273             :       static void writeEasyStorageDataToFile (std::ostream& out);
   15274             :       static void readEasyStorageDataFromFile (std::istream& in);
   15275             :       static void writeStaticDataToFile (std::ostream& out );
   15276             :       static void readStaticDataFromFile (std::istream& in );
   15277             :       friend class SgOmpTargetTeamsDistributeSimdStatement;
   15278             :    };
   15279             : /* #line 15280 "../../../src/frontend/SageIII//StorageClasses.h" */
   15280             : 
   15281             : 
   15282             : 
   15283             : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarStorageClassDeclatationMacros.macro" */
   15284             : /* 
   15285             :    JH (01/01/2006) ROSETTA generated class declarations for SgOmpTargetTeamsLoopStatementStorageClass 
   15286             :    used for the ast file IO. Do not chance by hand! 
   15287             : */
   15288           0 : class SgOmpTargetTeamsLoopStatementStorageClass  : public SgUpirFieldBodyStatementStorageClass
   15289             :    {
   15290             : 
   15291             :     protected: 
   15292             : 
   15293             : 
   15294             : /* #line 15295 "../../../src/frontend/SageIII//StorageClasses.h" */
   15295             : 
   15296             : 
   15297             : 
   15298             : /* #line 10 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarStorageClassDeclatationMacros.macro" */
   15299             : 
   15300             : 
   15301             :     public:
   15302             :       void pickOutIRNodeData ( SgOmpTargetTeamsLoopStatement* source );
   15303             :       static void arrangeStaticDataOfEasyStorageClassesInOneBlock ( );
   15304             :       static void deleteStaticDataOfEasyStorageClasses ( );
   15305             :       static void pickOutStaticDataMembers ( );
   15306             :       static void rebuildStaticDataMembers ( );
   15307             :       static void writeEasyStorageDataToFile (std::ostream& out);
   15308             :       static void readEasyStorageDataFromFile (std::istream& in);
   15309             :       static void writeStaticDataToFile (std::ostream& out );
   15310             :       static void readStaticDataFromFile (std::istream& in );
   15311             :       friend class SgOmpTargetTeamsLoopStatement;
   15312             :    };
   15313             : /* #line 15314 "../../../src/frontend/SageIII//StorageClasses.h" */
   15314             : 
   15315             : 
   15316             : 
   15317             : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarStorageClassDeclatationMacros.macro" */
   15318             : /* 
   15319             :    JH (01/01/2006) ROSETTA generated class declarations for SgOmpTargetTeamsDistributeParallelForStatementStorageClass 
   15320             :    used for the ast file IO. Do not chance by hand! 
   15321             : */
   15322           0 : class SgOmpTargetTeamsDistributeParallelForStatementStorageClass  : public SgUpirFieldBodyStatementStorageClass
   15323             :    {
   15324             : 
   15325             :     protected: 
   15326             : 
   15327             : 
   15328             : /* #line 15329 "../../../src/frontend/SageIII//StorageClasses.h" */
   15329             : 
   15330             : 
   15331             : 
   15332             : /* #line 10 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarStorageClassDeclatationMacros.macro" */
   15333             : 
   15334             : 
   15335             :     public:
   15336             :       void pickOutIRNodeData ( SgOmpTargetTeamsDistributeParallelForStatement* source );
   15337             :       static void arrangeStaticDataOfEasyStorageClassesInOneBlock ( );
   15338             :       static void deleteStaticDataOfEasyStorageClasses ( );
   15339             :       static void pickOutStaticDataMembers ( );
   15340             :       static void rebuildStaticDataMembers ( );
   15341             :       static void writeEasyStorageDataToFile (std::ostream& out);
   15342             :       static void readEasyStorageDataFromFile (std::istream& in);
   15343             :       static void writeStaticDataToFile (std::ostream& out );
   15344             :       static void readStaticDataFromFile (std::istream& in );
   15345             :       friend class SgOmpTargetTeamsDistributeParallelForStatement;
   15346             :    };
   15347             : /* #line 15348 "../../../src/frontend/SageIII//StorageClasses.h" */
   15348             : 
   15349             : 
   15350             : 
   15351             : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarStorageClassDeclatationMacros.macro" */
   15352             : /* 
   15353             :    JH (01/01/2006) ROSETTA generated class declarations for SgOmpTargetTeamsDistributeParallelForSimdStatementStorageClass 
   15354             :    used for the ast file IO. Do not chance by hand! 
   15355             : */
   15356           0 : class SgOmpTargetTeamsDistributeParallelForSimdStatementStorageClass  : public SgUpirFieldBodyStatementStorageClass
   15357             :    {
   15358             : 
   15359             :     protected: 
   15360             : 
   15361             : 
   15362             : /* #line 15363 "../../../src/frontend/SageIII//StorageClasses.h" */
   15363             : 
   15364             : 
   15365             : 
   15366             : /* #line 10 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarStorageClassDeclatationMacros.macro" */
   15367             : 
   15368             : 
   15369             :     public:
   15370             :       void pickOutIRNodeData ( SgOmpTargetTeamsDistributeParallelForSimdStatement* source );
   15371             :       static void arrangeStaticDataOfEasyStorageClassesInOneBlock ( );
   15372             :       static void deleteStaticDataOfEasyStorageClasses ( );
   15373             :       static void pickOutStaticDataMembers ( );
   15374             :       static void rebuildStaticDataMembers ( );
   15375             :       static void writeEasyStorageDataToFile (std::ostream& out);
   15376             :       static void readEasyStorageDataFromFile (std::istream& in);
   15377             :       static void writeStaticDataToFile (std::ostream& out );
   15378             :       static void readStaticDataFromFile (std::istream& in );
   15379             :       friend class SgOmpTargetTeamsDistributeParallelForSimdStatement;
   15380             :    };
   15381             : /* #line 15382 "../../../src/frontend/SageIII//StorageClasses.h" */
   15382             : 
   15383             : 
   15384             : 
   15385             : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarStorageClassDeclatationMacros.macro" */
   15386             : /* 
   15387             :    JH (01/01/2006) ROSETTA generated class declarations for SgOmpDistributeSimdStatementStorageClass 
   15388             :    used for the ast file IO. Do not chance by hand! 
   15389             : */
   15390           0 : class SgOmpDistributeSimdStatementStorageClass  : public SgUpirFieldBodyStatementStorageClass
   15391             :    {
   15392             : 
   15393             :     protected: 
   15394             : 
   15395             : 
   15396             : /* #line 15397 "../../../src/frontend/SageIII//StorageClasses.h" */
   15397             : 
   15398             : 
   15399             : 
   15400             : /* #line 10 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarStorageClassDeclatationMacros.macro" */
   15401             : 
   15402             : 
   15403             :     public:
   15404             :       void pickOutIRNodeData ( SgOmpDistributeSimdStatement* source );
   15405             :       static void arrangeStaticDataOfEasyStorageClassesInOneBlock ( );
   15406             :       static void deleteStaticDataOfEasyStorageClasses ( );
   15407             :       static void pickOutStaticDataMembers ( );
   15408             :       static void rebuildStaticDataMembers ( );
   15409             :       static void writeEasyStorageDataToFile (std::ostream& out);
   15410             :       static void readEasyStorageDataFromFile (std::istream& in);
   15411             :       static void writeStaticDataToFile (std::ostream& out );
   15412             :       static void readStaticDataFromFile (std::istream& in );
   15413             :       friend class SgOmpDistributeSimdStatement;
   15414             :    };
   15415             : /* #line 15416 "../../../src/frontend/SageIII//StorageClasses.h" */
   15416             : 
   15417             : 
   15418             : 
   15419             : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarStorageClassDeclatationMacros.macro" */
   15420             : /* 
   15421             :    JH (01/01/2006) ROSETTA generated class declarations for SgOmpDistributeParallelForStatementStorageClass 
   15422             :    used for the ast file IO. Do not chance by hand! 
   15423             : */
   15424           0 : class SgOmpDistributeParallelForStatementStorageClass  : public SgUpirFieldBodyStatementStorageClass
   15425             :    {
   15426             : 
   15427             :     protected: 
   15428             : 
   15429             : 
   15430             : /* #line 15431 "../../../src/frontend/SageIII//StorageClasses.h" */
   15431             : 
   15432             : 
   15433             : 
   15434             : /* #line 10 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarStorageClassDeclatationMacros.macro" */
   15435             : 
   15436             : 
   15437             :     public:
   15438             :       void pickOutIRNodeData ( SgOmpDistributeParallelForStatement* source );
   15439             :       static void arrangeStaticDataOfEasyStorageClassesInOneBlock ( );
   15440             :       static void deleteStaticDataOfEasyStorageClasses ( );
   15441             :       static void pickOutStaticDataMembers ( );
   15442             :       static void rebuildStaticDataMembers ( );
   15443             :       static void writeEasyStorageDataToFile (std::ostream& out);
   15444             :       static void readEasyStorageDataFromFile (std::istream& in);
   15445             :       static void writeStaticDataToFile (std::ostream& out );
   15446             :       static void readStaticDataFromFile (std::istream& in );
   15447             :       friend class SgOmpDistributeParallelForStatement;
   15448             :    };
   15449             : /* #line 15450 "../../../src/frontend/SageIII//StorageClasses.h" */
   15450             : 
   15451             : 
   15452             : 
   15453             : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarStorageClassDeclatationMacros.macro" */
   15454             : /* 
   15455             :    JH (01/01/2006) ROSETTA generated class declarations for SgOmpDistributeParallelForSimdStatementStorageClass 
   15456             :    used for the ast file IO. Do not chance by hand! 
   15457             : */
   15458           0 : class SgOmpDistributeParallelForSimdStatementStorageClass  : public SgUpirFieldBodyStatementStorageClass
   15459             :    {
   15460             : 
   15461             :     protected: 
   15462             : 
   15463             : 
   15464             : /* #line 15465 "../../../src/frontend/SageIII//StorageClasses.h" */
   15465             : 
   15466             : 
   15467             : 
   15468             : /* #line 10 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarStorageClassDeclatationMacros.macro" */
   15469             : 
   15470             : 
   15471             :     public:
   15472             :       void pickOutIRNodeData ( SgOmpDistributeParallelForSimdStatement* source );
   15473             :       static void arrangeStaticDataOfEasyStorageClassesInOneBlock ( );
   15474             :       static void deleteStaticDataOfEasyStorageClasses ( );
   15475             :       static void pickOutStaticDataMembers ( );
   15476             :       static void rebuildStaticDataMembers ( );
   15477             :       static void writeEasyStorageDataToFile (std::ostream& out);
   15478             :       static void readEasyStorageDataFromFile (std::istream& in);
   15479             :       static void writeStaticDataToFile (std::ostream& out );
   15480             :       static void readStaticDataFromFile (std::istream& in );
   15481             :       friend class SgOmpDistributeParallelForSimdStatement;
   15482             :    };
   15483             : /* #line 15484 "../../../src/frontend/SageIII//StorageClasses.h" */
   15484             : 
   15485             : 
   15486             : 
   15487             : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarStorageClassDeclatationMacros.macro" */
   15488             : /* 
   15489             :    JH (01/01/2006) ROSETTA generated class declarations for SgOmpTaskloopSimdStatementStorageClass 
   15490             :    used for the ast file IO. Do not chance by hand! 
   15491             : */
   15492           0 : class SgOmpTaskloopSimdStatementStorageClass  : public SgUpirFieldBodyStatementStorageClass
   15493             :    {
   15494             : 
   15495             :     protected: 
   15496             : 
   15497             : 
   15498             : /* #line 15499 "../../../src/frontend/SageIII//StorageClasses.h" */
   15499             : 
   15500             : 
   15501             : 
   15502             : /* #line 10 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarStorageClassDeclatationMacros.macro" */
   15503             : 
   15504             : 
   15505             :     public:
   15506             :       void pickOutIRNodeData ( SgOmpTaskloopSimdStatement* source );
   15507             :       static void arrangeStaticDataOfEasyStorageClassesInOneBlock ( );
   15508             :       static void deleteStaticDataOfEasyStorageClasses ( );
   15509             :       static void pickOutStaticDataMembers ( );
   15510             :       static void rebuildStaticDataMembers ( );
   15511             :       static void writeEasyStorageDataToFile (std::ostream& out);
   15512             :       static void readEasyStorageDataFromFile (std::istream& in);
   15513             :       static void writeStaticDataToFile (std::ostream& out );
   15514             :       static void readStaticDataFromFile (std::istream& in );
   15515             :       friend class SgOmpTaskloopSimdStatement;
   15516             :    };
   15517             : /* #line 15518 "../../../src/frontend/SageIII//StorageClasses.h" */
   15518             : 
   15519             : 
   15520             : 
   15521             : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarStorageClassDeclatationMacros.macro" */
   15522             : /* 
   15523             :    JH (01/01/2006) ROSETTA generated class declarations for SgOmpMasterTaskloopSimdStatementStorageClass 
   15524             :    used for the ast file IO. Do not chance by hand! 
   15525             : */
   15526           0 : class SgOmpMasterTaskloopSimdStatementStorageClass  : public SgUpirFieldBodyStatementStorageClass
   15527             :    {
   15528             : 
   15529             :     protected: 
   15530             : 
   15531             : 
   15532             : /* #line 15533 "../../../src/frontend/SageIII//StorageClasses.h" */
   15533             : 
   15534             : 
   15535             : 
   15536             : /* #line 10 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarStorageClassDeclatationMacros.macro" */
   15537             : 
   15538             : 
   15539             :     public:
   15540             :       void pickOutIRNodeData ( SgOmpMasterTaskloopSimdStatement* source );
   15541             :       static void arrangeStaticDataOfEasyStorageClassesInOneBlock ( );
   15542             :       static void deleteStaticDataOfEasyStorageClasses ( );
   15543             :       static void pickOutStaticDataMembers ( );
   15544             :       static void rebuildStaticDataMembers ( );
   15545             :       static void writeEasyStorageDataToFile (std::ostream& out);
   15546             :       static void readEasyStorageDataFromFile (std::istream& in);
   15547             :       static void writeStaticDataToFile (std::ostream& out );
   15548             :       static void readStaticDataFromFile (std::istream& in );
   15549             :       friend class SgOmpMasterTaskloopSimdStatement;
   15550             :    };
   15551             : /* #line 15552 "../../../src/frontend/SageIII//StorageClasses.h" */
   15552             : 
   15553             : 
   15554             : 
   15555             : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarStorageClassDeclatationMacros.macro" */
   15556             : /* 
   15557             :    JH (01/01/2006) ROSETTA generated class declarations for SgOmpParallelMasterTaskloopStatementStorageClass 
   15558             :    used for the ast file IO. Do not chance by hand! 
   15559             : */
   15560           0 : class SgOmpParallelMasterTaskloopStatementStorageClass  : public SgUpirFieldBodyStatementStorageClass
   15561             :    {
   15562             : 
   15563             :     protected: 
   15564             : 
   15565             : 
   15566             : /* #line 15567 "../../../src/frontend/SageIII//StorageClasses.h" */
   15567             : 
   15568             : 
   15569             : 
   15570             : /* #line 10 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarStorageClassDeclatationMacros.macro" */
   15571             : 
   15572             : 
   15573             :     public:
   15574             :       void pickOutIRNodeData ( SgOmpParallelMasterTaskloopStatement* source );
   15575             :       static void arrangeStaticDataOfEasyStorageClassesInOneBlock ( );
   15576             :       static void deleteStaticDataOfEasyStorageClasses ( );
   15577             :       static void pickOutStaticDataMembers ( );
   15578             :       static void rebuildStaticDataMembers ( );
   15579             :       static void writeEasyStorageDataToFile (std::ostream& out);
   15580             :       static void readEasyStorageDataFromFile (std::istream& in);
   15581             :       static void writeStaticDataToFile (std::ostream& out );
   15582             :       static void readStaticDataFromFile (std::istream& in );
   15583             :       friend class SgOmpParallelMasterTaskloopStatement;
   15584             :    };
   15585             : /* #line 15586 "../../../src/frontend/SageIII//StorageClasses.h" */
   15586             : 
   15587             : 
   15588             : 
   15589             : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarStorageClassDeclatationMacros.macro" */
   15590             : /* 
   15591             :    JH (01/01/2006) ROSETTA generated class declarations for SgOmpParallelMasterTaskloopSimdStatementStorageClass 
   15592             :    used for the ast file IO. Do not chance by hand! 
   15593             : */
   15594           0 : class SgOmpParallelMasterTaskloopSimdStatementStorageClass  : public SgUpirFieldBodyStatementStorageClass
   15595             :    {
   15596             : 
   15597             :     protected: 
   15598             : 
   15599             : 
   15600             : /* #line 15601 "../../../src/frontend/SageIII//StorageClasses.h" */
   15601             : 
   15602             : 
   15603             : 
   15604             : /* #line 10 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarStorageClassDeclatationMacros.macro" */
   15605             : 
   15606             : 
   15607             :     public:
   15608             :       void pickOutIRNodeData ( SgOmpParallelMasterTaskloopSimdStatement* source );
   15609             :       static void arrangeStaticDataOfEasyStorageClassesInOneBlock ( );
   15610             :       static void deleteStaticDataOfEasyStorageClasses ( );
   15611             :       static void pickOutStaticDataMembers ( );
   15612             :       static void rebuildStaticDataMembers ( );
   15613             :       static void writeEasyStorageDataToFile (std::ostream& out);
   15614             :       static void readEasyStorageDataFromFile (std::istream& in);
   15615             :       static void writeStaticDataToFile (std::ostream& out );
   15616             :       static void readStaticDataFromFile (std::istream& in );
   15617             :       friend class SgOmpParallelMasterTaskloopSimdStatement;
   15618             :    };
   15619             : /* #line 15620 "../../../src/frontend/SageIII//StorageClasses.h" */
   15620             : 
   15621             : 
   15622             : 
   15623             : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarStorageClassDeclatationMacros.macro" */
   15624             : /* 
   15625             :    JH (01/01/2006) ROSETTA generated class declarations for SgOmpTeamsDistributeStatementStorageClass 
   15626             :    used for the ast file IO. Do not chance by hand! 
   15627             : */
   15628           0 : class SgOmpTeamsDistributeStatementStorageClass  : public SgUpirFieldBodyStatementStorageClass
   15629             :    {
   15630             : 
   15631             :     protected: 
   15632             : 
   15633             : 
   15634             : /* #line 15635 "../../../src/frontend/SageIII//StorageClasses.h" */
   15635             : 
   15636             : 
   15637             : 
   15638             : /* #line 10 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarStorageClassDeclatationMacros.macro" */
   15639             : 
   15640             : 
   15641             :     public:
   15642             :       void pickOutIRNodeData ( SgOmpTeamsDistributeStatement* source );
   15643             :       static void arrangeStaticDataOfEasyStorageClassesInOneBlock ( );
   15644             :       static void deleteStaticDataOfEasyStorageClasses ( );
   15645             :       static void pickOutStaticDataMembers ( );
   15646             :       static void rebuildStaticDataMembers ( );
   15647             :       static void writeEasyStorageDataToFile (std::ostream& out);
   15648             :       static void readEasyStorageDataFromFile (std::istream& in);
   15649             :       static void writeStaticDataToFile (std::ostream& out );
   15650             :       static void readStaticDataFromFile (std::istream& in );
   15651             :       friend class SgOmpTeamsDistributeStatement;
   15652             :    };
   15653             : /* #line 15654 "../../../src/frontend/SageIII//StorageClasses.h" */
   15654             : 
   15655             : 
   15656             : 
   15657             : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarStorageClassDeclatationMacros.macro" */
   15658             : /* 
   15659             :    JH (01/01/2006) ROSETTA generated class declarations for SgOmpTeamsDistributeSimdStatementStorageClass 
   15660             :    used for the ast file IO. Do not chance by hand! 
   15661             : */
   15662           0 : class SgOmpTeamsDistributeSimdStatementStorageClass  : public SgUpirFieldBodyStatementStorageClass
   15663             :    {
   15664             : 
   15665             :     protected: 
   15666             : 
   15667             : 
   15668             : /* #line 15669 "../../../src/frontend/SageIII//StorageClasses.h" */
   15669             : 
   15670             : 
   15671             : 
   15672             : /* #line 10 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarStorageClassDeclatationMacros.macro" */
   15673             : 
   15674             : 
   15675             :     public:
   15676             :       void pickOutIRNodeData ( SgOmpTeamsDistributeSimdStatement* source );
   15677             :       static void arrangeStaticDataOfEasyStorageClassesInOneBlock ( );
   15678             :       static void deleteStaticDataOfEasyStorageClasses ( );
   15679             :       static void pickOutStaticDataMembers ( );
   15680             :       static void rebuildStaticDataMembers ( );
   15681             :       static void writeEasyStorageDataToFile (std::ostream& out);
   15682             :       static void readEasyStorageDataFromFile (std::istream& in);
   15683             :       static void writeStaticDataToFile (std::ostream& out );
   15684             :       static void readStaticDataFromFile (std::istream& in );
   15685             :       friend class SgOmpTeamsDistributeSimdStatement;
   15686             :    };
   15687             : /* #line 15688 "../../../src/frontend/SageIII//StorageClasses.h" */
   15688             : 
   15689             : 
   15690             : 
   15691             : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarStorageClassDeclatationMacros.macro" */
   15692             : /* 
   15693             :    JH (01/01/2006) ROSETTA generated class declarations for SgOmpTeamsDistributeParallelForStatementStorageClass 
   15694             :    used for the ast file IO. Do not chance by hand! 
   15695             : */
   15696           0 : class SgOmpTeamsDistributeParallelForStatementStorageClass  : public SgUpirFieldBodyStatementStorageClass
   15697             :    {
   15698             : 
   15699             :     protected: 
   15700             : 
   15701             : 
   15702             : /* #line 15703 "../../../src/frontend/SageIII//StorageClasses.h" */
   15703             : 
   15704             : 
   15705             : 
   15706             : /* #line 10 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarStorageClassDeclatationMacros.macro" */
   15707             : 
   15708             : 
   15709             :     public:
   15710             :       void pickOutIRNodeData ( SgOmpTeamsDistributeParallelForStatement* source );
   15711             :       static void arrangeStaticDataOfEasyStorageClassesInOneBlock ( );
   15712             :       static void deleteStaticDataOfEasyStorageClasses ( );
   15713             :       static void pickOutStaticDataMembers ( );
   15714             :       static void rebuildStaticDataMembers ( );
   15715             :       static void writeEasyStorageDataToFile (std::ostream& out);
   15716             :       static void readEasyStorageDataFromFile (std::istream& in);
   15717             :       static void writeStaticDataToFile (std::ostream& out );
   15718             :       static void readStaticDataFromFile (std::istream& in );
   15719             :       friend class SgOmpTeamsDistributeParallelForStatement;
   15720             :    };
   15721             : /* #line 15722 "../../../src/frontend/SageIII//StorageClasses.h" */
   15722             : 
   15723             : 
   15724             : 
   15725             : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarStorageClassDeclatationMacros.macro" */
   15726             : /* 
   15727             :    JH (01/01/2006) ROSETTA generated class declarations for SgOmpTeamsDistributeParallelForSimdStatementStorageClass 
   15728             :    used for the ast file IO. Do not chance by hand! 
   15729             : */
   15730           0 : class SgOmpTeamsDistributeParallelForSimdStatementStorageClass  : public SgUpirFieldBodyStatementStorageClass
   15731             :    {
   15732             : 
   15733             :     protected: 
   15734             : 
   15735             : 
   15736             : /* #line 15737 "../../../src/frontend/SageIII//StorageClasses.h" */
   15737             : 
   15738             : 
   15739             : 
   15740             : /* #line 10 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarStorageClassDeclatationMacros.macro" */
   15741             : 
   15742             : 
   15743             :     public:
   15744             :       void pickOutIRNodeData ( SgOmpTeamsDistributeParallelForSimdStatement* source );
   15745             :       static void arrangeStaticDataOfEasyStorageClassesInOneBlock ( );
   15746             :       static void deleteStaticDataOfEasyStorageClasses ( );
   15747             :       static void pickOutStaticDataMembers ( );
   15748             :       static void rebuildStaticDataMembers ( );
   15749             :       static void writeEasyStorageDataToFile (std::ostream& out);
   15750             :       static void readEasyStorageDataFromFile (std::istream& in);
   15751             :       static void writeStaticDataToFile (std::ostream& out );
   15752             :       static void readStaticDataFromFile (std::istream& in );
   15753             :       friend class SgOmpTeamsDistributeParallelForSimdStatement;
   15754             :    };
   15755             : /* #line 15756 "../../../src/frontend/SageIII//StorageClasses.h" */
   15756             : 
   15757             : 
   15758             : 
   15759             : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarStorageClassDeclatationMacros.macro" */
   15760             : /* 
   15761             :    JH (01/01/2006) ROSETTA generated class declarations for SgOmpTeamsLoopStatementStorageClass 
   15762             :    used for the ast file IO. Do not chance by hand! 
   15763             : */
   15764           0 : class SgOmpTeamsLoopStatementStorageClass  : public SgUpirFieldBodyStatementStorageClass
   15765             :    {
   15766             : 
   15767             :     protected: 
   15768             : 
   15769             : 
   15770             : /* #line 15771 "../../../src/frontend/SageIII//StorageClasses.h" */
   15771             : 
   15772             : 
   15773             : 
   15774             : /* #line 10 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarStorageClassDeclatationMacros.macro" */
   15775             : 
   15776             : 
   15777             :     public:
   15778             :       void pickOutIRNodeData ( SgOmpTeamsLoopStatement* source );
   15779             :       static void arrangeStaticDataOfEasyStorageClassesInOneBlock ( );
   15780             :       static void deleteStaticDataOfEasyStorageClasses ( );
   15781             :       static void pickOutStaticDataMembers ( );
   15782             :       static void rebuildStaticDataMembers ( );
   15783             :       static void writeEasyStorageDataToFile (std::ostream& out);
   15784             :       static void readEasyStorageDataFromFile (std::istream& in);
   15785             :       static void writeStaticDataToFile (std::ostream& out );
   15786             :       static void readStaticDataFromFile (std::istream& in );
   15787             :       friend class SgOmpTeamsLoopStatement;
   15788             :    };
   15789             : /* #line 15790 "../../../src/frontend/SageIII//StorageClasses.h" */
   15790             : 
   15791             : 
   15792             : 
   15793             : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarStorageClassDeclatationMacros.macro" */
   15794             : /* 
   15795             :    JH (01/01/2006) ROSETTA generated class declarations for SgOmpForSimdStatementStorageClass 
   15796             :    used for the ast file IO. Do not chance by hand! 
   15797             : */
   15798           0 : class SgOmpForSimdStatementStorageClass  : public SgUpirFieldBodyStatementStorageClass
   15799             :    {
   15800             : 
   15801             :     protected: 
   15802             : 
   15803             : 
   15804             : /* #line 15805 "../../../src/frontend/SageIII//StorageClasses.h" */
   15805             : 
   15806             : 
   15807             : 
   15808             : /* #line 10 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarStorageClassDeclatationMacros.macro" */
   15809             : 
   15810             : 
   15811             :     public:
   15812             :       void pickOutIRNodeData ( SgOmpForSimdStatement* source );
   15813             :       static void arrangeStaticDataOfEasyStorageClassesInOneBlock ( );
   15814             :       static void deleteStaticDataOfEasyStorageClasses ( );
   15815             :       static void pickOutStaticDataMembers ( );
   15816             :       static void rebuildStaticDataMembers ( );
   15817             :       static void writeEasyStorageDataToFile (std::ostream& out);
   15818             :       static void readEasyStorageDataFromFile (std::istream& in);
   15819             :       static void writeStaticDataToFile (std::ostream& out );
   15820             :       static void readStaticDataFromFile (std::istream& in );
   15821             :       friend class SgOmpForSimdStatement;
   15822             :    };
   15823             : /* #line 15824 "../../../src/frontend/SageIII//StorageClasses.h" */
   15824             : 
   15825             : 
   15826             : 
   15827             : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarStorageClassDeclatationMacros.macro" */
   15828             : /* 
   15829             :    JH (01/01/2006) ROSETTA generated class declarations for SgOmpCriticalStatementStorageClass 
   15830             :    used for the ast file IO. Do not chance by hand! 
   15831             : */
   15832           0 : class SgOmpCriticalStatementStorageClass  : public SgUpirFieldBodyStatementStorageClass
   15833             :    {
   15834             : 
   15835             :     protected: 
   15836             : 
   15837             : 
   15838             : /* #line 15839 "../../../src/frontend/SageIII//StorageClasses.h" */
   15839             : 
   15840             :       SgNameStorageClass storageOf_name;
   15841             : 
   15842             : 
   15843             : /* #line 10 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarStorageClassDeclatationMacros.macro" */
   15844             : 
   15845             : 
   15846             :     public:
   15847             :       void pickOutIRNodeData ( SgOmpCriticalStatement* source );
   15848             :       static void arrangeStaticDataOfEasyStorageClassesInOneBlock ( );
   15849             :       static void deleteStaticDataOfEasyStorageClasses ( );
   15850             :       static void pickOutStaticDataMembers ( );
   15851             :       static void rebuildStaticDataMembers ( );
   15852             :       static void writeEasyStorageDataToFile (std::ostream& out);
   15853             :       static void readEasyStorageDataFromFile (std::istream& in);
   15854             :       static void writeStaticDataToFile (std::ostream& out );
   15855             :       static void readStaticDataFromFile (std::istream& in );
   15856             :       friend class SgOmpCriticalStatement;
   15857             :    };
   15858             : /* #line 15859 "../../../src/frontend/SageIII//StorageClasses.h" */
   15859             : 
   15860             : 
   15861             : 
   15862             : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarStorageClassDeclatationMacros.macro" */
   15863             : /* 
   15864             :    JH (01/01/2006) ROSETTA generated class declarations for SgOmpDistributeStatementStorageClass 
   15865             :    used for the ast file IO. Do not chance by hand! 
   15866             : */
   15867           0 : class SgOmpDistributeStatementStorageClass  : public SgUpirFieldBodyStatementStorageClass
   15868             :    {
   15869             : 
   15870             :     protected: 
   15871             : 
   15872             : 
   15873             : /* #line 15874 "../../../src/frontend/SageIII//StorageClasses.h" */
   15874             : 
   15875             : 
   15876             : 
   15877             : /* #line 10 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarStorageClassDeclatationMacros.macro" */
   15878             : 
   15879             : 
   15880             :     public:
   15881             :       void pickOutIRNodeData ( SgOmpDistributeStatement* source );
   15882             :       static void arrangeStaticDataOfEasyStorageClassesInOneBlock ( );
   15883             :       static void deleteStaticDataOfEasyStorageClasses ( );
   15884             :       static void pickOutStaticDataMembers ( );
   15885             :       static void rebuildStaticDataMembers ( );
   15886             :       static void writeEasyStorageDataToFile (std::ostream& out);
   15887             :       static void readEasyStorageDataFromFile (std::istream& in);
   15888             :       static void writeStaticDataToFile (std::ostream& out );
   15889             :       static void readStaticDataFromFile (std::istream& in );
   15890             :       friend class SgOmpDistributeStatement;
   15891             :    };
   15892             : /* #line 15893 "../../../src/frontend/SageIII//StorageClasses.h" */
   15893             : 
   15894             : 
   15895             : 
   15896             : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarStorageClassDeclatationMacros.macro" */
   15897             : /* 
   15898             :    JH (01/01/2006) ROSETTA generated class declarations for SgOmpUnrollStatementStorageClass 
   15899             :    used for the ast file IO. Do not chance by hand! 
   15900             : */
   15901           0 : class SgOmpUnrollStatementStorageClass  : public SgUpirFieldBodyStatementStorageClass
   15902             :    {
   15903             : 
   15904             :     protected: 
   15905             : 
   15906             : 
   15907             : /* #line 15908 "../../../src/frontend/SageIII//StorageClasses.h" */
   15908             : 
   15909             : 
   15910             : 
   15911             : /* #line 10 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarStorageClassDeclatationMacros.macro" */
   15912             : 
   15913             : 
   15914             :     public:
   15915             :       void pickOutIRNodeData ( SgOmpUnrollStatement* source );
   15916             :       static void arrangeStaticDataOfEasyStorageClassesInOneBlock ( );
   15917             :       static void deleteStaticDataOfEasyStorageClasses ( );
   15918             :       static void pickOutStaticDataMembers ( );
   15919             :       static void rebuildStaticDataMembers ( );
   15920             :       static void writeEasyStorageDataToFile (std::ostream& out);
   15921             :       static void readEasyStorageDataFromFile (std::istream& in);
   15922             :       static void writeStaticDataToFile (std::ostream& out );
   15923             :       static void readStaticDataFromFile (std::istream& in );
   15924             :       friend class SgOmpUnrollStatement;
   15925             :    };
   15926             : /* #line 15927 "../../../src/frontend/SageIII//StorageClasses.h" */
   15927             : 
   15928             : 
   15929             : 
   15930             : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarStorageClassDeclatationMacros.macro" */
   15931             : /* 
   15932             :    JH (01/01/2006) ROSETTA generated class declarations for SgOmpTileStatementStorageClass 
   15933             :    used for the ast file IO. Do not chance by hand! 
   15934             : */
   15935           0 : class SgOmpTileStatementStorageClass  : public SgUpirFieldBodyStatementStorageClass
   15936             :    {
   15937             : 
   15938             :     protected: 
   15939             : 
   15940             : 
   15941             : /* #line 15942 "../../../src/frontend/SageIII//StorageClasses.h" */
   15942             : 
   15943             : 
   15944             : 
   15945             : /* #line 10 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarStorageClassDeclatationMacros.macro" */
   15946             : 
   15947             : 
   15948             :     public:
   15949             :       void pickOutIRNodeData ( SgOmpTileStatement* source );
   15950             :       static void arrangeStaticDataOfEasyStorageClassesInOneBlock ( );
   15951             :       static void deleteStaticDataOfEasyStorageClasses ( );
   15952             :       static void pickOutStaticDataMembers ( );
   15953             :       static void rebuildStaticDataMembers ( );
   15954             :       static void writeEasyStorageDataToFile (std::ostream& out);
   15955             :       static void readEasyStorageDataFromFile (std::istream& in);
   15956             :       static void writeStaticDataToFile (std::ostream& out );
   15957             :       static void readStaticDataFromFile (std::istream& in );
   15958             :       friend class SgOmpTileStatement;
   15959             :    };
   15960             : /* #line 15961 "../../../src/frontend/SageIII//StorageClasses.h" */
   15961             : 
   15962             : 
   15963             : 
   15964             : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarStorageClassDeclatationMacros.macro" */
   15965             : /* 
   15966             :    JH (01/01/2006) ROSETTA generated class declarations for SgUpirLoopStatementStorageClass 
   15967             :    used for the ast file IO. Do not chance by hand! 
   15968             : */
   15969           0 : class SgUpirLoopStatementStorageClass  : public SgUpirFieldBodyStatementStorageClass
   15970             :    {
   15971             : 
   15972             :     protected: 
   15973             : 
   15974             : 
   15975             : /* #line 15976 "../../../src/frontend/SageIII//StorageClasses.h" */
   15976             : 
   15977             :      unsigned long storageOf_induction;
   15978             :      unsigned long storageOf_lower_bound;
   15979             :      unsigned long storageOf_upper_bound;
   15980             :      unsigned long storageOf_step;
   15981             :       bool storageOf_incremental;
   15982             : 
   15983             : 
   15984             : /* #line 10 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarStorageClassDeclatationMacros.macro" */
   15985             : 
   15986             : 
   15987             :     public:
   15988             :       void pickOutIRNodeData ( SgUpirLoopStatement* source );
   15989             :       static void arrangeStaticDataOfEasyStorageClassesInOneBlock ( );
   15990             :       static void deleteStaticDataOfEasyStorageClasses ( );
   15991             :       static void pickOutStaticDataMembers ( );
   15992             :       static void rebuildStaticDataMembers ( );
   15993             :       static void writeEasyStorageDataToFile (std::ostream& out);
   15994             :       static void readEasyStorageDataFromFile (std::istream& in);
   15995             :       static void writeStaticDataToFile (std::ostream& out );
   15996             :       static void readStaticDataFromFile (std::istream& in );
   15997             :       friend class SgUpirLoopStatement;
   15998             :    };
   15999             : /* #line 16000 "../../../src/frontend/SageIII//StorageClasses.h" */
   16000             : 
   16001             : 
   16002             : 
   16003             : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarStorageClassDeclatationMacros.macro" */
   16004             : /* 
   16005             :    JH (01/01/2006) ROSETTA generated class declarations for SgUpirFieldStatementStorageClass 
   16006             :    used for the ast file IO. Do not chance by hand! 
   16007             : */
   16008           0 : class SgUpirFieldStatementStorageClass  : public SgUpirBaseStatementStorageClass
   16009             :    {
   16010             : 
   16011             :     protected: 
   16012             : 
   16013             : 
   16014             : /* #line 16015 "../../../src/frontend/SageIII//StorageClasses.h" */
   16015             : 
   16016             :        EasyStorage < SgOmpClausePtrList > storageOf_clauses;
   16017             : 
   16018             : 
   16019             : /* #line 10 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarStorageClassDeclatationMacros.macro" */
   16020             : 
   16021             : 
   16022             :     public:
   16023             :       void pickOutIRNodeData ( SgUpirFieldStatement* source );
   16024             :       static void arrangeStaticDataOfEasyStorageClassesInOneBlock ( );
   16025             :       static void deleteStaticDataOfEasyStorageClasses ( );
   16026             :       static void pickOutStaticDataMembers ( );
   16027             :       static void rebuildStaticDataMembers ( );
   16028             :       static void writeEasyStorageDataToFile (std::ostream& out);
   16029             :       static void readEasyStorageDataFromFile (std::istream& in);
   16030             :       static void writeStaticDataToFile (std::ostream& out );
   16031             :       static void readStaticDataFromFile (std::istream& in );
   16032             :       friend class SgUpirFieldStatement;
   16033             :    };
   16034             : /* #line 16035 "../../../src/frontend/SageIII//StorageClasses.h" */
   16035             : 
   16036             : 
   16037             : 
   16038             : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarStorageClassDeclatationMacros.macro" */
   16039             : /* 
   16040             :    JH (01/01/2006) ROSETTA generated class declarations for SgOmpCancelStatementStorageClass 
   16041             :    used for the ast file IO. Do not chance by hand! 
   16042             : */
   16043           0 : class SgOmpCancelStatementStorageClass  : public SgUpirFieldStatementStorageClass
   16044             :    {
   16045             : 
   16046             :     protected: 
   16047             : 
   16048             : 
   16049             : /* #line 16050 "../../../src/frontend/SageIII//StorageClasses.h" */
   16050             : 
   16051             : 
   16052             : 
   16053             : /* #line 10 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarStorageClassDeclatationMacros.macro" */
   16054             : 
   16055             : 
   16056             :     public:
   16057             :       void pickOutIRNodeData ( SgOmpCancelStatement* source );
   16058             :       static void arrangeStaticDataOfEasyStorageClassesInOneBlock ( );
   16059             :       static void deleteStaticDataOfEasyStorageClasses ( );
   16060             :       static void pickOutStaticDataMembers ( );
   16061             :       static void rebuildStaticDataMembers ( );
   16062             :       static void writeEasyStorageDataToFile (std::ostream& out);
   16063             :       static void readEasyStorageDataFromFile (std::istream& in);
   16064             :       static void writeStaticDataToFile (std::ostream& out );
   16065             :       static void readStaticDataFromFile (std::istream& in );
   16066             :       friend class SgOmpCancelStatement;
   16067             :    };
   16068             : /* #line 16069 "../../../src/frontend/SageIII//StorageClasses.h" */
   16069             : 
   16070             : 
   16071             : 
   16072             : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarStorageClassDeclatationMacros.macro" */
   16073             : /* 
   16074             :    JH (01/01/2006) ROSETTA generated class declarations for SgOmpCancellationPointStatementStorageClass 
   16075             :    used for the ast file IO. Do not chance by hand! 
   16076             : */
   16077           0 : class SgOmpCancellationPointStatementStorageClass  : public SgUpirFieldStatementStorageClass
   16078             :    {
   16079             : 
   16080             :     protected: 
   16081             : 
   16082             : 
   16083             : /* #line 16084 "../../../src/frontend/SageIII//StorageClasses.h" */
   16084             : 
   16085             : 
   16086             : 
   16087             : /* #line 10 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarStorageClassDeclatationMacros.macro" */
   16088             : 
   16089             : 
   16090             :     public:
   16091             :       void pickOutIRNodeData ( SgOmpCancellationPointStatement* source );
   16092             :       static void arrangeStaticDataOfEasyStorageClassesInOneBlock ( );
   16093             :       static void deleteStaticDataOfEasyStorageClasses ( );
   16094             :       static void pickOutStaticDataMembers ( );
   16095             :       static void rebuildStaticDataMembers ( );
   16096             :       static void writeEasyStorageDataToFile (std::ostream& out);
   16097             :       static void readEasyStorageDataFromFile (std::istream& in);
   16098             :       static void writeStaticDataToFile (std::ostream& out );
   16099             :       static void readStaticDataFromFile (std::istream& in );
   16100             :       friend class SgOmpCancellationPointStatement;
   16101             :    };
   16102             : /* #line 16103 "../../../src/frontend/SageIII//StorageClasses.h" */
   16103             : 
   16104             : 
   16105             : 
   16106             : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarStorageClassDeclatationMacros.macro" */
   16107             : /* 
   16108             :    JH (01/01/2006) ROSETTA generated class declarations for SgOmpTargetUpdateStatementStorageClass 
   16109             :    used for the ast file IO. Do not chance by hand! 
   16110             : */
   16111           0 : class SgOmpTargetUpdateStatementStorageClass  : public SgUpirFieldStatementStorageClass
   16112             :    {
   16113             : 
   16114             :     protected: 
   16115             : 
   16116             : 
   16117             : /* #line 16118 "../../../src/frontend/SageIII//StorageClasses.h" */
   16118             : 
   16119             : 
   16120             : 
   16121             : /* #line 10 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarStorageClassDeclatationMacros.macro" */
   16122             : 
   16123             : 
   16124             :     public:
   16125             :       void pickOutIRNodeData ( SgOmpTargetUpdateStatement* source );
   16126             :       static void arrangeStaticDataOfEasyStorageClassesInOneBlock ( );
   16127             :       static void deleteStaticDataOfEasyStorageClasses ( );
   16128             :       static void pickOutStaticDataMembers ( );
   16129             :       static void rebuildStaticDataMembers ( );
   16130             :       static void writeEasyStorageDataToFile (std::ostream& out);
   16131             :       static void readEasyStorageDataFromFile (std::istream& in);
   16132             :       static void writeStaticDataToFile (std::ostream& out );
   16133             :       static void readStaticDataFromFile (std::istream& in );
   16134             :       friend class SgOmpTargetUpdateStatement;
   16135             :    };
   16136             : /* #line 16137 "../../../src/frontend/SageIII//StorageClasses.h" */
   16137             : 
   16138             : 
   16139             : 
   16140             : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarStorageClassDeclatationMacros.macro" */
   16141             : /* 
   16142             :    JH (01/01/2006) ROSETTA generated class declarations for SgOmpFlushStatementStorageClass 
   16143             :    used for the ast file IO. Do not chance by hand! 
   16144             : */
   16145           0 : class SgOmpFlushStatementStorageClass  : public SgUpirFieldStatementStorageClass
   16146             :    {
   16147             : 
   16148             :     protected: 
   16149             : 
   16150             : 
   16151             : /* #line 16152 "../../../src/frontend/SageIII//StorageClasses.h" */
   16152             : 
   16153             :        EasyStorage < SgVarRefExpPtrList > storageOf_variables;
   16154             : 
   16155             : 
   16156             : /* #line 10 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarStorageClassDeclatationMacros.macro" */
   16157             : 
   16158             : 
   16159             :     public:
   16160             :       void pickOutIRNodeData ( SgOmpFlushStatement* source );
   16161             :       static void arrangeStaticDataOfEasyStorageClassesInOneBlock ( );
   16162             :       static void deleteStaticDataOfEasyStorageClasses ( );
   16163             :       static void pickOutStaticDataMembers ( );
   16164             :       static void rebuildStaticDataMembers ( );
   16165             :       static void writeEasyStorageDataToFile (std::ostream& out);
   16166             :       static void readEasyStorageDataFromFile (std::istream& in);
   16167             :       static void writeStaticDataToFile (std::ostream& out );
   16168             :       static void readStaticDataFromFile (std::istream& in );
   16169             :       friend class SgOmpFlushStatement;
   16170             :    };
   16171             : /* #line 16172 "../../../src/frontend/SageIII//StorageClasses.h" */
   16172             : 
   16173             : 
   16174             : 
   16175             : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarStorageClassDeclatationMacros.macro" */
   16176             : /* 
   16177             :    JH (01/01/2006) ROSETTA generated class declarations for SgOmpAllocateStatementStorageClass 
   16178             :    used for the ast file IO. Do not chance by hand! 
   16179             : */
   16180           0 : class SgOmpAllocateStatementStorageClass  : public SgUpirFieldStatementStorageClass
   16181             :    {
   16182             : 
   16183             :     protected: 
   16184             : 
   16185             : 
   16186             : /* #line 16187 "../../../src/frontend/SageIII//StorageClasses.h" */
   16187             : 
   16188             :        EasyStorage < SgVarRefExpPtrList > storageOf_variables;
   16189             : 
   16190             : 
   16191             : /* #line 10 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarStorageClassDeclatationMacros.macro" */
   16192             : 
   16193             : 
   16194             :     public:
   16195             :       void pickOutIRNodeData ( SgOmpAllocateStatement* source );
   16196             :       static void arrangeStaticDataOfEasyStorageClassesInOneBlock ( );
   16197             :       static void deleteStaticDataOfEasyStorageClasses ( );
   16198             :       static void pickOutStaticDataMembers ( );
   16199             :       static void rebuildStaticDataMembers ( );
   16200             :       static void writeEasyStorageDataToFile (std::ostream& out);
   16201             :       static void readEasyStorageDataFromFile (std::istream& in);
   16202             :       static void writeStaticDataToFile (std::ostream& out );
   16203             :       static void readStaticDataFromFile (std::istream& in );
   16204             :       friend class SgOmpAllocateStatement;
   16205             :    };
   16206             : /* #line 16207 "../../../src/frontend/SageIII//StorageClasses.h" */
   16207             : 
   16208             : 
   16209             : 
   16210             : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarStorageClassDeclatationMacros.macro" */
   16211             : /* 
   16212             :    JH (01/01/2006) ROSETTA generated class declarations for SgOmpOrderedDependStatementStorageClass 
   16213             :    used for the ast file IO. Do not chance by hand! 
   16214             : */
   16215           0 : class SgOmpOrderedDependStatementStorageClass  : public SgUpirFieldStatementStorageClass
   16216             :    {
   16217             : 
   16218             :     protected: 
   16219             : 
   16220             : 
   16221             : /* #line 16222 "../../../src/frontend/SageIII//StorageClasses.h" */
   16222             : 
   16223             : 
   16224             : 
   16225             : /* #line 10 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarStorageClassDeclatationMacros.macro" */
   16226             : 
   16227             : 
   16228             :     public:
   16229             :       void pickOutIRNodeData ( SgOmpOrderedDependStatement* source );
   16230             :       static void arrangeStaticDataOfEasyStorageClassesInOneBlock ( );
   16231             :       static void deleteStaticDataOfEasyStorageClasses ( );
   16232             :       static void pickOutStaticDataMembers ( );
   16233             :       static void rebuildStaticDataMembers ( );
   16234             :       static void writeEasyStorageDataToFile (std::ostream& out);
   16235             :       static void readEasyStorageDataFromFile (std::istream& in);
   16236             :       static void writeStaticDataToFile (std::ostream& out );
   16237             :       static void readStaticDataFromFile (std::istream& in );
   16238             :       friend class SgOmpOrderedDependStatement;
   16239             :    };
   16240             : /* #line 16241 "../../../src/frontend/SageIII//StorageClasses.h" */
   16241             : 
   16242             : 
   16243             : 
   16244             : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarStorageClassDeclatationMacros.macro" */
   16245             : /* 
   16246             :    JH (01/01/2006) ROSETTA generated class declarations for SgUpirSyncStatementStorageClass 
   16247             :    used for the ast file IO. Do not chance by hand! 
   16248             : */
   16249           0 : class SgUpirSyncStatementStorageClass  : public SgUpirFieldStatementStorageClass
   16250             :    {
   16251             : 
   16252             :     protected: 
   16253             : 
   16254             : 
   16255             : /* #line 16256 "../../../src/frontend/SageIII//StorageClasses.h" */
   16256             : 
   16257             : 
   16258             : 
   16259             : /* #line 10 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarStorageClassDeclatationMacros.macro" */
   16260             : 
   16261             : 
   16262             :     public:
   16263             :       void pickOutIRNodeData ( SgUpirSyncStatement* source );
   16264             :       static void arrangeStaticDataOfEasyStorageClassesInOneBlock ( );
   16265             :       static void deleteStaticDataOfEasyStorageClasses ( );
   16266             :       static void pickOutStaticDataMembers ( );
   16267             :       static void rebuildStaticDataMembers ( );
   16268             :       static void writeEasyStorageDataToFile (std::ostream& out);
   16269             :       static void readEasyStorageDataFromFile (std::istream& in);
   16270             :       static void writeStaticDataToFile (std::ostream& out );
   16271             :       static void readStaticDataFromFile (std::istream& in );
   16272             :       friend class SgUpirSyncStatement;
   16273             :    };
   16274             : /* #line 16275 "../../../src/frontend/SageIII//StorageClasses.h" */
   16275             : 
   16276             : 
   16277             : 
   16278             : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarStorageClassDeclatationMacros.macro" */
   16279             : /* 
   16280             :    JH (01/01/2006) ROSETTA generated class declarations for SgUpirLoopParallelStatementStorageClass 
   16281             :    used for the ast file IO. Do not chance by hand! 
   16282             : */
   16283           0 : class SgUpirLoopParallelStatementStorageClass  : public SgUpirFieldStatementStorageClass
   16284             :    {
   16285             : 
   16286             :     protected: 
   16287             : 
   16288             : 
   16289             : /* #line 16290 "../../../src/frontend/SageIII//StorageClasses.h" */
   16290             : 
   16291             :      unsigned long storageOf_worksharing;
   16292             :      unsigned long storageOf_simd;
   16293             :      unsigned long storageOf_taskloop;
   16294             :      unsigned long storageOf_loop;
   16295             : 
   16296             : 
   16297             : /* #line 10 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarStorageClassDeclatationMacros.macro" */
   16298             : 
   16299             : 
   16300             :     public:
   16301             :       void pickOutIRNodeData ( SgUpirLoopParallelStatement* source );
   16302             :       static void arrangeStaticDataOfEasyStorageClassesInOneBlock ( );
   16303             :       static void deleteStaticDataOfEasyStorageClasses ( );
   16304             :       static void pickOutStaticDataMembers ( );
   16305             :       static void rebuildStaticDataMembers ( );
   16306             :       static void writeEasyStorageDataToFile (std::ostream& out);
   16307             :       static void readEasyStorageDataFromFile (std::istream& in);
   16308             :       static void writeStaticDataToFile (std::ostream& out );
   16309             :       static void readStaticDataFromFile (std::istream& in );
   16310             :       friend class SgUpirLoopParallelStatement;
   16311             :    };
   16312             : /* #line 16313 "../../../src/frontend/SageIII//StorageClasses.h" */
   16313             : 
   16314             : 
   16315             : 
   16316             : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarStorageClassDeclatationMacros.macro" */
   16317             : /* 
   16318             :    JH (01/01/2006) ROSETTA generated class declarations for SgUpirWorksharingStatementStorageClass 
   16319             :    used for the ast file IO. Do not chance by hand! 
   16320             : */
   16321           0 : class SgUpirWorksharingStatementStorageClass  : public SgUpirFieldStatementStorageClass
   16322             :    {
   16323             : 
   16324             :     protected: 
   16325             : 
   16326             : 
   16327             : /* #line 16328 "../../../src/frontend/SageIII//StorageClasses.h" */
   16328             : 
   16329             : 
   16330             : 
   16331             : /* #line 10 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarStorageClassDeclatationMacros.macro" */
   16332             : 
   16333             : 
   16334             :     public:
   16335             :       void pickOutIRNodeData ( SgUpirWorksharingStatement* source );
   16336             :       static void arrangeStaticDataOfEasyStorageClassesInOneBlock ( );
   16337             :       static void deleteStaticDataOfEasyStorageClasses ( );
   16338             :       static void pickOutStaticDataMembers ( );
   16339             :       static void rebuildStaticDataMembers ( );
   16340             :       static void writeEasyStorageDataToFile (std::ostream& out);
   16341             :       static void readEasyStorageDataFromFile (std::istream& in);
   16342             :       static void writeStaticDataToFile (std::ostream& out );
   16343             :       static void readStaticDataFromFile (std::istream& in );
   16344             :       friend class SgUpirWorksharingStatement;
   16345             :    };
   16346             : /* #line 16347 "../../../src/frontend/SageIII//StorageClasses.h" */
   16347             : 
   16348             : 
   16349             : 
   16350             : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarStorageClassDeclatationMacros.macro" */
   16351             : /* 
   16352             :    JH (01/01/2006) ROSETTA generated class declarations for SgUpirSimdStatementStorageClass 
   16353             :    used for the ast file IO. Do not chance by hand! 
   16354             : */
   16355           0 : class SgUpirSimdStatementStorageClass  : public SgUpirFieldStatementStorageClass
   16356             :    {
   16357             : 
   16358             :     protected: 
   16359             : 
   16360             : 
   16361             : /* #line 16362 "../../../src/frontend/SageIII//StorageClasses.h" */
   16362             : 
   16363             : 
   16364             : 
   16365             : /* #line 10 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarStorageClassDeclatationMacros.macro" */
   16366             : 
   16367             : 
   16368             :     public:
   16369             :       void pickOutIRNodeData ( SgUpirSimdStatement* source );
   16370             :       static void arrangeStaticDataOfEasyStorageClassesInOneBlock ( );
   16371             :       static void deleteStaticDataOfEasyStorageClasses ( );
   16372             :       static void pickOutStaticDataMembers ( );
   16373             :       static void rebuildStaticDataMembers ( );
   16374             :       static void writeEasyStorageDataToFile (std::ostream& out);
   16375             :       static void readEasyStorageDataFromFile (std::istream& in);
   16376             :       static void writeStaticDataToFile (std::ostream& out );
   16377             :       static void readStaticDataFromFile (std::istream& in );
   16378             :       friend class SgUpirSimdStatement;
   16379             :    };
   16380             : /* #line 16381 "../../../src/frontend/SageIII//StorageClasses.h" */
   16381             : 
   16382             : 
   16383             : 
   16384             : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarStorageClassDeclatationMacros.macro" */
   16385             : /* 
   16386             :    JH (01/01/2006) ROSETTA generated class declarations for SgOmpDeclareMapperStatementStorageClass 
   16387             :    used for the ast file IO. Do not chance by hand! 
   16388             : */
   16389           0 : class SgOmpDeclareMapperStatementStorageClass  : public SgUpirBaseStatementStorageClass
   16390             :    {
   16391             : 
   16392             :     protected: 
   16393             : 
   16394             : 
   16395             : /* #line 16396 "../../../src/frontend/SageIII//StorageClasses.h" */
   16396             : 
   16397             : 
   16398             : 
   16399             : /* #line 10 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarStorageClassDeclatationMacros.macro" */
   16400             : 
   16401             : 
   16402             :     public:
   16403             :       void pickOutIRNodeData ( SgOmpDeclareMapperStatement* source );
   16404             :       static void arrangeStaticDataOfEasyStorageClassesInOneBlock ( );
   16405             :       static void deleteStaticDataOfEasyStorageClasses ( );
   16406             :       static void pickOutStaticDataMembers ( );
   16407             :       static void rebuildStaticDataMembers ( );
   16408             :       static void writeEasyStorageDataToFile (std::ostream& out);
   16409             :       static void readEasyStorageDataFromFile (std::istream& in);
   16410             :       static void writeStaticDataToFile (std::ostream& out );
   16411             :       static void readStaticDataFromFile (std::istream& in );
   16412             :       friend class SgOmpDeclareMapperStatement;
   16413             :    };
   16414             : /* #line 16415 "../../../src/frontend/SageIII//StorageClasses.h" */
   16415             : 
   16416             : 
   16417             : 
   16418             : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarStorageClassDeclatationMacros.macro" */
   16419             : /* 
   16420             :    JH (01/01/2006) ROSETTA generated class declarations for SgSequenceStatementStorageClass 
   16421             :    used for the ast file IO. Do not chance by hand! 
   16422             : */
   16423           0 : class SgSequenceStatementStorageClass  : public SgStatementStorageClass
   16424             :    {
   16425             : 
   16426             :     protected: 
   16427             : 
   16428             : 
   16429             : /* #line 16430 "../../../src/frontend/SageIII//StorageClasses.h" */
   16430             : 
   16431             : 
   16432             : 
   16433             : /* #line 10 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarStorageClassDeclatationMacros.macro" */
   16434             : 
   16435             : 
   16436             :     public:
   16437             :       void pickOutIRNodeData ( SgSequenceStatement* source );
   16438             :       static void arrangeStaticDataOfEasyStorageClassesInOneBlock ( );
   16439             :       static void deleteStaticDataOfEasyStorageClasses ( );
   16440             :       static void pickOutStaticDataMembers ( );
   16441             :       static void rebuildStaticDataMembers ( );
   16442             :       static void writeEasyStorageDataToFile (std::ostream& out);
   16443             :       static void readEasyStorageDataFromFile (std::istream& in);
   16444             :       static void writeStaticDataToFile (std::ostream& out );
   16445             :       static void readStaticDataFromFile (std::istream& in );
   16446             :       friend class SgSequenceStatement;
   16447             :    };
   16448             : /* #line 16449 "../../../src/frontend/SageIII//StorageClasses.h" */
   16449             : 
   16450             : 
   16451             : 
   16452             : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarStorageClassDeclatationMacros.macro" */
   16453             : /* 
   16454             :    JH (01/01/2006) ROSETTA generated class declarations for SgWithStatementStorageClass 
   16455             :    used for the ast file IO. Do not chance by hand! 
   16456             : */
   16457           0 : class SgWithStatementStorageClass  : public SgStatementStorageClass
   16458             :    {
   16459             : 
   16460             :     protected: 
   16461             : 
   16462             : 
   16463             : /* #line 16464 "../../../src/frontend/SageIII//StorageClasses.h" */
   16464             : 
   16465             :      unsigned long storageOf_expression;
   16466             :      unsigned long storageOf_body;
   16467             : 
   16468             : 
   16469             : /* #line 10 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarStorageClassDeclatationMacros.macro" */
   16470             : 
   16471             : 
   16472             :     public:
   16473             :       void pickOutIRNodeData ( SgWithStatement* source );
   16474             :       static void arrangeStaticDataOfEasyStorageClassesInOneBlock ( );
   16475             :       static void deleteStaticDataOfEasyStorageClasses ( );
   16476             :       static void pickOutStaticDataMembers ( );
   16477             :       static void rebuildStaticDataMembers ( );
   16478             :       static void writeEasyStorageDataToFile (std::ostream& out);
   16479             :       static void readEasyStorageDataFromFile (std::istream& in);
   16480             :       static void writeStaticDataToFile (std::ostream& out );
   16481             :       static void readStaticDataFromFile (std::istream& in );
   16482             :       friend class SgWithStatement;
   16483             :    };
   16484             : /* #line 16485 "../../../src/frontend/SageIII//StorageClasses.h" */
   16485             : 
   16486             : 
   16487             : 
   16488             : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarStorageClassDeclatationMacros.macro" */
   16489             : /* 
   16490             :    JH (01/01/2006) ROSETTA generated class declarations for SgPassStatementStorageClass 
   16491             :    used for the ast file IO. Do not chance by hand! 
   16492             : */
   16493           0 : class SgPassStatementStorageClass  : public SgStatementStorageClass
   16494             :    {
   16495             : 
   16496             :     protected: 
   16497             : 
   16498             : 
   16499             : /* #line 16500 "../../../src/frontend/SageIII//StorageClasses.h" */
   16500             : 
   16501             : 
   16502             : 
   16503             : /* #line 10 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarStorageClassDeclatationMacros.macro" */
   16504             : 
   16505             : 
   16506             :     public:
   16507             :       void pickOutIRNodeData ( SgPassStatement* source );
   16508             :       static void arrangeStaticDataOfEasyStorageClassesInOneBlock ( );
   16509             :       static void deleteStaticDataOfEasyStorageClasses ( );
   16510             :       static void pickOutStaticDataMembers ( );
   16511             :       static void rebuildStaticDataMembers ( );
   16512             :       static void writeEasyStorageDataToFile (std::ostream& out);
   16513             :       static void readEasyStorageDataFromFile (std::istream& in);
   16514             :       static void writeStaticDataToFile (std::ostream& out );
   16515             :       static void readStaticDataFromFile (std::istream& in );
   16516             :       friend class SgPassStatement;
   16517             :    };
   16518             : /* #line 16519 "../../../src/frontend/SageIII//StorageClasses.h" */
   16519             : 
   16520             : 
   16521             : 
   16522             : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarStorageClassDeclatationMacros.macro" */
   16523             : /* 
   16524             :    JH (01/01/2006) ROSETTA generated class declarations for SgAssertStmtStorageClass 
   16525             :    used for the ast file IO. Do not chance by hand! 
   16526             : */
   16527           0 : class SgAssertStmtStorageClass  : public SgStatementStorageClass
   16528             :    {
   16529             : 
   16530             :     protected: 
   16531             : 
   16532             : 
   16533             : /* #line 16534 "../../../src/frontend/SageIII//StorageClasses.h" */
   16534             : 
   16535             :      unsigned long storageOf_test;
   16536             :      unsigned long storageOf_exception_argument;
   16537             : 
   16538             : 
   16539             : /* #line 10 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarStorageClassDeclatationMacros.macro" */
   16540             : 
   16541             : 
   16542             :     public:
   16543             :       void pickOutIRNodeData ( SgAssertStmt* source );
   16544             :       static void arrangeStaticDataOfEasyStorageClassesInOneBlock ( );
   16545             :       static void deleteStaticDataOfEasyStorageClasses ( );
   16546             :       static void pickOutStaticDataMembers ( );
   16547             :       static void rebuildStaticDataMembers ( );
   16548             :       static void writeEasyStorageDataToFile (std::ostream& out);
   16549             :       static void readEasyStorageDataFromFile (std::istream& in);
   16550             :       static void writeStaticDataToFile (std::ostream& out );
   16551             :       static void readStaticDataFromFile (std::istream& in );
   16552             :       friend class SgAssertStmt;
   16553             :    };
   16554             : /* #line 16555 "../../../src/frontend/SageIII//StorageClasses.h" */
   16555             : 
   16556             : 
   16557             : 
   16558             : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarStorageClassDeclatationMacros.macro" */
   16559             : /* 
   16560             :    JH (01/01/2006) ROSETTA generated class declarations for SgExecStatementStorageClass 
   16561             :    used for the ast file IO. Do not chance by hand! 
   16562             : */
   16563           0 : class SgExecStatementStorageClass  : public SgStatementStorageClass
   16564             :    {
   16565             : 
   16566             :     protected: 
   16567             : 
   16568             : 
   16569             : /* #line 16570 "../../../src/frontend/SageIII//StorageClasses.h" */
   16570             : 
   16571             :      unsigned long storageOf_executable;
   16572             :      unsigned long storageOf_globals;
   16573             :      unsigned long storageOf_locals;
   16574             : 
   16575             : 
   16576             : /* #line 10 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarStorageClassDeclatationMacros.macro" */
   16577             : 
   16578             : 
   16579             :     public:
   16580             :       void pickOutIRNodeData ( SgExecStatement* source );
   16581             :       static void arrangeStaticDataOfEasyStorageClassesInOneBlock ( );
   16582             :       static void deleteStaticDataOfEasyStorageClasses ( );
   16583             :       static void pickOutStaticDataMembers ( );
   16584             :       static void rebuildStaticDataMembers ( );
   16585             :       static void writeEasyStorageDataToFile (std::ostream& out);
   16586             :       static void readEasyStorageDataFromFile (std::istream& in);
   16587             :       static void writeStaticDataToFile (std::ostream& out );
   16588             :       static void readStaticDataFromFile (std::istream& in );
   16589             :       friend class SgExecStatement;
   16590             :    };
   16591             : /* #line 16592 "../../../src/frontend/SageIII//StorageClasses.h" */
   16592             : 
   16593             : 
   16594             : 
   16595             : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarStorageClassDeclatationMacros.macro" */
   16596             : /* 
   16597             :    JH (01/01/2006) ROSETTA generated class declarations for SgImageControlStatementStorageClass 
   16598             :    used for the ast file IO. Do not chance by hand! 
   16599             : */
   16600           0 : class SgImageControlStatementStorageClass  : public SgStatementStorageClass
   16601             :    {
   16602             : 
   16603             :     protected: 
   16604             : 
   16605             : 
   16606             : /* #line 16607 "../../../src/frontend/SageIII//StorageClasses.h" */
   16607             : 
   16608             :       SgImageControlStatement::image_control_statement_enum storageOf_image_control_statement;
   16609             :      unsigned long storageOf_stat;
   16610             :      unsigned long storageOf_err_msg;
   16611             :      unsigned long storageOf_acquired_lock;
   16612             : 
   16613             : 
   16614             : /* #line 10 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarStorageClassDeclatationMacros.macro" */
   16615             : 
   16616             : 
   16617             :     public:
   16618             :       void pickOutIRNodeData ( SgImageControlStatement* source );
   16619             :       static void arrangeStaticDataOfEasyStorageClassesInOneBlock ( );
   16620             :       static void deleteStaticDataOfEasyStorageClasses ( );
   16621             :       static void pickOutStaticDataMembers ( );
   16622             :       static void rebuildStaticDataMembers ( );
   16623             :       static void writeEasyStorageDataToFile (std::ostream& out);
   16624             :       static void readEasyStorageDataFromFile (std::istream& in);
   16625             :       static void writeStaticDataToFile (std::ostream& out );
   16626             :       static void readStaticDataFromFile (std::istream& in );
   16627             :       friend class SgImageControlStatement;
   16628             :    };
   16629             : /* #line 16630 "../../../src/frontend/SageIII//StorageClasses.h" */
   16630             : 
   16631             : 
   16632             : 
   16633             : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarStorageClassDeclatationMacros.macro" */
   16634             : /* 
   16635             :    JH (01/01/2006) ROSETTA generated class declarations for SgSyncAllStatementStorageClass 
   16636             :    used for the ast file IO. Do not chance by hand! 
   16637             : */
   16638           0 : class SgSyncAllStatementStorageClass  : public SgImageControlStatementStorageClass
   16639             :    {
   16640             : 
   16641             :     protected: 
   16642             : 
   16643             : 
   16644             : /* #line 16645 "../../../src/frontend/SageIII//StorageClasses.h" */
   16645             : 
   16646             : 
   16647             : 
   16648             : /* #line 10 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarStorageClassDeclatationMacros.macro" */
   16649             : 
   16650             : 
   16651             :     public:
   16652             :       void pickOutIRNodeData ( SgSyncAllStatement* source );
   16653             :       static void arrangeStaticDataOfEasyStorageClassesInOneBlock ( );
   16654             :       static void deleteStaticDataOfEasyStorageClasses ( );
   16655             :       static void pickOutStaticDataMembers ( );
   16656             :       static void rebuildStaticDataMembers ( );
   16657             :       static void writeEasyStorageDataToFile (std::ostream& out);
   16658             :       static void readEasyStorageDataFromFile (std::istream& in);
   16659             :       static void writeStaticDataToFile (std::ostream& out );
   16660             :       static void readStaticDataFromFile (std::istream& in );
   16661             :       friend class SgSyncAllStatement;
   16662             :    };
   16663             : /* #line 16664 "../../../src/frontend/SageIII//StorageClasses.h" */
   16664             : 
   16665             : 
   16666             : 
   16667             : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarStorageClassDeclatationMacros.macro" */
   16668             : /* 
   16669             :    JH (01/01/2006) ROSETTA generated class declarations for SgSyncImagesStatementStorageClass 
   16670             :    used for the ast file IO. Do not chance by hand! 
   16671             : */
   16672           0 : class SgSyncImagesStatementStorageClass  : public SgImageControlStatementStorageClass
   16673             :    {
   16674             : 
   16675             :     protected: 
   16676             : 
   16677             : 
   16678             : /* #line 16679 "../../../src/frontend/SageIII//StorageClasses.h" */
   16679             : 
   16680             :      unsigned long storageOf_image_set;
   16681             : 
   16682             : 
   16683             : /* #line 10 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarStorageClassDeclatationMacros.macro" */
   16684             : 
   16685             : 
   16686             :     public:
   16687             :       void pickOutIRNodeData ( SgSyncImagesStatement* source );
   16688             :       static void arrangeStaticDataOfEasyStorageClassesInOneBlock ( );
   16689             :       static void deleteStaticDataOfEasyStorageClasses ( );
   16690             :       static void pickOutStaticDataMembers ( );
   16691             :       static void rebuildStaticDataMembers ( );
   16692             :       static void writeEasyStorageDataToFile (std::ostream& out);
   16693             :       static void readEasyStorageDataFromFile (std::istream& in);
   16694             :       static void writeStaticDataToFile (std::ostream& out );
   16695             :       static void readStaticDataFromFile (std::istream& in );
   16696             :       friend class SgSyncImagesStatement;
   16697             :    };
   16698             : /* #line 16699 "../../../src/frontend/SageIII//StorageClasses.h" */
   16699             : 
   16700             : 
   16701             : 
   16702             : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarStorageClassDeclatationMacros.macro" */
   16703             : /* 
   16704             :    JH (01/01/2006) ROSETTA generated class declarations for SgSyncMemoryStatementStorageClass 
   16705             :    used for the ast file IO. Do not chance by hand! 
   16706             : */
   16707           0 : class SgSyncMemoryStatementStorageClass  : public SgImageControlStatementStorageClass
   16708             :    {
   16709             : 
   16710             :     protected: 
   16711             : 
   16712             : 
   16713             : /* #line 16714 "../../../src/frontend/SageIII//StorageClasses.h" */
   16714             : 
   16715             : 
   16716             : 
   16717             : /* #line 10 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarStorageClassDeclatationMacros.macro" */
   16718             : 
   16719             : 
   16720             :     public:
   16721             :       void pickOutIRNodeData ( SgSyncMemoryStatement* source );
   16722             :       static void arrangeStaticDataOfEasyStorageClassesInOneBlock ( );
   16723             :       static void deleteStaticDataOfEasyStorageClasses ( );
   16724             :       static void pickOutStaticDataMembers ( );
   16725             :       static void rebuildStaticDataMembers ( );
   16726             :       static void writeEasyStorageDataToFile (std::ostream& out);
   16727             :       static void readEasyStorageDataFromFile (std::istream& in);
   16728             :       static void writeStaticDataToFile (std::ostream& out );
   16729             :       static void readStaticDataFromFile (std::istream& in );
   16730             :       friend class SgSyncMemoryStatement;
   16731             :    };
   16732             : /* #line 16733 "../../../src/frontend/SageIII//StorageClasses.h" */
   16733             : 
   16734             : 
   16735             : 
   16736             : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarStorageClassDeclatationMacros.macro" */
   16737             : /* 
   16738             :    JH (01/01/2006) ROSETTA generated class declarations for SgSyncTeamStatementStorageClass 
   16739             :    used for the ast file IO. Do not chance by hand! 
   16740             : */
   16741           0 : class SgSyncTeamStatementStorageClass  : public SgImageControlStatementStorageClass
   16742             :    {
   16743             : 
   16744             :     protected: 
   16745             : 
   16746             : 
   16747             : /* #line 16748 "../../../src/frontend/SageIII//StorageClasses.h" */
   16748             : 
   16749             :      unsigned long storageOf_team_value;
   16750             : 
   16751             : 
   16752             : /* #line 10 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarStorageClassDeclatationMacros.macro" */
   16753             : 
   16754             : 
   16755             :     public:
   16756             :       void pickOutIRNodeData ( SgSyncTeamStatement* source );
   16757             :       static void arrangeStaticDataOfEasyStorageClassesInOneBlock ( );
   16758             :       static void deleteStaticDataOfEasyStorageClasses ( );
   16759             :       static void pickOutStaticDataMembers ( );
   16760             :       static void rebuildStaticDataMembers ( );
   16761             :       static void writeEasyStorageDataToFile (std::ostream& out);
   16762             :       static void readEasyStorageDataFromFile (std::istream& in);
   16763             :       static void writeStaticDataToFile (std::ostream& out );
   16764             :       static void readStaticDataFromFile (std::istream& in );
   16765             :       friend class SgSyncTeamStatement;
   16766             :    };
   16767             : /* #line 16768 "../../../src/frontend/SageIII//StorageClasses.h" */
   16768             : 
   16769             : 
   16770             : 
   16771             : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarStorageClassDeclatationMacros.macro" */
   16772             : /* 
   16773             :    JH (01/01/2006) ROSETTA generated class declarations for SgLockStatementStorageClass 
   16774             :    used for the ast file IO. Do not chance by hand! 
   16775             : */
   16776           0 : class SgLockStatementStorageClass  : public SgImageControlStatementStorageClass
   16777             :    {
   16778             : 
   16779             :     protected: 
   16780             : 
   16781             : 
   16782             : /* #line 16783 "../../../src/frontend/SageIII//StorageClasses.h" */
   16783             : 
   16784             :      unsigned long storageOf_lock_variable;
   16785             : 
   16786             : 
   16787             : /* #line 10 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarStorageClassDeclatationMacros.macro" */
   16788             : 
   16789             : 
   16790             :     public:
   16791             :       void pickOutIRNodeData ( SgLockStatement* source );
   16792             :       static void arrangeStaticDataOfEasyStorageClassesInOneBlock ( );
   16793             :       static void deleteStaticDataOfEasyStorageClasses ( );
   16794             :       static void pickOutStaticDataMembers ( );
   16795             :       static void rebuildStaticDataMembers ( );
   16796             :       static void writeEasyStorageDataToFile (std::ostream& out);
   16797             :       static void readEasyStorageDataFromFile (std::istream& in);
   16798             :       static void writeStaticDataToFile (std::ostream& out );
   16799             :       static void readStaticDataFromFile (std::istream& in );
   16800             :       friend class SgLockStatement;
   16801             :    };
   16802             : /* #line 16803 "../../../src/frontend/SageIII//StorageClasses.h" */
   16803             : 
   16804             : 
   16805             : 
   16806             : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarStorageClassDeclatationMacros.macro" */
   16807             : /* 
   16808             :    JH (01/01/2006) ROSETTA generated class declarations for SgUnlockStatementStorageClass 
   16809             :    used for the ast file IO. Do not chance by hand! 
   16810             : */
   16811           0 : class SgUnlockStatementStorageClass  : public SgImageControlStatementStorageClass
   16812             :    {
   16813             : 
   16814             :     protected: 
   16815             : 
   16816             : 
   16817             : /* #line 16818 "../../../src/frontend/SageIII//StorageClasses.h" */
   16818             : 
   16819             :      unsigned long storageOf_lock_variable;
   16820             : 
   16821             : 
   16822             : /* #line 10 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarStorageClassDeclatationMacros.macro" */
   16823             : 
   16824             : 
   16825             :     public:
   16826             :       void pickOutIRNodeData ( SgUnlockStatement* source );
   16827             :       static void arrangeStaticDataOfEasyStorageClassesInOneBlock ( );
   16828             :       static void deleteStaticDataOfEasyStorageClasses ( );
   16829             :       static void pickOutStaticDataMembers ( );
   16830             :       static void rebuildStaticDataMembers ( );
   16831             :       static void writeEasyStorageDataToFile (std::ostream& out);
   16832             :       static void readEasyStorageDataFromFile (std::istream& in);
   16833             :       static void writeStaticDataToFile (std::ostream& out );
   16834             :       static void readStaticDataFromFile (std::istream& in );
   16835             :       friend class SgUnlockStatement;
   16836             :    };
   16837             : /* #line 16838 "../../../src/frontend/SageIII//StorageClasses.h" */
   16838             : 
   16839             : 
   16840             : 
   16841             : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarStorageClassDeclatationMacros.macro" */
   16842             : /* 
   16843             :    JH (01/01/2006) ROSETTA generated class declarations for SgExpressionStorageClass 
   16844             :    used for the ast file IO. Do not chance by hand! 
   16845             : */
   16846           0 : class SgExpressionStorageClass  : public SgLocatedNodeStorageClass
   16847             :    {
   16848             : 
   16849             :     protected: 
   16850             : 
   16851             : 
   16852             : /* #line 16853 "../../../src/frontend/SageIII//StorageClasses.h" */
   16853             : 
   16854             :       bool storageOf_need_paren;
   16855             :       bool storageOf_lvalue;
   16856             :       bool storageOf_global_qualified_name;
   16857             :      unsigned long storageOf_operatorPosition;
   16858             : 
   16859             : 
   16860             : /* #line 10 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarStorageClassDeclatationMacros.macro" */
   16861             : 
   16862             : 
   16863             :     public:
   16864             :       void pickOutIRNodeData ( SgExpression* source );
   16865             :       static void arrangeStaticDataOfEasyStorageClassesInOneBlock ( );
   16866             :       static void deleteStaticDataOfEasyStorageClasses ( );
   16867             :       static void pickOutStaticDataMembers ( );
   16868             :       static void rebuildStaticDataMembers ( );
   16869             :       static void writeEasyStorageDataToFile (std::ostream& out);
   16870             :       static void readEasyStorageDataFromFile (std::istream& in);
   16871             :       static void writeStaticDataToFile (std::ostream& out );
   16872             :       static void readStaticDataFromFile (std::istream& in );
   16873             :       friend class SgExpression;
   16874             :    };
   16875             : /* #line 16876 "../../../src/frontend/SageIII//StorageClasses.h" */
   16876             : 
   16877             : 
   16878             : 
   16879             : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarStorageClassDeclatationMacros.macro" */
   16880             : /* 
   16881             :    JH (01/01/2006) ROSETTA generated class declarations for SgUnaryOpStorageClass 
   16882             :    used for the ast file IO. Do not chance by hand! 
   16883             : */
   16884           0 : class SgUnaryOpStorageClass  : public SgExpressionStorageClass
   16885             :    {
   16886             : 
   16887             :     protected: 
   16888             : 
   16889             : 
   16890             : /* #line 16891 "../../../src/frontend/SageIII//StorageClasses.h" */
   16891             : 
   16892             :      unsigned long storageOf_operand_i;
   16893             :      unsigned long storageOf_expression_type;
   16894             :       SgUnaryOp::Sgop_mode storageOf_mode;
   16895             : 
   16896             : 
   16897             : /* #line 10 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarStorageClassDeclatationMacros.macro" */
   16898             : 
   16899             : 
   16900             :     public:
   16901             :       void pickOutIRNodeData ( SgUnaryOp* source );
   16902             :       static void arrangeStaticDataOfEasyStorageClassesInOneBlock ( );
   16903             :       static void deleteStaticDataOfEasyStorageClasses ( );
   16904             :       static void pickOutStaticDataMembers ( );
   16905             :       static void rebuildStaticDataMembers ( );
   16906             :       static void writeEasyStorageDataToFile (std::ostream& out);
   16907             :       static void readEasyStorageDataFromFile (std::istream& in);
   16908             :       static void writeStaticDataToFile (std::ostream& out );
   16909             :       static void readStaticDataFromFile (std::istream& in );
   16910             :       friend class SgUnaryOp;
   16911             :    };
   16912             : /* #line 16913 "../../../src/frontend/SageIII//StorageClasses.h" */
   16913             : 
   16914             : 
   16915             : 
   16916             : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarStorageClassDeclatationMacros.macro" */
   16917             : /* 
   16918             :    JH (01/01/2006) ROSETTA generated class declarations for SgExpressionRootStorageClass 
   16919             :    used for the ast file IO. Do not chance by hand! 
   16920             : */
   16921           0 : class SgExpressionRootStorageClass  : public SgUnaryOpStorageClass
   16922             :    {
   16923             : 
   16924             :     protected: 
   16925             : 
   16926             : 
   16927             : /* #line 16928 "../../../src/frontend/SageIII//StorageClasses.h" */
   16928             : 
   16929             : 
   16930             : 
   16931             : /* #line 10 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarStorageClassDeclatationMacros.macro" */
   16932             : 
   16933             : 
   16934             :     public:
   16935             :       void pickOutIRNodeData ( SgExpressionRoot* source );
   16936             :       static void arrangeStaticDataOfEasyStorageClassesInOneBlock ( );
   16937             :       static void deleteStaticDataOfEasyStorageClasses ( );
   16938             :       static void pickOutStaticDataMembers ( );
   16939             :       static void rebuildStaticDataMembers ( );
   16940             :       static void writeEasyStorageDataToFile (std::ostream& out);
   16941             :       static void readEasyStorageDataFromFile (std::istream& in);
   16942             :       static void writeStaticDataToFile (std::ostream& out );
   16943             :       static void readStaticDataFromFile (std::istream& in );
   16944             :       friend class SgExpressionRoot;
   16945             :    };
   16946             : /* #line 16947 "../../../src/frontend/SageIII//StorageClasses.h" */
   16947             : 
   16948             : 
   16949             : 
   16950             : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarStorageClassDeclatationMacros.macro" */
   16951             : /* 
   16952             :    JH (01/01/2006) ROSETTA generated class declarations for SgMinusOpStorageClass 
   16953             :    used for the ast file IO. Do not chance by hand! 
   16954             : */
   16955         114 : class SgMinusOpStorageClass  : public SgUnaryOpStorageClass
   16956             :    {
   16957             : 
   16958             :     protected: 
   16959             : 
   16960             : 
   16961             : /* #line 16962 "../../../src/frontend/SageIII//StorageClasses.h" */
   16962             : 
   16963             : 
   16964             : 
   16965             : /* #line 10 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarStorageClassDeclatationMacros.macro" */
   16966             : 
   16967             : 
   16968             :     public:
   16969             :       void pickOutIRNodeData ( SgMinusOp* source );
   16970             :       static void arrangeStaticDataOfEasyStorageClassesInOneBlock ( );
   16971             :       static void deleteStaticDataOfEasyStorageClasses ( );
   16972             :       static void pickOutStaticDataMembers ( );
   16973             :       static void rebuildStaticDataMembers ( );
   16974             :       static void writeEasyStorageDataToFile (std::ostream& out);
   16975             :       static void readEasyStorageDataFromFile (std::istream& in);
   16976             :       static void writeStaticDataToFile (std::ostream& out );
   16977             :       static void readStaticDataFromFile (std::istream& in );
   16978             :       friend class SgMinusOp;
   16979             :    };
   16980             : /* #line 16981 "../../../src/frontend/SageIII//StorageClasses.h" */
   16981             : 
   16982             : 
   16983             : 
   16984             : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarStorageClassDeclatationMacros.macro" */
   16985             : /* 
   16986             :    JH (01/01/2006) ROSETTA generated class declarations for SgUnaryAddOpStorageClass 
   16987             :    used for the ast file IO. Do not chance by hand! 
   16988             : */
   16989           0 : class SgUnaryAddOpStorageClass  : public SgUnaryOpStorageClass
   16990             :    {
   16991             : 
   16992             :     protected: 
   16993             : 
   16994             : 
   16995             : /* #line 16996 "../../../src/frontend/SageIII//StorageClasses.h" */
   16996             : 
   16997             : 
   16998             : 
   16999             : /* #line 10 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarStorageClassDeclatationMacros.macro" */
   17000             : 
   17001             : 
   17002             :     public:
   17003             :       void pickOutIRNodeData ( SgUnaryAddOp* source );
   17004             :       static void arrangeStaticDataOfEasyStorageClassesInOneBlock ( );
   17005             :       static void deleteStaticDataOfEasyStorageClasses ( );
   17006             :       static void pickOutStaticDataMembers ( );
   17007             :       static void rebuildStaticDataMembers ( );
   17008             :       static void writeEasyStorageDataToFile (std::ostream& out);
   17009             :       static void readEasyStorageDataFromFile (std::istream& in);
   17010             :       static void writeStaticDataToFile (std::ostream& out );
   17011             :       static void readStaticDataFromFile (std::istream& in );
   17012             :       friend class SgUnaryAddOp;
   17013             :    };
   17014             : /* #line 17015 "../../../src/frontend/SageIII//StorageClasses.h" */
   17015             : 
   17016             : 
   17017             : 
   17018             : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarStorageClassDeclatationMacros.macro" */
   17019             : /* 
   17020             :    JH (01/01/2006) ROSETTA generated class declarations for SgNotOpStorageClass 
   17021             :    used for the ast file IO. Do not chance by hand! 
   17022             : */
   17023         440 : class SgNotOpStorageClass  : public SgUnaryOpStorageClass
   17024             :    {
   17025             : 
   17026             :     protected: 
   17027             : 
   17028             : 
   17029             : /* #line 17030 "../../../src/frontend/SageIII//StorageClasses.h" */
   17030             : 
   17031             : 
   17032             : 
   17033             : /* #line 10 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarStorageClassDeclatationMacros.macro" */
   17034             : 
   17035             : 
   17036             :     public:
   17037             :       void pickOutIRNodeData ( SgNotOp* source );
   17038             :       static void arrangeStaticDataOfEasyStorageClassesInOneBlock ( );
   17039             :       static void deleteStaticDataOfEasyStorageClasses ( );
   17040             :       static void pickOutStaticDataMembers ( );
   17041             :       static void rebuildStaticDataMembers ( );
   17042             :       static void writeEasyStorageDataToFile (std::ostream& out);
   17043             :       static void readEasyStorageDataFromFile (std::istream& in);
   17044             :       static void writeStaticDataToFile (std::ostream& out );
   17045             :       static void readStaticDataFromFile (std::istream& in );
   17046             :       friend class SgNotOp;
   17047             :    };
   17048             : /* #line 17049 "../../../src/frontend/SageIII//StorageClasses.h" */
   17049             : 
   17050             : 
   17051             : 
   17052             : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarStorageClassDeclatationMacros.macro" */
   17053             : /* 
   17054             :    JH (01/01/2006) ROSETTA generated class declarations for SgPointerDerefExpStorageClass 
   17055             :    used for the ast file IO. Do not chance by hand! 
   17056             : */
   17057         768 : class SgPointerDerefExpStorageClass  : public SgUnaryOpStorageClass
   17058             :    {
   17059             : 
   17060             :     protected: 
   17061             : 
   17062             : 
   17063             : /* #line 17064 "../../../src/frontend/SageIII//StorageClasses.h" */
   17064             : 
   17065             : 
   17066             : 
   17067             : /* #line 10 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarStorageClassDeclatationMacros.macro" */
   17068             : 
   17069             : 
   17070             :     public:
   17071             :       void pickOutIRNodeData ( SgPointerDerefExp* source );
   17072             :       static void arrangeStaticDataOfEasyStorageClassesInOneBlock ( );
   17073             :       static void deleteStaticDataOfEasyStorageClasses ( );
   17074             :       static void pickOutStaticDataMembers ( );
   17075             :       static void rebuildStaticDataMembers ( );
   17076             :       static void writeEasyStorageDataToFile (std::ostream& out);
   17077             :       static void readEasyStorageDataFromFile (std::istream& in);
   17078             :       static void writeStaticDataToFile (std::ostream& out );
   17079             :       static void readStaticDataFromFile (std::istream& in );
   17080             :       friend class SgPointerDerefExp;
   17081             :    };
   17082             : /* #line 17083 "../../../src/frontend/SageIII//StorageClasses.h" */
   17083             : 
   17084             : 
   17085             : 
   17086             : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarStorageClassDeclatationMacros.macro" */
   17087             : /* 
   17088             :    JH (01/01/2006) ROSETTA generated class declarations for SgAddressOfOpStorageClass 
   17089             :    used for the ast file IO. Do not chance by hand! 
   17090             : */
   17091         168 : class SgAddressOfOpStorageClass  : public SgUnaryOpStorageClass
   17092             :    {
   17093             : 
   17094             :     protected: 
   17095             : 
   17096             : 
   17097             : /* #line 17098 "../../../src/frontend/SageIII//StorageClasses.h" */
   17098             : 
   17099             :      unsigned long storageOf_originalExpressionTree;
   17100             : 
   17101             : 
   17102             : /* #line 10 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarStorageClassDeclatationMacros.macro" */
   17103             : 
   17104             : 
   17105             :     public:
   17106             :       void pickOutIRNodeData ( SgAddressOfOp* source );
   17107             :       static void arrangeStaticDataOfEasyStorageClassesInOneBlock ( );
   17108             :       static void deleteStaticDataOfEasyStorageClasses ( );
   17109             :       static void pickOutStaticDataMembers ( );
   17110             :       static void rebuildStaticDataMembers ( );
   17111             :       static void writeEasyStorageDataToFile (std::ostream& out);
   17112             :       static void readEasyStorageDataFromFile (std::istream& in);
   17113             :       static void writeStaticDataToFile (std::ostream& out );
   17114             :       static void readStaticDataFromFile (std::istream& in );
   17115             :       friend class SgAddressOfOp;
   17116             :    };
   17117             : /* #line 17118 "../../../src/frontend/SageIII//StorageClasses.h" */
   17118             : 
   17119             : 
   17120             : 
   17121             : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarStorageClassDeclatationMacros.macro" */
   17122             : /* 
   17123             :    JH (01/01/2006) ROSETTA generated class declarations for SgMinusMinusOpStorageClass 
   17124             :    used for the ast file IO. Do not chance by hand! 
   17125             : */
   17126          96 : class SgMinusMinusOpStorageClass  : public SgUnaryOpStorageClass
   17127             :    {
   17128             : 
   17129             :     protected: 
   17130             : 
   17131             : 
   17132             : /* #line 17133 "../../../src/frontend/SageIII//StorageClasses.h" */
   17133             : 
   17134             : 
   17135             : 
   17136             : /* #line 10 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarStorageClassDeclatationMacros.macro" */
   17137             : 
   17138             : 
   17139             :     public:
   17140             :       void pickOutIRNodeData ( SgMinusMinusOp* source );
   17141             :       static void arrangeStaticDataOfEasyStorageClassesInOneBlock ( );
   17142             :       static void deleteStaticDataOfEasyStorageClasses ( );
   17143             :       static void pickOutStaticDataMembers ( );
   17144             :       static void rebuildStaticDataMembers ( );
   17145             :       static void writeEasyStorageDataToFile (std::ostream& out);
   17146             :       static void readEasyStorageDataFromFile (std::istream& in);
   17147             :       static void writeStaticDataToFile (std::ostream& out );
   17148             :       static void readStaticDataFromFile (std::istream& in );
   17149             :       friend class SgMinusMinusOp;
   17150             :    };
   17151             : /* #line 17152 "../../../src/frontend/SageIII//StorageClasses.h" */
   17152             : 
   17153             : 
   17154             : 
   17155             : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarStorageClassDeclatationMacros.macro" */
   17156             : /* 
   17157             :    JH (01/01/2006) ROSETTA generated class declarations for SgPlusPlusOpStorageClass 
   17158             :    used for the ast file IO. Do not chance by hand! 
   17159             : */
   17160         262 : class SgPlusPlusOpStorageClass  : public SgUnaryOpStorageClass
   17161             :    {
   17162             : 
   17163             :     protected: 
   17164             : 
   17165             : 
   17166             : /* #line 17167 "../../../src/frontend/SageIII//StorageClasses.h" */
   17167             : 
   17168             : 
   17169             : 
   17170             : /* #line 10 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarStorageClassDeclatationMacros.macro" */
   17171             : 
   17172             : 
   17173             :     public:
   17174             :       void pickOutIRNodeData ( SgPlusPlusOp* source );
   17175             :       static void arrangeStaticDataOfEasyStorageClassesInOneBlock ( );
   17176             :       static void deleteStaticDataOfEasyStorageClasses ( );
   17177             :       static void pickOutStaticDataMembers ( );
   17178             :       static void rebuildStaticDataMembers ( );
   17179             :       static void writeEasyStorageDataToFile (std::ostream& out);
   17180             :       static void readEasyStorageDataFromFile (std::istream& in);
   17181             :       static void writeStaticDataToFile (std::ostream& out );
   17182             :       static void readStaticDataFromFile (std::istream& in );
   17183             :       friend class SgPlusPlusOp;
   17184             :    };
   17185             : /* #line 17186 "../../../src/frontend/SageIII//StorageClasses.h" */
   17186             : 
   17187             : 
   17188             : 
   17189             : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarStorageClassDeclatationMacros.macro" */
   17190             : /* 
   17191             :    JH (01/01/2006) ROSETTA generated class declarations for SgBitComplementOpStorageClass 
   17192             :    used for the ast file IO. Do not chance by hand! 
   17193             : */
   17194          22 : class SgBitComplementOpStorageClass  : public SgUnaryOpStorageClass
   17195             :    {
   17196             : 
   17197             :     protected: 
   17198             : 
   17199             : 
   17200             : /* #line 17201 "../../../src/frontend/SageIII//StorageClasses.h" */
   17201             : 
   17202             : 
   17203             : 
   17204             : /* #line 10 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarStorageClassDeclatationMacros.macro" */
   17205             : 
   17206             : 
   17207             :     public:
   17208             :       void pickOutIRNodeData ( SgBitComplementOp* source );
   17209             :       static void arrangeStaticDataOfEasyStorageClassesInOneBlock ( );
   17210             :       static void deleteStaticDataOfEasyStorageClasses ( );
   17211             :       static void pickOutStaticDataMembers ( );
   17212             :       static void rebuildStaticDataMembers ( );
   17213             :       static void writeEasyStorageDataToFile (std::ostream& out);
   17214             :       static void readEasyStorageDataFromFile (std::istream& in);
   17215             :       static void writeStaticDataToFile (std::ostream& out );
   17216             :       static void readStaticDataFromFile (std::istream& in );
   17217             :       friend class SgBitComplementOp;
   17218             :    };
   17219             : /* #line 17220 "../../../src/frontend/SageIII//StorageClasses.h" */
   17220             : 
   17221             : 
   17222             : 
   17223             : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarStorageClassDeclatationMacros.macro" */
   17224             : /* 
   17225             :    JH (01/01/2006) ROSETTA generated class declarations for SgCastExpStorageClass 
   17226             :    used for the ast file IO. Do not chance by hand! 
   17227             : */
   17228        4522 : class SgCastExpStorageClass  : public SgUnaryOpStorageClass
   17229             :    {
   17230             : 
   17231             :     protected: 
   17232             : 
   17233             : 
   17234             : /* #line 17235 "../../../src/frontend/SageIII//StorageClasses.h" */
   17235             : 
   17236             :       SgCastExp::cast_type_enum storageOf_cast_type;
   17237             :      unsigned long storageOf_originalExpressionTree;
   17238             :       int storageOf_name_qualification_length;
   17239             :       bool storageOf_type_elaboration_required;
   17240             :       bool storageOf_global_qualification_required;
   17241             :       bool storageOf_castContainsBaseTypeDefiningDeclaration;
   17242             :       int storageOf_name_qualification_for_pointer_to_member_class_length;
   17243             :       bool storageOf_type_elaboration_for_pointer_to_member_class_required;
   17244             :       bool storageOf_global_qualification_for_pointer_to_member_class_required;
   17245             : 
   17246             : 
   17247             : /* #line 10 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarStorageClassDeclatationMacros.macro" */
   17248             : 
   17249             : 
   17250             :     public:
   17251             :       void pickOutIRNodeData ( SgCastExp* source );
   17252             :       static void arrangeStaticDataOfEasyStorageClassesInOneBlock ( );
   17253             :       static void deleteStaticDataOfEasyStorageClasses ( );
   17254             :       static void pickOutStaticDataMembers ( );
   17255             :       static void rebuildStaticDataMembers ( );
   17256             :       static void writeEasyStorageDataToFile (std::ostream& out);
   17257             :       static void readEasyStorageDataFromFile (std::istream& in);
   17258             :       static void writeStaticDataToFile (std::ostream& out );
   17259             :       static void readStaticDataFromFile (std::istream& in );
   17260             :       friend class SgCastExp;
   17261             :    };
   17262             : /* #line 17263 "../../../src/frontend/SageIII//StorageClasses.h" */
   17263             : 
   17264             : 
   17265             : 
   17266             : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarStorageClassDeclatationMacros.macro" */
   17267             : /* 
   17268             :    JH (01/01/2006) ROSETTA generated class declarations for SgThrowOpStorageClass 
   17269             :    used for the ast file IO. Do not chance by hand! 
   17270             : */
   17271         104 : class SgThrowOpStorageClass  : public SgUnaryOpStorageClass
   17272             :    {
   17273             : 
   17274             :     protected: 
   17275             : 
   17276             : 
   17277             : /* #line 17278 "../../../src/frontend/SageIII//StorageClasses.h" */
   17278             : 
   17279             :       SgThrowOp::e_throw_kind storageOf_throwKind;
   17280             : 
   17281             : 
   17282             : /* #line 10 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarStorageClassDeclatationMacros.macro" */
   17283             : 
   17284             : 
   17285             :     public:
   17286             :       void pickOutIRNodeData ( SgThrowOp* source );
   17287             :       static void arrangeStaticDataOfEasyStorageClassesInOneBlock ( );
   17288             :       static void deleteStaticDataOfEasyStorageClasses ( );
   17289             :       static void pickOutStaticDataMembers ( );
   17290             :       static void rebuildStaticDataMembers ( );
   17291             :       static void writeEasyStorageDataToFile (std::ostream& out);
   17292             :       static void readEasyStorageDataFromFile (std::istream& in);
   17293             :       static void writeStaticDataToFile (std::ostream& out );
   17294             :       static void readStaticDataFromFile (std::istream& in );
   17295             :       friend class SgThrowOp;
   17296             :    };
   17297             : /* #line 17298 "../../../src/frontend/SageIII//StorageClasses.h" */
   17298             : 
   17299             : 
   17300             : 
   17301             : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarStorageClassDeclatationMacros.macro" */
   17302             : /* 
   17303             :    JH (01/01/2006) ROSETTA generated class declarations for SgRealPartOpStorageClass 
   17304             :    used for the ast file IO. Do not chance by hand! 
   17305             : */
   17306           0 : class SgRealPartOpStorageClass  : public SgUnaryOpStorageClass
   17307             :    {
   17308             : 
   17309             :     protected: 
   17310             : 
   17311             : 
   17312             : /* #line 17313 "../../../src/frontend/SageIII//StorageClasses.h" */
   17313             : 
   17314             : 
   17315             : 
   17316             : /* #line 10 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarStorageClassDeclatationMacros.macro" */
   17317             : 
   17318             : 
   17319             :     public:
   17320             :       void pickOutIRNodeData ( SgRealPartOp* source );
   17321             :       static void arrangeStaticDataOfEasyStorageClassesInOneBlock ( );
   17322             :       static void deleteStaticDataOfEasyStorageClasses ( );
   17323             :       static void pickOutStaticDataMembers ( );
   17324             :       static void rebuildStaticDataMembers ( );
   17325             :       static void writeEasyStorageDataToFile (std::ostream& out);
   17326             :       static void readEasyStorageDataFromFile (std::istream& in);
   17327             :       static void writeStaticDataToFile (std::ostream& out );
   17328             :       static void readStaticDataFromFile (std::istream& in );
   17329             :       friend class SgRealPartOp;
   17330             :    };
   17331             : /* #line 17332 "../../../src/frontend/SageIII//StorageClasses.h" */
   17332             : 
   17333             : 
   17334             : 
   17335             : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarStorageClassDeclatationMacros.macro" */
   17336             : /* 
   17337             :    JH (01/01/2006) ROSETTA generated class declarations for SgImagPartOpStorageClass 
   17338             :    used for the ast file IO. Do not chance by hand! 
   17339             : */
   17340           0 : class SgImagPartOpStorageClass  : public SgUnaryOpStorageClass
   17341             :    {
   17342             : 
   17343             :     protected: 
   17344             : 
   17345             : 
   17346             : /* #line 17347 "../../../src/frontend/SageIII//StorageClasses.h" */
   17347             : 
   17348             : 
   17349             : 
   17350             : /* #line 10 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarStorageClassDeclatationMacros.macro" */
   17351             : 
   17352             : 
   17353             :     public:
   17354             :       void pickOutIRNodeData ( SgImagPartOp* source );
   17355             :       static void arrangeStaticDataOfEasyStorageClassesInOneBlock ( );
   17356             :       static void deleteStaticDataOfEasyStorageClasses ( );
   17357             :       static void pickOutStaticDataMembers ( );
   17358             :       static void rebuildStaticDataMembers ( );
   17359             :       static void writeEasyStorageDataToFile (std::ostream& out);
   17360             :       static void readEasyStorageDataFromFile (std::istream& in);
   17361             :       static void writeStaticDataToFile (std::ostream& out );
   17362             :       static void readStaticDataFromFile (std::istream& in );
   17363             :       friend class SgImagPartOp;
   17364             :    };
   17365             : /* #line 17366 "../../../src/frontend/SageIII//StorageClasses.h" */
   17366             : 
   17367             : 
   17368             : 
   17369             : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarStorageClassDeclatationMacros.macro" */
   17370             : /* 
   17371             :    JH (01/01/2006) ROSETTA generated class declarations for SgConjugateOpStorageClass 
   17372             :    used for the ast file IO. Do not chance by hand! 
   17373             : */
   17374           0 : class SgConjugateOpStorageClass  : public SgUnaryOpStorageClass
   17375             :    {
   17376             : 
   17377             :     protected: 
   17378             : 
   17379             : 
   17380             : /* #line 17381 "../../../src/frontend/SageIII//StorageClasses.h" */
   17381             : 
   17382             : 
   17383             : 
   17384             : /* #line 10 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarStorageClassDeclatationMacros.macro" */
   17385             : 
   17386             : 
   17387             :     public:
   17388             :       void pickOutIRNodeData ( SgConjugateOp* source );
   17389             :       static void arrangeStaticDataOfEasyStorageClassesInOneBlock ( );
   17390             :       static void deleteStaticDataOfEasyStorageClasses ( );
   17391             :       static void pickOutStaticDataMembers ( );
   17392             :       static void rebuildStaticDataMembers ( );
   17393             :       static void writeEasyStorageDataToFile (std::ostream& out);
   17394             :       static void readEasyStorageDataFromFile (std::istream& in);
   17395             :       static void writeStaticDataToFile (std::ostream& out );
   17396             :       static void readStaticDataFromFile (std::istream& in );
   17397             :       friend class SgConjugateOp;
   17398             :    };
   17399             : /* #line 17400 "../../../src/frontend/SageIII//StorageClasses.h" */
   17400             : 
   17401             : 
   17402             : 
   17403             : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarStorageClassDeclatationMacros.macro" */
   17404             : /* 
   17405             :    JH (01/01/2006) ROSETTA generated class declarations for SgUserDefinedUnaryOpStorageClass 
   17406             :    used for the ast file IO. Do not chance by hand! 
   17407             : */
   17408           0 : class SgUserDefinedUnaryOpStorageClass  : public SgUnaryOpStorageClass
   17409             :    {
   17410             : 
   17411             :     protected: 
   17412             : 
   17413             : 
   17414             : /* #line 17415 "../../../src/frontend/SageIII//StorageClasses.h" */
   17415             : 
   17416             :       SgNameStorageClass storageOf_operator_name;
   17417             :      unsigned long storageOf_symbol;
   17418             : 
   17419             : 
   17420             : /* #line 10 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarStorageClassDeclatationMacros.macro" */
   17421             : 
   17422             : 
   17423             :     public:
   17424             :       void pickOutIRNodeData ( SgUserDefinedUnaryOp* source );
   17425             :       static void arrangeStaticDataOfEasyStorageClassesInOneBlock ( );
   17426             :       static void deleteStaticDataOfEasyStorageClasses ( );
   17427             :       static void pickOutStaticDataMembers ( );
   17428             :       static void rebuildStaticDataMembers ( );
   17429             :       static void writeEasyStorageDataToFile (std::ostream& out);
   17430             :       static void readEasyStorageDataFromFile (std::istream& in);
   17431             :       static void writeStaticDataToFile (std::ostream& out );
   17432             :       static void readStaticDataFromFile (std::istream& in );
   17433             :       friend class SgUserDefinedUnaryOp;
   17434             :    };
   17435             : /* #line 17436 "../../../src/frontend/SageIII//StorageClasses.h" */
   17436             : 
   17437             : 
   17438             : 
   17439             : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarStorageClassDeclatationMacros.macro" */
   17440             : /* 
   17441             :    JH (01/01/2006) ROSETTA generated class declarations for SgMatrixTransposeOpStorageClass 
   17442             :    used for the ast file IO. Do not chance by hand! 
   17443             : */
   17444           0 : class SgMatrixTransposeOpStorageClass  : public SgUnaryOpStorageClass
   17445             :    {
   17446             : 
   17447             :     protected: 
   17448             : 
   17449             : 
   17450             : /* #line 17451 "../../../src/frontend/SageIII//StorageClasses.h" */
   17451             : 
   17452             :       bool storageOf_is_conjugate;
   17453             : 
   17454             : 
   17455             : /* #line 10 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarStorageClassDeclatationMacros.macro" */
   17456             : 
   17457             : 
   17458             :     public:
   17459             :       void pickOutIRNodeData ( SgMatrixTransposeOp* source );
   17460             :       static void arrangeStaticDataOfEasyStorageClassesInOneBlock ( );
   17461             :       static void deleteStaticDataOfEasyStorageClasses ( );
   17462             :       static void pickOutStaticDataMembers ( );
   17463             :       static void rebuildStaticDataMembers ( );
   17464             :       static void writeEasyStorageDataToFile (std::ostream& out);
   17465             :       static void readEasyStorageDataFromFile (std::istream& in);
   17466             :       static void writeStaticDataToFile (std::ostream& out );
   17467             :       static void readStaticDataFromFile (std::istream& in );
   17468             :       friend class SgMatrixTransposeOp;
   17469             :    };
   17470             : /* #line 17471 "../../../src/frontend/SageIII//StorageClasses.h" */
   17471             : 
   17472             : 
   17473             : 
   17474             : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarStorageClassDeclatationMacros.macro" */
   17475             : /* 
   17476             :    JH (01/01/2006) ROSETTA generated class declarations for SgBinaryOpStorageClass 
   17477             :    used for the ast file IO. Do not chance by hand! 
   17478             : */
   17479           0 : class SgBinaryOpStorageClass  : public SgExpressionStorageClass
   17480             :    {
   17481             : 
   17482             :     protected: 
   17483             : 
   17484             : 
   17485             : /* #line 17486 "../../../src/frontend/SageIII//StorageClasses.h" */
   17486             : 
   17487             :      unsigned long storageOf_lhs_operand_i;
   17488             :      unsigned long storageOf_rhs_operand_i;
   17489             :      unsigned long storageOf_expression_type;
   17490             :      unsigned long storageOf_originalExpressionTree;
   17491             : 
   17492             : 
   17493             : /* #line 10 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarStorageClassDeclatationMacros.macro" */
   17494             : 
   17495             : 
   17496             :     public:
   17497             :       void pickOutIRNodeData ( SgBinaryOp* source );
   17498             :       static void arrangeStaticDataOfEasyStorageClassesInOneBlock ( );
   17499             :       static void deleteStaticDataOfEasyStorageClasses ( );
   17500             :       static void pickOutStaticDataMembers ( );
   17501             :       static void rebuildStaticDataMembers ( );
   17502             :       static void writeEasyStorageDataToFile (std::ostream& out);
   17503             :       static void readEasyStorageDataFromFile (std::istream& in);
   17504             :       static void writeStaticDataToFile (std::ostream& out );
   17505             :       static void readStaticDataFromFile (std::istream& in );
   17506             :       friend class SgBinaryOp;
   17507             :    };
   17508             : /* #line 17509 "../../../src/frontend/SageIII//StorageClasses.h" */
   17509             : 
   17510             : 
   17511             : 
   17512             : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarStorageClassDeclatationMacros.macro" */
   17513             : /* 
   17514             :    JH (01/01/2006) ROSETTA generated class declarations for SgArrowExpStorageClass 
   17515             :    used for the ast file IO. Do not chance by hand! 
   17516             : */
   17517        2508 : class SgArrowExpStorageClass  : public SgBinaryOpStorageClass
   17518             :    {
   17519             : 
   17520             :     protected: 
   17521             : 
   17522             : 
   17523             : /* #line 17524 "../../../src/frontend/SageIII//StorageClasses.h" */
   17524             : 
   17525             : 
   17526             : 
   17527             : /* #line 10 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarStorageClassDeclatationMacros.macro" */
   17528             : 
   17529             : 
   17530             :     public:
   17531             :       void pickOutIRNodeData ( SgArrowExp* source );
   17532             :       static void arrangeStaticDataOfEasyStorageClassesInOneBlock ( );
   17533             :       static void deleteStaticDataOfEasyStorageClasses ( );
   17534             :       static void pickOutStaticDataMembers ( );
   17535             :       static void rebuildStaticDataMembers ( );
   17536             :       static void writeEasyStorageDataToFile (std::ostream& out);
   17537             :       static void readEasyStorageDataFromFile (std::istream& in);
   17538             :       static void writeStaticDataToFile (std::ostream& out );
   17539             :       static void readStaticDataFromFile (std::istream& in );
   17540             :       friend class SgArrowExp;
   17541             :    };
   17542             : /* #line 17543 "../../../src/frontend/SageIII//StorageClasses.h" */
   17543             : 
   17544             : 
   17545             : 
   17546             : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarStorageClassDeclatationMacros.macro" */
   17547             : /* 
   17548             :    JH (01/01/2006) ROSETTA generated class declarations for SgDotExpStorageClass 
   17549             :    used for the ast file IO. Do not chance by hand! 
   17550             : */
   17551        1632 : class SgDotExpStorageClass  : public SgBinaryOpStorageClass
   17552             :    {
   17553             : 
   17554             :     protected: 
   17555             : 
   17556             : 
   17557             : /* #line 17558 "../../../src/frontend/SageIII//StorageClasses.h" */
   17558             : 
   17559             : 
   17560             : 
   17561             : /* #line 10 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarStorageClassDeclatationMacros.macro" */
   17562             : 
   17563             : 
   17564             :     public:
   17565             :       void pickOutIRNodeData ( SgDotExp* source );
   17566             :       static void arrangeStaticDataOfEasyStorageClassesInOneBlock ( );
   17567             :       static void deleteStaticDataOfEasyStorageClasses ( );
   17568             :       static void pickOutStaticDataMembers ( );
   17569             :       static void rebuildStaticDataMembers ( );
   17570             :       static void writeEasyStorageDataToFile (std::ostream& out);
   17571             :       static void readEasyStorageDataFromFile (std::istream& in);
   17572             :       static void writeStaticDataToFile (std::ostream& out );
   17573             :       static void readStaticDataFromFile (std::istream& in );
   17574             :       friend class SgDotExp;
   17575             :    };
   17576             : /* #line 17577 "../../../src/frontend/SageIII//StorageClasses.h" */
   17577             : 
   17578             : 
   17579             : 
   17580             : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarStorageClassDeclatationMacros.macro" */
   17581             : /* 
   17582             :    JH (01/01/2006) ROSETTA generated class declarations for SgDotStarOpStorageClass 
   17583             :    used for the ast file IO. Do not chance by hand! 
   17584             : */
   17585          24 : class SgDotStarOpStorageClass  : public SgBinaryOpStorageClass
   17586             :    {
   17587             : 
   17588             :     protected: 
   17589             : 
   17590             : 
   17591             : /* #line 17592 "../../../src/frontend/SageIII//StorageClasses.h" */
   17592             : 
   17593             : 
   17594             : 
   17595             : /* #line 10 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarStorageClassDeclatationMacros.macro" */
   17596             : 
   17597             : 
   17598             :     public:
   17599             :       void pickOutIRNodeData ( SgDotStarOp* source );
   17600             :       static void arrangeStaticDataOfEasyStorageClassesInOneBlock ( );
   17601             :       static void deleteStaticDataOfEasyStorageClasses ( );
   17602             :       static void pickOutStaticDataMembers ( );
   17603             :       static void rebuildStaticDataMembers ( );
   17604             :       static void writeEasyStorageDataToFile (std::ostream& out);
   17605             :       static void readEasyStorageDataFromFile (std::istream& in);
   17606             :       static void writeStaticDataToFile (std::ostream& out );
   17607             :       static void readStaticDataFromFile (std::istream& in );
   17608             :       friend class SgDotStarOp;
   17609             :    };
   17610             : /* #line 17611 "../../../src/frontend/SageIII//StorageClasses.h" */
   17611             : 
   17612             : 
   17613             : 
   17614             : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarStorageClassDeclatationMacros.macro" */
   17615             : /* 
   17616             :    JH (01/01/2006) ROSETTA generated class declarations for SgArrowStarOpStorageClass 
   17617             :    used for the ast file IO. Do not chance by hand! 
   17618             : */
   17619           8 : class SgArrowStarOpStorageClass  : public SgBinaryOpStorageClass
   17620             :    {
   17621             : 
   17622             :     protected: 
   17623             : 
   17624             : 
   17625             : /* #line 17626 "../../../src/frontend/SageIII//StorageClasses.h" */
   17626             : 
   17627             : 
   17628             : 
   17629             : /* #line 10 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarStorageClassDeclatationMacros.macro" */
   17630             : 
   17631             : 
   17632             :     public:
   17633             :       void pickOutIRNodeData ( SgArrowStarOp* source );
   17634             :       static void arrangeStaticDataOfEasyStorageClassesInOneBlock ( );
   17635             :       static void deleteStaticDataOfEasyStorageClasses ( );
   17636             :       static void pickOutStaticDataMembers ( );
   17637             :       static void rebuildStaticDataMembers ( );
   17638             :       static void writeEasyStorageDataToFile (std::ostream& out);
   17639             :       static void readEasyStorageDataFromFile (std::istream& in);
   17640             :       static void writeStaticDataToFile (std::ostream& out );
   17641             :       static void readStaticDataFromFile (std::istream& in );
   17642             :       friend class SgArrowStarOp;
   17643             :    };
   17644             : /* #line 17645 "../../../src/frontend/SageIII//StorageClasses.h" */
   17645             : 
   17646             : 
   17647             : 
   17648             : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarStorageClassDeclatationMacros.macro" */
   17649             : /* 
   17650             :    JH (01/01/2006) ROSETTA generated class declarations for SgEqualityOpStorageClass 
   17651             :    used for the ast file IO. Do not chance by hand! 
   17652             : */
   17653         500 : class SgEqualityOpStorageClass  : public SgBinaryOpStorageClass
   17654             :    {
   17655             : 
   17656             :     protected: 
   17657             : 
   17658             : 
   17659             : /* #line 17660 "../../../src/frontend/SageIII//StorageClasses.h" */
   17660             : 
   17661             : 
   17662             : 
   17663             : /* #line 10 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarStorageClassDeclatationMacros.macro" */
   17664             : 
   17665             : 
   17666             :     public:
   17667             :       void pickOutIRNodeData ( SgEqualityOp* source );
   17668             :       static void arrangeStaticDataOfEasyStorageClassesInOneBlock ( );
   17669             :       static void deleteStaticDataOfEasyStorageClasses ( );
   17670             :       static void pickOutStaticDataMembers ( );
   17671             :       static void rebuildStaticDataMembers ( );
   17672             :       static void writeEasyStorageDataToFile (std::ostream& out);
   17673             :       static void readEasyStorageDataFromFile (std::istream& in);
   17674             :       static void writeStaticDataToFile (std::ostream& out );
   17675             :       static void readStaticDataFromFile (std::istream& in );
   17676             :       friend class SgEqualityOp;
   17677             :    };
   17678             : /* #line 17679 "../../../src/frontend/SageIII//StorageClasses.h" */
   17679             : 
   17680             : 
   17681             : 
   17682             : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarStorageClassDeclatationMacros.macro" */
   17683             : /* 
   17684             :    JH (01/01/2006) ROSETTA generated class declarations for SgLessThanOpStorageClass 
   17685             :    used for the ast file IO. Do not chance by hand! 
   17686             : */
   17687         272 : class SgLessThanOpStorageClass  : public SgBinaryOpStorageClass
   17688             :    {
   17689             : 
   17690             :     protected: 
   17691             : 
   17692             : 
   17693             : /* #line 17694 "../../../src/frontend/SageIII//StorageClasses.h" */
   17694             : 
   17695             : 
   17696             : 
   17697             : /* #line 10 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarStorageClassDeclatationMacros.macro" */
   17698             : 
   17699             : 
   17700             :     public:
   17701             :       void pickOutIRNodeData ( SgLessThanOp* source );
   17702             :       static void arrangeStaticDataOfEasyStorageClassesInOneBlock ( );
   17703             :       static void deleteStaticDataOfEasyStorageClasses ( );
   17704             :       static void pickOutStaticDataMembers ( );
   17705             :       static void rebuildStaticDataMembers ( );
   17706             :       static void writeEasyStorageDataToFile (std::ostream& out);
   17707             :       static void readEasyStorageDataFromFile (std::istream& in);
   17708             :       static void writeStaticDataToFile (std::ostream& out );
   17709             :       static void readStaticDataFromFile (std::istream& in );
   17710             :       friend class SgLessThanOp;
   17711             :    };
   17712             : /* #line 17713 "../../../src/frontend/SageIII//StorageClasses.h" */
   17713             : 
   17714             : 
   17715             : 
   17716             : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarStorageClassDeclatationMacros.macro" */
   17717             : /* 
   17718             :    JH (01/01/2006) ROSETTA generated class declarations for SgGreaterThanOpStorageClass 
   17719             :    used for the ast file IO. Do not chance by hand! 
   17720             : */
   17721         216 : class SgGreaterThanOpStorageClass  : public SgBinaryOpStorageClass
   17722             :    {
   17723             : 
   17724             :     protected: 
   17725             : 
   17726             : 
   17727             : /* #line 17728 "../../../src/frontend/SageIII//StorageClasses.h" */
   17728             : 
   17729             : 
   17730             : 
   17731             : /* #line 10 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarStorageClassDeclatationMacros.macro" */
   17732             : 
   17733             : 
   17734             :     public:
   17735             :       void pickOutIRNodeData ( SgGreaterThanOp* source );
   17736             :       static void arrangeStaticDataOfEasyStorageClassesInOneBlock ( );
   17737             :       static void deleteStaticDataOfEasyStorageClasses ( );
   17738             :       static void pickOutStaticDataMembers ( );
   17739             :       static void rebuildStaticDataMembers ( );
   17740             :       static void writeEasyStorageDataToFile (std::ostream& out);
   17741             :       static void readEasyStorageDataFromFile (std::istream& in);
   17742             :       static void writeStaticDataToFile (std::ostream& out );
   17743             :       static void readStaticDataFromFile (std::istream& in );
   17744             :       friend class SgGreaterThanOp;
   17745             :    };
   17746             : /* #line 17747 "../../../src/frontend/SageIII//StorageClasses.h" */
   17747             : 
   17748             : 
   17749             : 
   17750             : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarStorageClassDeclatationMacros.macro" */
   17751             : /* 
   17752             :    JH (01/01/2006) ROSETTA generated class declarations for SgNotEqualOpStorageClass 
   17753             :    used for the ast file IO. Do not chance by hand! 
   17754             : */
   17755         190 : class SgNotEqualOpStorageClass  : public SgBinaryOpStorageClass
   17756             :    {
   17757             : 
   17758             :     protected: 
   17759             : 
   17760             : 
   17761             : /* #line 17762 "../../../src/frontend/SageIII//StorageClasses.h" */
   17762             : 
   17763             : 
   17764             : 
   17765             : /* #line 10 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarStorageClassDeclatationMacros.macro" */
   17766             : 
   17767             : 
   17768             :     public:
   17769             :       void pickOutIRNodeData ( SgNotEqualOp* source );
   17770             :       static void arrangeStaticDataOfEasyStorageClassesInOneBlock ( );
   17771             :       static void deleteStaticDataOfEasyStorageClasses ( );
   17772             :       static void pickOutStaticDataMembers ( );
   17773             :       static void rebuildStaticDataMembers ( );
   17774             :       static void writeEasyStorageDataToFile (std::ostream& out);
   17775             :       static void readEasyStorageDataFromFile (std::istream& in);
   17776             :       static void writeStaticDataToFile (std::ostream& out );
   17777             :       static void readStaticDataFromFile (std::istream& in );
   17778             :       friend class SgNotEqualOp;
   17779             :    };
   17780             : /* #line 17781 "../../../src/frontend/SageIII//StorageClasses.h" */
   17781             : 
   17782             : 
   17783             : 
   17784             : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarStorageClassDeclatationMacros.macro" */
   17785             : /* 
   17786             :    JH (01/01/2006) ROSETTA generated class declarations for SgLessOrEqualOpStorageClass 
   17787             :    used for the ast file IO. Do not chance by hand! 
   17788             : */
   17789          62 : class SgLessOrEqualOpStorageClass  : public SgBinaryOpStorageClass
   17790             :    {
   17791             : 
   17792             :     protected: 
   17793             : 
   17794             : 
   17795             : /* #line 17796 "../../../src/frontend/SageIII//StorageClasses.h" */
   17796             : 
   17797             : 
   17798             : 
   17799             : /* #line 10 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarStorageClassDeclatationMacros.macro" */
   17800             : 
   17801             : 
   17802             :     public:
   17803             :       void pickOutIRNodeData ( SgLessOrEqualOp* source );
   17804             :       static void arrangeStaticDataOfEasyStorageClassesInOneBlock ( );
   17805             :       static void deleteStaticDataOfEasyStorageClasses ( );
   17806             :       static void pickOutStaticDataMembers ( );
   17807             :       static void rebuildStaticDataMembers ( );
   17808             :       static void writeEasyStorageDataToFile (std::ostream& out);
   17809             :       static void readEasyStorageDataFromFile (std::istream& in);
   17810             :       static void writeStaticDataToFile (std::ostream& out );
   17811             :       static void readStaticDataFromFile (std::istream& in );
   17812             :       friend class SgLessOrEqualOp;
   17813             :    };
   17814             : /* #line 17815 "../../../src/frontend/SageIII//StorageClasses.h" */
   17815             : 
   17816             : 
   17817             : 
   17818             : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarStorageClassDeclatationMacros.macro" */
   17819             : /* 
   17820             :    JH (01/01/2006) ROSETTA generated class declarations for SgGreaterOrEqualOpStorageClass 
   17821             :    used for the ast file IO. Do not chance by hand! 
   17822             : */
   17823          56 : class SgGreaterOrEqualOpStorageClass  : public SgBinaryOpStorageClass
   17824             :    {
   17825             : 
   17826             :     protected: 
   17827             : 
   17828             : 
   17829             : /* #line 17830 "../../../src/frontend/SageIII//StorageClasses.h" */
   17830             : 
   17831             : 
   17832             : 
   17833             : /* #line 10 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarStorageClassDeclatationMacros.macro" */
   17834             : 
   17835             : 
   17836             :     public:
   17837             :       void pickOutIRNodeData ( SgGreaterOrEqualOp* source );
   17838             :       static void arrangeStaticDataOfEasyStorageClassesInOneBlock ( );
   17839             :       static void deleteStaticDataOfEasyStorageClasses ( );
   17840             :       static void pickOutStaticDataMembers ( );
   17841             :       static void rebuildStaticDataMembers ( );
   17842             :       static void writeEasyStorageDataToFile (std::ostream& out);
   17843             :       static void readEasyStorageDataFromFile (std::istream& in);
   17844             :       static void writeStaticDataToFile (std::ostream& out );
   17845             :       static void readStaticDataFromFile (std::istream& in );
   17846             :       friend class SgGreaterOrEqualOp;
   17847             :    };
   17848             : /* #line 17849 "../../../src/frontend/SageIII//StorageClasses.h" */
   17849             : 
   17850             : 
   17851             : 
   17852             : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarStorageClassDeclatationMacros.macro" */
   17853             : /* 
   17854             :    JH (01/01/2006) ROSETTA generated class declarations for SgAddOpStorageClass 
   17855             :    used for the ast file IO. Do not chance by hand! 
   17856             : */
   17857         380 : class SgAddOpStorageClass  : public SgBinaryOpStorageClass
   17858             :    {
   17859             : 
   17860             :     protected: 
   17861             : 
   17862             : 
   17863             : /* #line 17864 "../../../src/frontend/SageIII//StorageClasses.h" */
   17864             : 
   17865             : 
   17866             : 
   17867             : /* #line 10 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarStorageClassDeclatationMacros.macro" */
   17868             : 
   17869             : 
   17870             :     public:
   17871             :       void pickOutIRNodeData ( SgAddOp* source );
   17872             :       static void arrangeStaticDataOfEasyStorageClassesInOneBlock ( );
   17873             :       static void deleteStaticDataOfEasyStorageClasses ( );
   17874             :       static void pickOutStaticDataMembers ( );
   17875             :       static void rebuildStaticDataMembers ( );
   17876             :       static void writeEasyStorageDataToFile (std::ostream& out);
   17877             :       static void readEasyStorageDataFromFile (std::istream& in);
   17878             :       static void writeStaticDataToFile (std::ostream& out );
   17879             :       static void readStaticDataFromFile (std::istream& in );
   17880             :       friend class SgAddOp;
   17881             :    };
   17882             : /* #line 17883 "../../../src/frontend/SageIII//StorageClasses.h" */
   17883             : 
   17884             : 
   17885             : 
   17886             : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarStorageClassDeclatationMacros.macro" */
   17887             : /* 
   17888             :    JH (01/01/2006) ROSETTA generated class declarations for SgSubtractOpStorageClass 
   17889             :    used for the ast file IO. Do not chance by hand! 
   17890             : */
   17891         422 : class SgSubtractOpStorageClass  : public SgBinaryOpStorageClass
   17892             :    {
   17893             : 
   17894             :     protected: 
   17895             : 
   17896             : 
   17897             : /* #line 17898 "../../../src/frontend/SageIII//StorageClasses.h" */
   17898             : 
   17899             : 
   17900             : 
   17901             : /* #line 10 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarStorageClassDeclatationMacros.macro" */
   17902             : 
   17903             : 
   17904             :     public:
   17905             :       void pickOutIRNodeData ( SgSubtractOp* source );
   17906             :       static void arrangeStaticDataOfEasyStorageClassesInOneBlock ( );
   17907             :       static void deleteStaticDataOfEasyStorageClasses ( );
   17908             :       static void pickOutStaticDataMembers ( );
   17909             :       static void rebuildStaticDataMembers ( );
   17910             :       static void writeEasyStorageDataToFile (std::ostream& out);
   17911             :       static void readEasyStorageDataFromFile (std::istream& in);
   17912             :       static void writeStaticDataToFile (std::ostream& out );
   17913             :       static void readStaticDataFromFile (std::istream& in );
   17914             :       friend class SgSubtractOp;
   17915             :    };
   17916             : /* #line 17917 "../../../src/frontend/SageIII//StorageClasses.h" */
   17917             : 
   17918             : 
   17919             : 
   17920             : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarStorageClassDeclatationMacros.macro" */
   17921             : /* 
   17922             :    JH (01/01/2006) ROSETTA generated class declarations for SgMultiplyOpStorageClass 
   17923             :    used for the ast file IO. Do not chance by hand! 
   17924             : */
   17925         130 : class SgMultiplyOpStorageClass  : public SgBinaryOpStorageClass
   17926             :    {
   17927             : 
   17928             :     protected: 
   17929             : 
   17930             : 
   17931             : /* #line 17932 "../../../src/frontend/SageIII//StorageClasses.h" */
   17932             : 
   17933             : 
   17934             : 
   17935             : /* #line 10 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarStorageClassDeclatationMacros.macro" */
   17936             : 
   17937             : 
   17938             :     public:
   17939             :       void pickOutIRNodeData ( SgMultiplyOp* source );
   17940             :       static void arrangeStaticDataOfEasyStorageClassesInOneBlock ( );
   17941             :       static void deleteStaticDataOfEasyStorageClasses ( );
   17942             :       static void pickOutStaticDataMembers ( );
   17943             :       static void rebuildStaticDataMembers ( );
   17944             :       static void writeEasyStorageDataToFile (std::ostream& out);
   17945             :       static void readEasyStorageDataFromFile (std::istream& in);
   17946             :       static void writeStaticDataToFile (std::ostream& out );
   17947             :       static void readStaticDataFromFile (std::istream& in );
   17948             :       friend class SgMultiplyOp;
   17949             :    };
   17950             : /* #line 17951 "../../../src/frontend/SageIII//StorageClasses.h" */
   17951             : 
   17952             : 
   17953             : 
   17954             : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarStorageClassDeclatationMacros.macro" */
   17955             : /* 
   17956             :    JH (01/01/2006) ROSETTA generated class declarations for SgDivideOpStorageClass 
   17957             :    used for the ast file IO. Do not chance by hand! 
   17958             : */
   17959          74 : class SgDivideOpStorageClass  : public SgBinaryOpStorageClass
   17960             :    {
   17961             : 
   17962             :     protected: 
   17963             : 
   17964             : 
   17965             : /* #line 17966 "../../../src/frontend/SageIII//StorageClasses.h" */
   17966             : 
   17967             : 
   17968             : 
   17969             : /* #line 10 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarStorageClassDeclatationMacros.macro" */
   17970             : 
   17971             : 
   17972             :     public:
   17973             :       void pickOutIRNodeData ( SgDivideOp* source );
   17974             :       static void arrangeStaticDataOfEasyStorageClassesInOneBlock ( );
   17975             :       static void deleteStaticDataOfEasyStorageClasses ( );
   17976             :       static void pickOutStaticDataMembers ( );
   17977             :       static void rebuildStaticDataMembers ( );
   17978             :       static void writeEasyStorageDataToFile (std::ostream& out);
   17979             :       static void readEasyStorageDataFromFile (std::istream& in);
   17980             :       static void writeStaticDataToFile (std::ostream& out );
   17981             :       static void readStaticDataFromFile (std::istream& in );
   17982             :       friend class SgDivideOp;
   17983             :    };
   17984             : /* #line 17985 "../../../src/frontend/SageIII//StorageClasses.h" */
   17985             : 
   17986             : 
   17987             : 
   17988             : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarStorageClassDeclatationMacros.macro" */
   17989             : /* 
   17990             :    JH (01/01/2006) ROSETTA generated class declarations for SgIntegerDivideOpStorageClass 
   17991             :    used for the ast file IO. Do not chance by hand! 
   17992             : */
   17993           0 : class SgIntegerDivideOpStorageClass  : public SgBinaryOpStorageClass
   17994             :    {
   17995             : 
   17996             :     protected: 
   17997             : 
   17998             : 
   17999             : /* #line 18000 "../../../src/frontend/SageIII//StorageClasses.h" */
   18000             : 
   18001             : 
   18002             : 
   18003             : /* #line 10 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarStorageClassDeclatationMacros.macro" */
   18004             : 
   18005             : 
   18006             :     public:
   18007             :       void pickOutIRNodeData ( SgIntegerDivideOp* source );
   18008             :       static void arrangeStaticDataOfEasyStorageClassesInOneBlock ( );
   18009             :       static void deleteStaticDataOfEasyStorageClasses ( );
   18010             :       static void pickOutStaticDataMembers ( );
   18011             :       static void rebuildStaticDataMembers ( );
   18012             :       static void writeEasyStorageDataToFile (std::ostream& out);
   18013             :       static void readEasyStorageDataFromFile (std::istream& in);
   18014             :       static void writeStaticDataToFile (std::ostream& out );
   18015             :       static void readStaticDataFromFile (std::istream& in );
   18016             :       friend class SgIntegerDivideOp;
   18017             :    };
   18018             : /* #line 18019 "../../../src/frontend/SageIII//StorageClasses.h" */
   18019             : 
   18020             : 
   18021             : 
   18022             : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarStorageClassDeclatationMacros.macro" */
   18023             : /* 
   18024             :    JH (01/01/2006) ROSETTA generated class declarations for SgModOpStorageClass 
   18025             :    used for the ast file IO. Do not chance by hand! 
   18026             : */
   18027          10 : class SgModOpStorageClass  : public SgBinaryOpStorageClass
   18028             :    {
   18029             : 
   18030             :     protected: 
   18031             : 
   18032             : 
   18033             : /* #line 18034 "../../../src/frontend/SageIII//StorageClasses.h" */
   18034             : 
   18035             : 
   18036             : 
   18037             : /* #line 10 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarStorageClassDeclatationMacros.macro" */
   18038             : 
   18039             : 
   18040             :     public:
   18041             :       void pickOutIRNodeData ( SgModOp* source );
   18042             :       static void arrangeStaticDataOfEasyStorageClassesInOneBlock ( );
   18043             :       static void deleteStaticDataOfEasyStorageClasses ( );
   18044             :       static void pickOutStaticDataMembers ( );
   18045             :       static void rebuildStaticDataMembers ( );
   18046             :       static void writeEasyStorageDataToFile (std::ostream& out);
   18047             :       static void readEasyStorageDataFromFile (std::istream& in);
   18048             :       static void writeStaticDataToFile (std::ostream& out );
   18049             :       static void readStaticDataFromFile (std::istream& in );
   18050             :       friend class SgModOp;
   18051             :    };
   18052             : /* #line 18053 "../../../src/frontend/SageIII//StorageClasses.h" */
   18053             : 
   18054             : 
   18055             : 
   18056             : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarStorageClassDeclatationMacros.macro" */
   18057             : /* 
   18058             :    JH (01/01/2006) ROSETTA generated class declarations for SgAndOpStorageClass 
   18059             :    used for the ast file IO. Do not chance by hand! 
   18060             : */
   18061         346 : class SgAndOpStorageClass  : public SgBinaryOpStorageClass
   18062             :    {
   18063             : 
   18064             :     protected: 
   18065             : 
   18066             : 
   18067             : /* #line 18068 "../../../src/frontend/SageIII//StorageClasses.h" */
   18068             : 
   18069             : 
   18070             : 
   18071             : /* #line 10 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarStorageClassDeclatationMacros.macro" */
   18072             : 
   18073             : 
   18074             :     public:
   18075             :       void pickOutIRNodeData ( SgAndOp* source );
   18076             :       static void arrangeStaticDataOfEasyStorageClassesInOneBlock ( );
   18077             :       static void deleteStaticDataOfEasyStorageClasses ( );
   18078             :       static void pickOutStaticDataMembers ( );
   18079             :       static void rebuildStaticDataMembers ( );
   18080             :       static void writeEasyStorageDataToFile (std::ostream& out);
   18081             :       static void readEasyStorageDataFromFile (std::istream& in);
   18082             :       static void writeStaticDataToFile (std::ostream& out );
   18083             :       static void readStaticDataFromFile (std::istream& in );
   18084             :       friend class SgAndOp;
   18085             :    };
   18086             : /* #line 18087 "../../../src/frontend/SageIII//StorageClasses.h" */
   18087             : 
   18088             : 
   18089             : 
   18090             : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarStorageClassDeclatationMacros.macro" */
   18091             : /* 
   18092             :    JH (01/01/2006) ROSETTA generated class declarations for SgOrOpStorageClass 
   18093             :    used for the ast file IO. Do not chance by hand! 
   18094             : */
   18095         166 : class SgOrOpStorageClass  : public SgBinaryOpStorageClass
   18096             :    {
   18097             : 
   18098             :     protected: 
   18099             : 
   18100             : 
   18101             : /* #line 18102 "../../../src/frontend/SageIII//StorageClasses.h" */
   18102             : 
   18103             : 
   18104             : 
   18105             : /* #line 10 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarStorageClassDeclatationMacros.macro" */
   18106             : 
   18107             : 
   18108             :     public:
   18109             :       void pickOutIRNodeData ( SgOrOp* source );
   18110             :       static void arrangeStaticDataOfEasyStorageClassesInOneBlock ( );
   18111             :       static void deleteStaticDataOfEasyStorageClasses ( );
   18112             :       static void pickOutStaticDataMembers ( );
   18113             :       static void rebuildStaticDataMembers ( );
   18114             :       static void writeEasyStorageDataToFile (std::ostream& out);
   18115             :       static void readEasyStorageDataFromFile (std::istream& in);
   18116             :       static void writeStaticDataToFile (std::ostream& out );
   18117             :       static void readStaticDataFromFile (std::istream& in );
   18118             :       friend class SgOrOp;
   18119             :    };
   18120             : /* #line 18121 "../../../src/frontend/SageIII//StorageClasses.h" */
   18121             : 
   18122             : 
   18123             : 
   18124             : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarStorageClassDeclatationMacros.macro" */
   18125             : /* 
   18126             :    JH (01/01/2006) ROSETTA generated class declarations for SgBitXorOpStorageClass 
   18127             :    used for the ast file IO. Do not chance by hand! 
   18128             : */
   18129          12 : class SgBitXorOpStorageClass  : public SgBinaryOpStorageClass
   18130             :    {
   18131             : 
   18132             :     protected: 
   18133             : 
   18134             : 
   18135             : /* #line 18136 "../../../src/frontend/SageIII//StorageClasses.h" */
   18136             : 
   18137             : 
   18138             : 
   18139             : /* #line 10 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarStorageClassDeclatationMacros.macro" */
   18140             : 
   18141             : 
   18142             :     public:
   18143             :       void pickOutIRNodeData ( SgBitXorOp* source );
   18144             :       static void arrangeStaticDataOfEasyStorageClassesInOneBlock ( );
   18145             :       static void deleteStaticDataOfEasyStorageClasses ( );
   18146             :       static void pickOutStaticDataMembers ( );
   18147             :       static void rebuildStaticDataMembers ( );
   18148             :       static void writeEasyStorageDataToFile (std::ostream& out);
   18149             :       static void readEasyStorageDataFromFile (std::istream& in);
   18150             :       static void writeStaticDataToFile (std::ostream& out );
   18151             :       static void readStaticDataFromFile (std::istream& in );
   18152             :       friend class SgBitXorOp;
   18153             :    };
   18154             : /* #line 18155 "../../../src/frontend/SageIII//StorageClasses.h" */
   18155             : 
   18156             : 
   18157             : 
   18158             : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarStorageClassDeclatationMacros.macro" */
   18159             : /* 
   18160             :    JH (01/01/2006) ROSETTA generated class declarations for SgBitAndOpStorageClass 
   18161             :    used for the ast file IO. Do not chance by hand! 
   18162             : */
   18163          40 : class SgBitAndOpStorageClass  : public SgBinaryOpStorageClass
   18164             :    {
   18165             : 
   18166             :     protected: 
   18167             : 
   18168             : 
   18169             : /* #line 18170 "../../../src/frontend/SageIII//StorageClasses.h" */
   18170             : 
   18171             : 
   18172             : 
   18173             : /* #line 10 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarStorageClassDeclatationMacros.macro" */
   18174             : 
   18175             : 
   18176             :     public:
   18177             :       void pickOutIRNodeData ( SgBitAndOp* source );
   18178             :       static void arrangeStaticDataOfEasyStorageClassesInOneBlock ( );
   18179             :       static void deleteStaticDataOfEasyStorageClasses ( );
   18180             :       static void pickOutStaticDataMembers ( );
   18181             :       static void rebuildStaticDataMembers ( );
   18182             :       static void writeEasyStorageDataToFile (std::ostream& out);
   18183             :       static void readEasyStorageDataFromFile (std::istream& in);
   18184             :       static void writeStaticDataToFile (std::ostream& out );
   18185             :       static void readStaticDataFromFile (std::istream& in );
   18186             :       friend class SgBitAndOp;
   18187             :    };
   18188             : /* #line 18189 "../../../src/frontend/SageIII//StorageClasses.h" */
   18189             : 
   18190             : 
   18191             : 
   18192             : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarStorageClassDeclatationMacros.macro" */
   18193             : /* 
   18194             :    JH (01/01/2006) ROSETTA generated class declarations for SgBitOrOpStorageClass 
   18195             :    used for the ast file IO. Do not chance by hand! 
   18196             : */
   18197          30 : class SgBitOrOpStorageClass  : public SgBinaryOpStorageClass
   18198             :    {
   18199             : 
   18200             :     protected: 
   18201             : 
   18202             : 
   18203             : /* #line 18204 "../../../src/frontend/SageIII//StorageClasses.h" */
   18204             : 
   18205             : 
   18206             : 
   18207             : /* #line 10 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarStorageClassDeclatationMacros.macro" */
   18208             : 
   18209             : 
   18210             :     public:
   18211             :       void pickOutIRNodeData ( SgBitOrOp* source );
   18212             :       static void arrangeStaticDataOfEasyStorageClassesInOneBlock ( );
   18213             :       static void deleteStaticDataOfEasyStorageClasses ( );
   18214             :       static void pickOutStaticDataMembers ( );
   18215             :       static void rebuildStaticDataMembers ( );
   18216             :       static void writeEasyStorageDataToFile (std::ostream& out);
   18217             :       static void readEasyStorageDataFromFile (std::istream& in);
   18218             :       static void writeStaticDataToFile (std::ostream& out );
   18219             :       static void readStaticDataFromFile (std::istream& in );
   18220             :       friend class SgBitOrOp;
   18221             :    };
   18222             : /* #line 18223 "../../../src/frontend/SageIII//StorageClasses.h" */
   18223             : 
   18224             : 
   18225             : 
   18226             : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarStorageClassDeclatationMacros.macro" */
   18227             : /* 
   18228             :    JH (01/01/2006) ROSETTA generated class declarations for SgBitEqvOpStorageClass 
   18229             :    used for the ast file IO. Do not chance by hand! 
   18230             : */
   18231           0 : class SgBitEqvOpStorageClass  : public SgBinaryOpStorageClass
   18232             :    {
   18233             : 
   18234             :     protected: 
   18235             : 
   18236             : 
   18237             : /* #line 18238 "../../../src/frontend/SageIII//StorageClasses.h" */
   18238             : 
   18239             : 
   18240             : 
   18241             : /* #line 10 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarStorageClassDeclatationMacros.macro" */
   18242             : 
   18243             : 
   18244             :     public:
   18245             :       void pickOutIRNodeData ( SgBitEqvOp* source );
   18246             :       static void arrangeStaticDataOfEasyStorageClassesInOneBlock ( );
   18247             :       static void deleteStaticDataOfEasyStorageClasses ( );
   18248             :       static void pickOutStaticDataMembers ( );
   18249             :       static void rebuildStaticDataMembers ( );
   18250             :       static void writeEasyStorageDataToFile (std::ostream& out);
   18251             :       static void readEasyStorageDataFromFile (std::istream& in);
   18252             :       static void writeStaticDataToFile (std::ostream& out );
   18253             :       static void readStaticDataFromFile (std::istream& in );
   18254             :       friend class SgBitEqvOp;
   18255             :    };
   18256             : /* #line 18257 "../../../src/frontend/SageIII//StorageClasses.h" */
   18257             : 
   18258             : 
   18259             : 
   18260             : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarStorageClassDeclatationMacros.macro" */
   18261             : /* 
   18262             :    JH (01/01/2006) ROSETTA generated class declarations for SgCommaOpExpStorageClass 
   18263             :    used for the ast file IO. Do not chance by hand! 
   18264             : */
   18265          32 : class SgCommaOpExpStorageClass  : public SgBinaryOpStorageClass
   18266             :    {
   18267             : 
   18268             :     protected: 
   18269             : 
   18270             : 
   18271             : /* #line 18272 "../../../src/frontend/SageIII//StorageClasses.h" */
   18272             : 
   18273             : 
   18274             : 
   18275             : /* #line 10 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarStorageClassDeclatationMacros.macro" */
   18276             : 
   18277             : 
   18278             :     public:
   18279             :       void pickOutIRNodeData ( SgCommaOpExp* source );
   18280             :       static void arrangeStaticDataOfEasyStorageClassesInOneBlock ( );
   18281             :       static void deleteStaticDataOfEasyStorageClasses ( );
   18282             :       static void pickOutStaticDataMembers ( );
   18283             :       static void rebuildStaticDataMembers ( );
   18284             :       static void writeEasyStorageDataToFile (std::ostream& out);
   18285             :       static void readEasyStorageDataFromFile (std::istream& in);
   18286             :       static void writeStaticDataToFile (std::ostream& out );
   18287             :       static void readStaticDataFromFile (std::istream& in );
   18288             :       friend class SgCommaOpExp;
   18289             :    };
   18290             : /* #line 18291 "../../../src/frontend/SageIII//StorageClasses.h" */
   18291             : 
   18292             : 
   18293             : 
   18294             : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarStorageClassDeclatationMacros.macro" */
   18295             : /* 
   18296             :    JH (01/01/2006) ROSETTA generated class declarations for SgLshiftOpStorageClass 
   18297             :    used for the ast file IO. Do not chance by hand! 
   18298             : */
   18299          54 : class SgLshiftOpStorageClass  : public SgBinaryOpStorageClass
   18300             :    {
   18301             : 
   18302             :     protected: 
   18303             : 
   18304             : 
   18305             : /* #line 18306 "../../../src/frontend/SageIII//StorageClasses.h" */
   18306             : 
   18307             : 
   18308             : 
   18309             : /* #line 10 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarStorageClassDeclatationMacros.macro" */
   18310             : 
   18311             : 
   18312             :     public:
   18313             :       void pickOutIRNodeData ( SgLshiftOp* source );
   18314             :       static void arrangeStaticDataOfEasyStorageClassesInOneBlock ( );
   18315             :       static void deleteStaticDataOfEasyStorageClasses ( );
   18316             :       static void pickOutStaticDataMembers ( );
   18317             :       static void rebuildStaticDataMembers ( );
   18318             :       static void writeEasyStorageDataToFile (std::ostream& out);
   18319             :       static void readEasyStorageDataFromFile (std::istream& in);
   18320             :       static void writeStaticDataToFile (std::ostream& out );
   18321             :       static void readStaticDataFromFile (std::istream& in );
   18322             :       friend class SgLshiftOp;
   18323             :    };
   18324             : /* #line 18325 "../../../src/frontend/SageIII//StorageClasses.h" */
   18325             : 
   18326             : 
   18327             : 
   18328             : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarStorageClassDeclatationMacros.macro" */
   18329             : /* 
   18330             :    JH (01/01/2006) ROSETTA generated class declarations for SgRshiftOpStorageClass 
   18331             :    used for the ast file IO. Do not chance by hand! 
   18332             : */
   18333          16 : class SgRshiftOpStorageClass  : public SgBinaryOpStorageClass
   18334             :    {
   18335             : 
   18336             :     protected: 
   18337             : 
   18338             : 
   18339             : /* #line 18340 "../../../src/frontend/SageIII//StorageClasses.h" */
   18340             : 
   18341             : 
   18342             : 
   18343             : /* #line 10 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarStorageClassDeclatationMacros.macro" */
   18344             : 
   18345             : 
   18346             :     public:
   18347             :       void pickOutIRNodeData ( SgRshiftOp* source );
   18348             :       static void arrangeStaticDataOfEasyStorageClassesInOneBlock ( );
   18349             :       static void deleteStaticDataOfEasyStorageClasses ( );
   18350             :       static void pickOutStaticDataMembers ( );
   18351             :       static void rebuildStaticDataMembers ( );
   18352             :       static void writeEasyStorageDataToFile (std::ostream& out);
   18353             :       static void readEasyStorageDataFromFile (std::istream& in);
   18354             :       static void writeStaticDataToFile (std::ostream& out );
   18355             :       static void readStaticDataFromFile (std::istream& in );
   18356             :       friend class SgRshiftOp;
   18357             :    };
   18358             : /* #line 18359 "../../../src/frontend/SageIII//StorageClasses.h" */
   18359             : 
   18360             : 
   18361             : 
   18362             : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarStorageClassDeclatationMacros.macro" */
   18363             : /* 
   18364             :    JH (01/01/2006) ROSETTA generated class declarations for SgPntrArrRefExpStorageClass 
   18365             :    used for the ast file IO. Do not chance by hand! 
   18366             : */
   18367         252 : class SgPntrArrRefExpStorageClass  : public SgBinaryOpStorageClass
   18368             :    {
   18369             : 
   18370             :     protected: 
   18371             : 
   18372             : 
   18373             : /* #line 18374 "../../../src/frontend/SageIII//StorageClasses.h" */
   18374             : 
   18375             : 
   18376             : 
   18377             : /* #line 10 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarStorageClassDeclatationMacros.macro" */
   18378             : 
   18379             : 
   18380             :     public:
   18381             :       void pickOutIRNodeData ( SgPntrArrRefExp* source );
   18382             :       static void arrangeStaticDataOfEasyStorageClassesInOneBlock ( );
   18383             :       static void deleteStaticDataOfEasyStorageClasses ( );
   18384             :       static void pickOutStaticDataMembers ( );
   18385             :       static void rebuildStaticDataMembers ( );
   18386             :       static void writeEasyStorageDataToFile (std::ostream& out);
   18387             :       static void readEasyStorageDataFromFile (std::istream& in);
   18388             :       static void writeStaticDataToFile (std::ostream& out );
   18389             :       static void readStaticDataFromFile (std::istream& in );
   18390             :       friend class SgPntrArrRefExp;
   18391             :    };
   18392             : /* #line 18393 "../../../src/frontend/SageIII//StorageClasses.h" */
   18393             : 
   18394             : 
   18395             : 
   18396             : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarStorageClassDeclatationMacros.macro" */
   18397             : /* 
   18398             :    JH (01/01/2006) ROSETTA generated class declarations for SgScopeOpStorageClass 
   18399             :    used for the ast file IO. Do not chance by hand! 
   18400             : */
   18401           0 : class SgScopeOpStorageClass  : public SgBinaryOpStorageClass
   18402             :    {
   18403             : 
   18404             :     protected: 
   18405             : 
   18406             : 
   18407             : /* #line 18408 "../../../src/frontend/SageIII//StorageClasses.h" */
   18408             : 
   18409             : 
   18410             : 
   18411             : /* #line 10 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarStorageClassDeclatationMacros.macro" */
   18412             : 
   18413             : 
   18414             :     public:
   18415             :       void pickOutIRNodeData ( SgScopeOp* source );
   18416             :       static void arrangeStaticDataOfEasyStorageClassesInOneBlock ( );
   18417             :       static void deleteStaticDataOfEasyStorageClasses ( );
   18418             :       static void pickOutStaticDataMembers ( );
   18419             :       static void rebuildStaticDataMembers ( );
   18420             :       static void writeEasyStorageDataToFile (std::ostream& out);
   18421             :       static void readEasyStorageDataFromFile (std::istream& in);
   18422             :       static void writeStaticDataToFile (std::ostream& out );
   18423             :       static void readStaticDataFromFile (std::istream& in );
   18424             :       friend class SgScopeOp;
   18425             :    };
   18426             : /* #line 18427 "../../../src/frontend/SageIII//StorageClasses.h" */
   18427             : 
   18428             : 
   18429             : 
   18430             : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarStorageClassDeclatationMacros.macro" */
   18431             : /* 
   18432             :    JH (01/01/2006) ROSETTA generated class declarations for SgAssignOpStorageClass 
   18433             :    used for the ast file IO. Do not chance by hand! 
   18434             : */
   18435         910 : class SgAssignOpStorageClass  : public SgBinaryOpStorageClass
   18436             :    {
   18437             : 
   18438             :     protected: 
   18439             : 
   18440             : 
   18441             : /* #line 18442 "../../../src/frontend/SageIII//StorageClasses.h" */
   18442             : 
   18443             : 
   18444             : 
   18445             : /* #line 10 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarStorageClassDeclatationMacros.macro" */
   18446             : 
   18447             : 
   18448             :     public:
   18449             :       void pickOutIRNodeData ( SgAssignOp* source );
   18450             :       static void arrangeStaticDataOfEasyStorageClassesInOneBlock ( );
   18451             :       static void deleteStaticDataOfEasyStorageClasses ( );
   18452             :       static void pickOutStaticDataMembers ( );
   18453             :       static void rebuildStaticDataMembers ( );
   18454             :       static void writeEasyStorageDataToFile (std::ostream& out);
   18455             :       static void readEasyStorageDataFromFile (std::istream& in);
   18456             :       static void writeStaticDataToFile (std::ostream& out );
   18457             :       static void readStaticDataFromFile (std::istream& in );
   18458             :       friend class SgAssignOp;
   18459             :    };
   18460             : /* #line 18461 "../../../src/frontend/SageIII//StorageClasses.h" */
   18461             : 
   18462             : 
   18463             : 
   18464             : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarStorageClassDeclatationMacros.macro" */
   18465             : /* 
   18466             :    JH (01/01/2006) ROSETTA generated class declarations for SgExponentiationOpStorageClass 
   18467             :    used for the ast file IO. Do not chance by hand! 
   18468             : */
   18469           0 : class SgExponentiationOpStorageClass  : public SgBinaryOpStorageClass
   18470             :    {
   18471             : 
   18472             :     protected: 
   18473             : 
   18474             : 
   18475             : /* #line 18476 "../../../src/frontend/SageIII//StorageClasses.h" */
   18476             : 
   18477             : 
   18478             : 
   18479             : /* #line 10 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarStorageClassDeclatationMacros.macro" */
   18480             : 
   18481             : 
   18482             :     public:
   18483             :       void pickOutIRNodeData ( SgExponentiationOp* source );
   18484             :       static void arrangeStaticDataOfEasyStorageClassesInOneBlock ( );
   18485             :       static void deleteStaticDataOfEasyStorageClasses ( );
   18486             :       static void pickOutStaticDataMembers ( );
   18487             :       static void rebuildStaticDataMembers ( );
   18488             :       static void writeEasyStorageDataToFile (std::ostream& out);
   18489             :       static void readEasyStorageDataFromFile (std::istream& in);
   18490             :       static void writeStaticDataToFile (std::ostream& out );
   18491             :       static void readStaticDataFromFile (std::istream& in );
   18492             :       friend class SgExponentiationOp;
   18493             :    };
   18494             : /* #line 18495 "../../../src/frontend/SageIII//StorageClasses.h" */
   18495             : 
   18496             : 
   18497             : 
   18498             : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarStorageClassDeclatationMacros.macro" */
   18499             : /* 
   18500             :    JH (01/01/2006) ROSETTA generated class declarations for SgConcatenationOpStorageClass 
   18501             :    used for the ast file IO. Do not chance by hand! 
   18502             : */
   18503           0 : class SgConcatenationOpStorageClass  : public SgBinaryOpStorageClass
   18504             :    {
   18505             : 
   18506             :     protected: 
   18507             : 
   18508             : 
   18509             : /* #line 18510 "../../../src/frontend/SageIII//StorageClasses.h" */
   18510             : 
   18511             : 
   18512             : 
   18513             : /* #line 10 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarStorageClassDeclatationMacros.macro" */
   18514             : 
   18515             : 
   18516             :     public:
   18517             :       void pickOutIRNodeData ( SgConcatenationOp* source );
   18518             :       static void arrangeStaticDataOfEasyStorageClassesInOneBlock ( );
   18519             :       static void deleteStaticDataOfEasyStorageClasses ( );
   18520             :       static void pickOutStaticDataMembers ( );
   18521             :       static void rebuildStaticDataMembers ( );
   18522             :       static void writeEasyStorageDataToFile (std::ostream& out);
   18523             :       static void readEasyStorageDataFromFile (std::istream& in);
   18524             :       static void writeStaticDataToFile (std::ostream& out );
   18525             :       static void readStaticDataFromFile (std::istream& in );
   18526             :       friend class SgConcatenationOp;
   18527             :    };
   18528             : /* #line 18529 "../../../src/frontend/SageIII//StorageClasses.h" */
   18529             : 
   18530             : 
   18531             : 
   18532             : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarStorageClassDeclatationMacros.macro" */
   18533             : /* 
   18534             :    JH (01/01/2006) ROSETTA generated class declarations for SgPointerAssignOpStorageClass 
   18535             :    used for the ast file IO. Do not chance by hand! 
   18536             : */
   18537           0 : class SgPointerAssignOpStorageClass  : public SgBinaryOpStorageClass
   18538             :    {
   18539             : 
   18540             :     protected: 
   18541             : 
   18542             : 
   18543             : /* #line 18544 "../../../src/frontend/SageIII//StorageClasses.h" */
   18544             : 
   18545             : 
   18546             : 
   18547             : /* #line 10 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarStorageClassDeclatationMacros.macro" */
   18548             : 
   18549             : 
   18550             :     public:
   18551             :       void pickOutIRNodeData ( SgPointerAssignOp* source );
   18552             :       static void arrangeStaticDataOfEasyStorageClassesInOneBlock ( );
   18553             :       static void deleteStaticDataOfEasyStorageClasses ( );
   18554             :       static void pickOutStaticDataMembers ( );
   18555             :       static void rebuildStaticDataMembers ( );
   18556             :       static void writeEasyStorageDataToFile (std::ostream& out);
   18557             :       static void readEasyStorageDataFromFile (std::istream& in);
   18558             :       static void writeStaticDataToFile (std::ostream& out );
   18559             :       static void readStaticDataFromFile (std::istream& in );
   18560             :       friend class SgPointerAssignOp;
   18561             :    };
   18562             : /* #line 18563 "../../../src/frontend/SageIII//StorageClasses.h" */
   18563             : 
   18564             : 
   18565             : 
   18566             : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarStorageClassDeclatationMacros.macro" */
   18567             : /* 
   18568             :    JH (01/01/2006) ROSETTA generated class declarations for SgUserDefinedBinaryOpStorageClass 
   18569             :    used for the ast file IO. Do not chance by hand! 
   18570             : */
   18571           0 : class SgUserDefinedBinaryOpStorageClass  : public SgBinaryOpStorageClass
   18572             :    {
   18573             : 
   18574             :     protected: 
   18575             : 
   18576             : 
   18577             : /* #line 18578 "../../../src/frontend/SageIII//StorageClasses.h" */
   18578             : 
   18579             :       SgNameStorageClass storageOf_operator_name;
   18580             :      unsigned long storageOf_symbol;
   18581             : 
   18582             : 
   18583             : /* #line 10 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarStorageClassDeclatationMacros.macro" */
   18584             : 
   18585             : 
   18586             :     public:
   18587             :       void pickOutIRNodeData ( SgUserDefinedBinaryOp* source );
   18588             :       static void arrangeStaticDataOfEasyStorageClassesInOneBlock ( );
   18589             :       static void deleteStaticDataOfEasyStorageClasses ( );
   18590             :       static void pickOutStaticDataMembers ( );
   18591             :       static void rebuildStaticDataMembers ( );
   18592             :       static void writeEasyStorageDataToFile (std::ostream& out);
   18593             :       static void readEasyStorageDataFromFile (std::istream& in);
   18594             :       static void writeStaticDataToFile (std::ostream& out );
   18595             :       static void readStaticDataFromFile (std::istream& in );
   18596             :       friend class SgUserDefinedBinaryOp;
   18597             :    };
   18598             : /* #line 18599 "../../../src/frontend/SageIII//StorageClasses.h" */
   18599             : 
   18600             : 
   18601             : 
   18602             : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarStorageClassDeclatationMacros.macro" */
   18603             : /* 
   18604             :    JH (01/01/2006) ROSETTA generated class declarations for SgCompoundAssignOpStorageClass 
   18605             :    used for the ast file IO. Do not chance by hand! 
   18606             : */
   18607           0 : class SgCompoundAssignOpStorageClass  : public SgBinaryOpStorageClass
   18608             :    {
   18609             : 
   18610             :     protected: 
   18611             : 
   18612             : 
   18613             : /* #line 18614 "../../../src/frontend/SageIII//StorageClasses.h" */
   18614             : 
   18615             : 
   18616             : 
   18617             : /* #line 10 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarStorageClassDeclatationMacros.macro" */
   18618             : 
   18619             : 
   18620             :     public:
   18621             :       void pickOutIRNodeData ( SgCompoundAssignOp* source );
   18622             :       static void arrangeStaticDataOfEasyStorageClassesInOneBlock ( );
   18623             :       static void deleteStaticDataOfEasyStorageClasses ( );
   18624             :       static void pickOutStaticDataMembers ( );
   18625             :       static void rebuildStaticDataMembers ( );
   18626             :       static void writeEasyStorageDataToFile (std::ostream& out);
   18627             :       static void readEasyStorageDataFromFile (std::istream& in);
   18628             :       static void writeStaticDataToFile (std::ostream& out );
   18629             :       static void readStaticDataFromFile (std::istream& in );
   18630             :       friend class SgCompoundAssignOp;
   18631             :    };
   18632             : /* #line 18633 "../../../src/frontend/SageIII//StorageClasses.h" */
   18633             : 
   18634             : 
   18635             : 
   18636             : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarStorageClassDeclatationMacros.macro" */
   18637             : /* 
   18638             :    JH (01/01/2006) ROSETTA generated class declarations for SgPlusAssignOpStorageClass 
   18639             :    used for the ast file IO. Do not chance by hand! 
   18640             : */
   18641          58 : class SgPlusAssignOpStorageClass  : public SgCompoundAssignOpStorageClass
   18642             :    {
   18643             : 
   18644             :     protected: 
   18645             : 
   18646             : 
   18647             : /* #line 18648 "../../../src/frontend/SageIII//StorageClasses.h" */
   18648             : 
   18649             : 
   18650             : 
   18651             : /* #line 10 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarStorageClassDeclatationMacros.macro" */
   18652             : 
   18653             : 
   18654             :     public:
   18655             :       void pickOutIRNodeData ( SgPlusAssignOp* source );
   18656             :       static void arrangeStaticDataOfEasyStorageClassesInOneBlock ( );
   18657             :       static void deleteStaticDataOfEasyStorageClasses ( );
   18658             :       static void pickOutStaticDataMembers ( );
   18659             :       static void rebuildStaticDataMembers ( );
   18660             :       static void writeEasyStorageDataToFile (std::ostream& out);
   18661             :       static void readEasyStorageDataFromFile (std::istream& in);
   18662             :       static void writeStaticDataToFile (std::ostream& out );
   18663             :       static void readStaticDataFromFile (std::istream& in );
   18664             :       friend class SgPlusAssignOp;
   18665             :    };
   18666             : /* #line 18667 "../../../src/frontend/SageIII//StorageClasses.h" */
   18667             : 
   18668             : 
   18669             : 
   18670             : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarStorageClassDeclatationMacros.macro" */
   18671             : /* 
   18672             :    JH (01/01/2006) ROSETTA generated class declarations for SgMinusAssignOpStorageClass 
   18673             :    used for the ast file IO. Do not chance by hand! 
   18674             : */
   18675          20 : class SgMinusAssignOpStorageClass  : public SgCompoundAssignOpStorageClass
   18676             :    {
   18677             : 
   18678             :     protected: 
   18679             : 
   18680             : 
   18681             : /* #line 18682 "../../../src/frontend/SageIII//StorageClasses.h" */
   18682             : 
   18683             : 
   18684             : 
   18685             : /* #line 10 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarStorageClassDeclatationMacros.macro" */
   18686             : 
   18687             : 
   18688             :     public:
   18689             :       void pickOutIRNodeData ( SgMinusAssignOp* source );
   18690             :       static void arrangeStaticDataOfEasyStorageClassesInOneBlock ( );
   18691             :       static void deleteStaticDataOfEasyStorageClasses ( );
   18692             :       static void pickOutStaticDataMembers ( );
   18693             :       static void rebuildStaticDataMembers ( );
   18694             :       static void writeEasyStorageDataToFile (std::ostream& out);
   18695             :       static void readEasyStorageDataFromFile (std::istream& in);
   18696             :       static void writeStaticDataToFile (std::ostream& out );
   18697             :       static void readStaticDataFromFile (std::istream& in );
   18698             :       friend class SgMinusAssignOp;
   18699             :    };
   18700             : /* #line 18701 "../../../src/frontend/SageIII//StorageClasses.h" */
   18701             : 
   18702             : 
   18703             : 
   18704             : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarStorageClassDeclatationMacros.macro" */
   18705             : /* 
   18706             :    JH (01/01/2006) ROSETTA generated class declarations for SgAndAssignOpStorageClass 
   18707             :    used for the ast file IO. Do not chance by hand! 
   18708             : */
   18709           0 : class SgAndAssignOpStorageClass  : public SgCompoundAssignOpStorageClass
   18710             :    {
   18711             : 
   18712             :     protected: 
   18713             : 
   18714             : 
   18715             : /* #line 18716 "../../../src/frontend/SageIII//StorageClasses.h" */
   18716             : 
   18717             : 
   18718             : 
   18719             : /* #line 10 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarStorageClassDeclatationMacros.macro" */
   18720             : 
   18721             : 
   18722             :     public:
   18723             :       void pickOutIRNodeData ( SgAndAssignOp* source );
   18724             :       static void arrangeStaticDataOfEasyStorageClassesInOneBlock ( );
   18725             :       static void deleteStaticDataOfEasyStorageClasses ( );
   18726             :       static void pickOutStaticDataMembers ( );
   18727             :       static void rebuildStaticDataMembers ( );
   18728             :       static void writeEasyStorageDataToFile (std::ostream& out);
   18729             :       static void readEasyStorageDataFromFile (std::istream& in);
   18730             :       static void writeStaticDataToFile (std::ostream& out );
   18731             :       static void readStaticDataFromFile (std::istream& in );
   18732             :       friend class SgAndAssignOp;
   18733             :    };
   18734             : /* #line 18735 "../../../src/frontend/SageIII//StorageClasses.h" */
   18735             : 
   18736             : 
   18737             : 
   18738             : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarStorageClassDeclatationMacros.macro" */
   18739             : /* 
   18740             :    JH (01/01/2006) ROSETTA generated class declarations for SgIorAssignOpStorageClass 
   18741             :    used for the ast file IO. Do not chance by hand! 
   18742             : */
   18743          14 : class SgIorAssignOpStorageClass  : public SgCompoundAssignOpStorageClass
   18744             :    {
   18745             : 
   18746             :     protected: 
   18747             : 
   18748             : 
   18749             : /* #line 18750 "../../../src/frontend/SageIII//StorageClasses.h" */
   18750             : 
   18751             : 
   18752             : 
   18753             : /* #line 10 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarStorageClassDeclatationMacros.macro" */
   18754             : 
   18755             : 
   18756             :     public:
   18757             :       void pickOutIRNodeData ( SgIorAssignOp* source );
   18758             :       static void arrangeStaticDataOfEasyStorageClassesInOneBlock ( );
   18759             :       static void deleteStaticDataOfEasyStorageClasses ( );
   18760             :       static void pickOutStaticDataMembers ( );
   18761             :       static void rebuildStaticDataMembers ( );
   18762             :       static void writeEasyStorageDataToFile (std::ostream& out);
   18763             :       static void readEasyStorageDataFromFile (std::istream& in);
   18764             :       static void writeStaticDataToFile (std::ostream& out );
   18765             :       static void readStaticDataFromFile (std::istream& in );
   18766             :       friend class SgIorAssignOp;
   18767             :    };
   18768             : /* #line 18769 "../../../src/frontend/SageIII//StorageClasses.h" */
   18769             : 
   18770             : 
   18771             : 
   18772             : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarStorageClassDeclatationMacros.macro" */
   18773             : /* 
   18774             :    JH (01/01/2006) ROSETTA generated class declarations for SgMultAssignOpStorageClass 
   18775             :    used for the ast file IO. Do not chance by hand! 
   18776             : */
   18777           4 : class SgMultAssignOpStorageClass  : public SgCompoundAssignOpStorageClass
   18778             :    {
   18779             : 
   18780             :     protected: 
   18781             : 
   18782             : 
   18783             : /* #line 18784 "../../../src/frontend/SageIII//StorageClasses.h" */
   18784             : 
   18785             : 
   18786             : 
   18787             : /* #line 10 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarStorageClassDeclatationMacros.macro" */
   18788             : 
   18789             : 
   18790             :     public:
   18791             :       void pickOutIRNodeData ( SgMultAssignOp* source );
   18792             :       static void arrangeStaticDataOfEasyStorageClassesInOneBlock ( );
   18793             :       static void deleteStaticDataOfEasyStorageClasses ( );
   18794             :       static void pickOutStaticDataMembers ( );
   18795             :       static void rebuildStaticDataMembers ( );
   18796             :       static void writeEasyStorageDataToFile (std::ostream& out);
   18797             :       static void readEasyStorageDataFromFile (std::istream& in);
   18798             :       static void writeStaticDataToFile (std::ostream& out );
   18799             :       static void readStaticDataFromFile (std::istream& in );
   18800             :       friend class SgMultAssignOp;
   18801             :    };
   18802             : /* #line 18803 "../../../src/frontend/SageIII//StorageClasses.h" */
   18803             : 
   18804             : 
   18805             : 
   18806             : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarStorageClassDeclatationMacros.macro" */
   18807             : /* 
   18808             :    JH (01/01/2006) ROSETTA generated class declarations for SgDivAssignOpStorageClass 
   18809             :    used for the ast file IO. Do not chance by hand! 
   18810             : */
   18811           2 : class SgDivAssignOpStorageClass  : public SgCompoundAssignOpStorageClass
   18812             :    {
   18813             : 
   18814             :     protected: 
   18815             : 
   18816             : 
   18817             : /* #line 18818 "../../../src/frontend/SageIII//StorageClasses.h" */
   18818             : 
   18819             : 
   18820             : 
   18821             : /* #line 10 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarStorageClassDeclatationMacros.macro" */
   18822             : 
   18823             : 
   18824             :     public:
   18825             :       void pickOutIRNodeData ( SgDivAssignOp* source );
   18826             :       static void arrangeStaticDataOfEasyStorageClassesInOneBlock ( );
   18827             :       static void deleteStaticDataOfEasyStorageClasses ( );
   18828             :       static void pickOutStaticDataMembers ( );
   18829             :       static void rebuildStaticDataMembers ( );
   18830             :       static void writeEasyStorageDataToFile (std::ostream& out);
   18831             :       static void readEasyStorageDataFromFile (std::istream& in);
   18832             :       static void writeStaticDataToFile (std::ostream& out );
   18833             :       static void readStaticDataFromFile (std::istream& in );
   18834             :       friend class SgDivAssignOp;
   18835             :    };
   18836             : /* #line 18837 "../../../src/frontend/SageIII//StorageClasses.h" */
   18837             : 
   18838             : 
   18839             : 
   18840             : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarStorageClassDeclatationMacros.macro" */
   18841             : /* 
   18842             :    JH (01/01/2006) ROSETTA generated class declarations for SgModAssignOpStorageClass 
   18843             :    used for the ast file IO. Do not chance by hand! 
   18844             : */
   18845           0 : class SgModAssignOpStorageClass  : public SgCompoundAssignOpStorageClass
   18846             :    {
   18847             : 
   18848             :     protected: 
   18849             : 
   18850             : 
   18851             : /* #line 18852 "../../../src/frontend/SageIII//StorageClasses.h" */
   18852             : 
   18853             : 
   18854             : 
   18855             : /* #line 10 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarStorageClassDeclatationMacros.macro" */
   18856             : 
   18857             : 
   18858             :     public:
   18859             :       void pickOutIRNodeData ( SgModAssignOp* source );
   18860             :       static void arrangeStaticDataOfEasyStorageClassesInOneBlock ( );
   18861             :       static void deleteStaticDataOfEasyStorageClasses ( );
   18862             :       static void pickOutStaticDataMembers ( );
   18863             :       static void rebuildStaticDataMembers ( );
   18864             :       static void writeEasyStorageDataToFile (std::ostream& out);
   18865             :       static void readEasyStorageDataFromFile (std::istream& in);
   18866             :       static void writeStaticDataToFile (std::ostream& out );
   18867             :       static void readStaticDataFromFile (std::istream& in );
   18868             :       friend class SgModAssignOp;
   18869             :    };
   18870             : /* #line 18871 "../../../src/frontend/SageIII//StorageClasses.h" */
   18871             : 
   18872             : 
   18873             : 
   18874             : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarStorageClassDeclatationMacros.macro" */
   18875             : /* 
   18876             :    JH (01/01/2006) ROSETTA generated class declarations for SgXorAssignOpStorageClass 
   18877             :    used for the ast file IO. Do not chance by hand! 
   18878             : */
   18879           0 : class SgXorAssignOpStorageClass  : public SgCompoundAssignOpStorageClass
   18880             :    {
   18881             : 
   18882             :     protected: 
   18883             : 
   18884             : 
   18885             : /* #line 18886 "../../../src/frontend/SageIII//StorageClasses.h" */
   18886             : 
   18887             : 
   18888             : 
   18889             : /* #line 10 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarStorageClassDeclatationMacros.macro" */
   18890             : 
   18891             : 
   18892             :     public:
   18893             :       void pickOutIRNodeData ( SgXorAssignOp* source );
   18894             :       static void arrangeStaticDataOfEasyStorageClassesInOneBlock ( );
   18895             :       static void deleteStaticDataOfEasyStorageClasses ( );
   18896             :       static void pickOutStaticDataMembers ( );
   18897             :       static void rebuildStaticDataMembers ( );
   18898             :       static void writeEasyStorageDataToFile (std::ostream& out);
   18899             :       static void readEasyStorageDataFromFile (std::istream& in);
   18900             :       static void writeStaticDataToFile (std::ostream& out );
   18901             :       static void readStaticDataFromFile (std::istream& in );
   18902             :       friend class SgXorAssignOp;
   18903             :    };
   18904             : /* #line 18905 "../../../src/frontend/SageIII//StorageClasses.h" */
   18905             : 
   18906             : 
   18907             : 
   18908             : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarStorageClassDeclatationMacros.macro" */
   18909             : /* 
   18910             :    JH (01/01/2006) ROSETTA generated class declarations for SgLshiftAssignOpStorageClass 
   18911             :    used for the ast file IO. Do not chance by hand! 
   18912             : */
   18913           0 : class SgLshiftAssignOpStorageClass  : public SgCompoundAssignOpStorageClass
   18914             :    {
   18915             : 
   18916             :     protected: 
   18917             : 
   18918             : 
   18919             : /* #line 18920 "../../../src/frontend/SageIII//StorageClasses.h" */
   18920             : 
   18921             : 
   18922             : 
   18923             : /* #line 10 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarStorageClassDeclatationMacros.macro" */
   18924             : 
   18925             : 
   18926             :     public:
   18927             :       void pickOutIRNodeData ( SgLshiftAssignOp* source );
   18928             :       static void arrangeStaticDataOfEasyStorageClassesInOneBlock ( );
   18929             :       static void deleteStaticDataOfEasyStorageClasses ( );
   18930             :       static void pickOutStaticDataMembers ( );
   18931             :       static void rebuildStaticDataMembers ( );
   18932             :       static void writeEasyStorageDataToFile (std::ostream& out);
   18933             :       static void readEasyStorageDataFromFile (std::istream& in);
   18934             :       static void writeStaticDataToFile (std::ostream& out );
   18935             :       static void readStaticDataFromFile (std::istream& in );
   18936             :       friend class SgLshiftAssignOp;
   18937             :    };
   18938             : /* #line 18939 "../../../src/frontend/SageIII//StorageClasses.h" */
   18939             : 
   18940             : 
   18941             : 
   18942             : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarStorageClassDeclatationMacros.macro" */
   18943             : /* 
   18944             :    JH (01/01/2006) ROSETTA generated class declarations for SgRshiftAssignOpStorageClass 
   18945             :    used for the ast file IO. Do not chance by hand! 
   18946             : */
   18947           4 : class SgRshiftAssignOpStorageClass  : public SgCompoundAssignOpStorageClass
   18948             :    {
   18949             : 
   18950             :     protected: 
   18951             : 
   18952             : 
   18953             : /* #line 18954 "../../../src/frontend/SageIII//StorageClasses.h" */
   18954             : 
   18955             : 
   18956             : 
   18957             : /* #line 10 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarStorageClassDeclatationMacros.macro" */
   18958             : 
   18959             : 
   18960             :     public:
   18961             :       void pickOutIRNodeData ( SgRshiftAssignOp* source );
   18962             :       static void arrangeStaticDataOfEasyStorageClassesInOneBlock ( );
   18963             :       static void deleteStaticDataOfEasyStorageClasses ( );
   18964             :       static void pickOutStaticDataMembers ( );
   18965             :       static void rebuildStaticDataMembers ( );
   18966             :       static void writeEasyStorageDataToFile (std::ostream& out);
   18967             :       static void readEasyStorageDataFromFile (std::istream& in);
   18968             :       static void writeStaticDataToFile (std::ostream& out );
   18969             :       static void readStaticDataFromFile (std::istream& in );
   18970             :       friend class SgRshiftAssignOp;
   18971             :    };
   18972             : /* #line 18973 "../../../src/frontend/SageIII//StorageClasses.h" */
   18973             : 
   18974             : 
   18975             : 
   18976             : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarStorageClassDeclatationMacros.macro" */
   18977             : /* 
   18978             :    JH (01/01/2006) ROSETTA generated class declarations for SgIntegerDivideAssignOpStorageClass 
   18979             :    used for the ast file IO. Do not chance by hand! 
   18980             : */
   18981           0 : class SgIntegerDivideAssignOpStorageClass  : public SgCompoundAssignOpStorageClass
   18982             :    {
   18983             : 
   18984             :     protected: 
   18985             : 
   18986             : 
   18987             : /* #line 18988 "../../../src/frontend/SageIII//StorageClasses.h" */
   18988             : 
   18989             : 
   18990             : 
   18991             : /* #line 10 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarStorageClassDeclatationMacros.macro" */
   18992             : 
   18993             : 
   18994             :     public:
   18995             :       void pickOutIRNodeData ( SgIntegerDivideAssignOp* source );
   18996             :       static void arrangeStaticDataOfEasyStorageClassesInOneBlock ( );
   18997             :       static void deleteStaticDataOfEasyStorageClasses ( );
   18998             :       static void pickOutStaticDataMembers ( );
   18999             :       static void rebuildStaticDataMembers ( );
   19000             :       static void writeEasyStorageDataToFile (std::ostream& out);
   19001             :       static void readEasyStorageDataFromFile (std::istream& in);
   19002             :       static void writeStaticDataToFile (std::ostream& out );
   19003             :       static void readStaticDataFromFile (std::istream& in );
   19004             :       friend class SgIntegerDivideAssignOp;
   19005             :    };
   19006             : /* #line 19007 "../../../src/frontend/SageIII//StorageClasses.h" */
   19007             : 
   19008             : 
   19009             : 
   19010             : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarStorageClassDeclatationMacros.macro" */
   19011             : /* 
   19012             :    JH (01/01/2006) ROSETTA generated class declarations for SgExponentiationAssignOpStorageClass 
   19013             :    used for the ast file IO. Do not chance by hand! 
   19014             : */
   19015           0 : class SgExponentiationAssignOpStorageClass  : public SgCompoundAssignOpStorageClass
   19016             :    {
   19017             : 
   19018             :     protected: 
   19019             : 
   19020             : 
   19021             : /* #line 19022 "../../../src/frontend/SageIII//StorageClasses.h" */
   19022             : 
   19023             : 
   19024             : 
   19025             : /* #line 10 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarStorageClassDeclatationMacros.macro" */
   19026             : 
   19027             : 
   19028             :     public:
   19029             :       void pickOutIRNodeData ( SgExponentiationAssignOp* source );
   19030             :       static void arrangeStaticDataOfEasyStorageClassesInOneBlock ( );
   19031             :       static void deleteStaticDataOfEasyStorageClasses ( );
   19032             :       static void pickOutStaticDataMembers ( );
   19033             :       static void rebuildStaticDataMembers ( );
   19034             :       static void writeEasyStorageDataToFile (std::ostream& out);
   19035             :       static void readEasyStorageDataFromFile (std::istream& in);
   19036             :       static void writeStaticDataToFile (std::ostream& out );
   19037             :       static void readStaticDataFromFile (std::istream& in );
   19038             :       friend class SgExponentiationAssignOp;
   19039             :    };
   19040             : /* #line 19041 "../../../src/frontend/SageIII//StorageClasses.h" */
   19041             : 
   19042             : 
   19043             : 
   19044             : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarStorageClassDeclatationMacros.macro" */
   19045             : /* 
   19046             :    JH (01/01/2006) ROSETTA generated class declarations for SgMembershipOpStorageClass 
   19047             :    used for the ast file IO. Do not chance by hand! 
   19048             : */
   19049           0 : class SgMembershipOpStorageClass  : public SgBinaryOpStorageClass
   19050             :    {
   19051             : 
   19052             :     protected: 
   19053             : 
   19054             : 
   19055             : /* #line 19056 "../../../src/frontend/SageIII//StorageClasses.h" */
   19056             : 
   19057             : 
   19058             : 
   19059             : /* #line 10 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarStorageClassDeclatationMacros.macro" */
   19060             : 
   19061             : 
   19062             :     public:
   19063             :       void pickOutIRNodeData ( SgMembershipOp* source );
   19064             :       static void arrangeStaticDataOfEasyStorageClassesInOneBlock ( );
   19065             :       static void deleteStaticDataOfEasyStorageClasses ( );
   19066             :       static void pickOutStaticDataMembers ( );
   19067             :       static void rebuildStaticDataMembers ( );
   19068             :       static void writeEasyStorageDataToFile (std::ostream& out);
   19069             :       static void readEasyStorageDataFromFile (std::istream& in);
   19070             :       static void writeStaticDataToFile (std::ostream& out );
   19071             :       static void readStaticDataFromFile (std::istream& in );
   19072             :       friend class SgMembershipOp;
   19073             :    };
   19074             : /* #line 19075 "../../../src/frontend/SageIII//StorageClasses.h" */
   19075             : 
   19076             : 
   19077             : 
   19078             : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarStorageClassDeclatationMacros.macro" */
   19079             : /* 
   19080             :    JH (01/01/2006) ROSETTA generated class declarations for SgSpaceshipOpStorageClass 
   19081             :    used for the ast file IO. Do not chance by hand! 
   19082             : */
   19083           0 : class SgSpaceshipOpStorageClass  : public SgBinaryOpStorageClass
   19084             :    {
   19085             : 
   19086             :     protected: 
   19087             : 
   19088             : 
   19089             : /* #line 19090 "../../../src/frontend/SageIII//StorageClasses.h" */
   19090             : 
   19091             : 
   19092             : 
   19093             : /* #line 10 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarStorageClassDeclatationMacros.macro" */
   19094             : 
   19095             : 
   19096             :     public:
   19097             :       void pickOutIRNodeData ( SgSpaceshipOp* source );
   19098             :       static void arrangeStaticDataOfEasyStorageClassesInOneBlock ( );
   19099             :       static void deleteStaticDataOfEasyStorageClasses ( );
   19100             :       static void pickOutStaticDataMembers ( );
   19101             :       static void rebuildStaticDataMembers ( );
   19102             :       static void writeEasyStorageDataToFile (std::ostream& out);
   19103             :       static void readEasyStorageDataFromFile (std::istream& in);
   19104             :       static void writeStaticDataToFile (std::ostream& out );
   19105             :       static void readStaticDataFromFile (std::istream& in );
   19106             :       friend class SgSpaceshipOp;
   19107             :    };
   19108             : /* #line 19109 "../../../src/frontend/SageIII//StorageClasses.h" */
   19109             : 
   19110             : 
   19111             : 
   19112             : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarStorageClassDeclatationMacros.macro" */
   19113             : /* 
   19114             :    JH (01/01/2006) ROSETTA generated class declarations for SgNonMembershipOpStorageClass 
   19115             :    used for the ast file IO. Do not chance by hand! 
   19116             : */
   19117           0 : class SgNonMembershipOpStorageClass  : public SgBinaryOpStorageClass
   19118             :    {
   19119             : 
   19120             :     protected: 
   19121             : 
   19122             : 
   19123             : /* #line 19124 "../../../src/frontend/SageIII//StorageClasses.h" */
   19124             : 
   19125             : 
   19126             : 
   19127             : /* #line 10 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarStorageClassDeclatationMacros.macro" */
   19128             : 
   19129             : 
   19130             :     public:
   19131             :       void pickOutIRNodeData ( SgNonMembershipOp* source );
   19132             :       static void arrangeStaticDataOfEasyStorageClassesInOneBlock ( );
   19133             :       static void deleteStaticDataOfEasyStorageClasses ( );
   19134             :       static void pickOutStaticDataMembers ( );
   19135             :       static void rebuildStaticDataMembers ( );
   19136             :       static void writeEasyStorageDataToFile (std::ostream& out);
   19137             :       static void readEasyStorageDataFromFile (std::istream& in);
   19138             :       static void writeStaticDataToFile (std::ostream& out );
   19139             :       static void readStaticDataFromFile (std::istream& in );
   19140             :       friend class SgNonMembershipOp;
   19141             :    };
   19142             : /* #line 19143 "../../../src/frontend/SageIII//StorageClasses.h" */
   19143             : 
   19144             : 
   19145             : 
   19146             : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarStorageClassDeclatationMacros.macro" */
   19147             : /* 
   19148             :    JH (01/01/2006) ROSETTA generated class declarations for SgIsOpStorageClass 
   19149             :    used for the ast file IO. Do not chance by hand! 
   19150             : */
   19151           0 : class SgIsOpStorageClass  : public SgBinaryOpStorageClass
   19152             :    {
   19153             : 
   19154             :     protected: 
   19155             : 
   19156             : 
   19157             : /* #line 19158 "../../../src/frontend/SageIII//StorageClasses.h" */
   19158             : 
   19159             : 
   19160             : 
   19161             : /* #line 10 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarStorageClassDeclatationMacros.macro" */
   19162             : 
   19163             : 
   19164             :     public:
   19165             :       void pickOutIRNodeData ( SgIsOp* source );
   19166             :       static void arrangeStaticDataOfEasyStorageClassesInOneBlock ( );
   19167             :       static void deleteStaticDataOfEasyStorageClasses ( );
   19168             :       static void pickOutStaticDataMembers ( );
   19169             :       static void rebuildStaticDataMembers ( );
   19170             :       static void writeEasyStorageDataToFile (std::ostream& out);
   19171             :       static void readEasyStorageDataFromFile (std::istream& in);
   19172             :       static void writeStaticDataToFile (std::ostream& out );
   19173             :       static void readStaticDataFromFile (std::istream& in );
   19174             :       friend class SgIsOp;
   19175             :    };
   19176             : /* #line 19177 "../../../src/frontend/SageIII//StorageClasses.h" */
   19177             : 
   19178             : 
   19179             : 
   19180             : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarStorageClassDeclatationMacros.macro" */
   19181             : /* 
   19182             :    JH (01/01/2006) ROSETTA generated class declarations for SgIsNotOpStorageClass 
   19183             :    used for the ast file IO. Do not chance by hand! 
   19184             : */
   19185           0 : class SgIsNotOpStorageClass  : public SgBinaryOpStorageClass
   19186             :    {
   19187             : 
   19188             :     protected: 
   19189             : 
   19190             : 
   19191             : /* #line 19192 "../../../src/frontend/SageIII//StorageClasses.h" */
   19192             : 
   19193             : 
   19194             : 
   19195             : /* #line 10 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarStorageClassDeclatationMacros.macro" */
   19196             : 
   19197             : 
   19198             :     public:
   19199             :       void pickOutIRNodeData ( SgIsNotOp* source );
   19200             :       static void arrangeStaticDataOfEasyStorageClassesInOneBlock ( );
   19201             :       static void deleteStaticDataOfEasyStorageClasses ( );
   19202             :       static void pickOutStaticDataMembers ( );
   19203             :       static void rebuildStaticDataMembers ( );
   19204             :       static void writeEasyStorageDataToFile (std::ostream& out);
   19205             :       static void readEasyStorageDataFromFile (std::istream& in);
   19206             :       static void writeStaticDataToFile (std::ostream& out );
   19207             :       static void readStaticDataFromFile (std::istream& in );
   19208             :       friend class SgIsNotOp;
   19209             :    };
   19210             : /* #line 19211 "../../../src/frontend/SageIII//StorageClasses.h" */
   19211             : 
   19212             : 
   19213             : 
   19214             : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarStorageClassDeclatationMacros.macro" */
   19215             : /* 
   19216             :    JH (01/01/2006) ROSETTA generated class declarations for SgElementwiseOpStorageClass 
   19217             :    used for the ast file IO. Do not chance by hand! 
   19218             : */
   19219           0 : class SgElementwiseOpStorageClass  : public SgBinaryOpStorageClass
   19220             :    {
   19221             : 
   19222             :     protected: 
   19223             : 
   19224             : 
   19225             : /* #line 19226 "../../../src/frontend/SageIII//StorageClasses.h" */
   19226             : 
   19227             : 
   19228             : 
   19229             : /* #line 10 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarStorageClassDeclatationMacros.macro" */
   19230             : 
   19231             : 
   19232             :     public:
   19233             :       void pickOutIRNodeData ( SgElementwiseOp* source );
   19234             :       static void arrangeStaticDataOfEasyStorageClassesInOneBlock ( );
   19235             :       static void deleteStaticDataOfEasyStorageClasses ( );
   19236             :       static void pickOutStaticDataMembers ( );
   19237             :       static void rebuildStaticDataMembers ( );
   19238             :       static void writeEasyStorageDataToFile (std::ostream& out);
   19239             :       static void readEasyStorageDataFromFile (std::istream& in);
   19240             :       static void writeStaticDataToFile (std::ostream& out );
   19241             :       static void readStaticDataFromFile (std::istream& in );
   19242             :       friend class SgElementwiseOp;
   19243             :    };
   19244             : /* #line 19245 "../../../src/frontend/SageIII//StorageClasses.h" */
   19245             : 
   19246             : 
   19247             : 
   19248             : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarStorageClassDeclatationMacros.macro" */
   19249             : /* 
   19250             :    JH (01/01/2006) ROSETTA generated class declarations for SgElementwiseMultiplyOpStorageClass 
   19251             :    used for the ast file IO. Do not chance by hand! 
   19252             : */
   19253           0 : class SgElementwiseMultiplyOpStorageClass  : public SgElementwiseOpStorageClass
   19254             :    {
   19255             : 
   19256             :     protected: 
   19257             : 
   19258             : 
   19259             : /* #line 19260 "../../../src/frontend/SageIII//StorageClasses.h" */
   19260             : 
   19261             : 
   19262             : 
   19263             : /* #line 10 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarStorageClassDeclatationMacros.macro" */
   19264             : 
   19265             : 
   19266             :     public:
   19267             :       void pickOutIRNodeData ( SgElementwiseMultiplyOp* source );
   19268             :       static void arrangeStaticDataOfEasyStorageClassesInOneBlock ( );
   19269             :       static void deleteStaticDataOfEasyStorageClasses ( );
   19270             :       static void pickOutStaticDataMembers ( );
   19271             :       static void rebuildStaticDataMembers ( );
   19272             :       static void writeEasyStorageDataToFile (std::ostream& out);
   19273             :       static void readEasyStorageDataFromFile (std::istream& in);
   19274             :       static void writeStaticDataToFile (std::ostream& out );
   19275             :       static void readStaticDataFromFile (std::istream& in );
   19276             :       friend class SgElementwiseMultiplyOp;
   19277             :    };
   19278             : /* #line 19279 "../../../src/frontend/SageIII//StorageClasses.h" */
   19279             : 
   19280             : 
   19281             : 
   19282             : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarStorageClassDeclatationMacros.macro" */
   19283             : /* 
   19284             :    JH (01/01/2006) ROSETTA generated class declarations for SgElementwisePowerOpStorageClass 
   19285             :    used for the ast file IO. Do not chance by hand! 
   19286             : */
   19287           0 : class SgElementwisePowerOpStorageClass  : public SgElementwiseOpStorageClass
   19288             :    {
   19289             : 
   19290             :     protected: 
   19291             : 
   19292             : 
   19293             : /* #line 19294 "../../../src/frontend/SageIII//StorageClasses.h" */
   19294             : 
   19295             : 
   19296             : 
   19297             : /* #line 10 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarStorageClassDeclatationMacros.macro" */
   19298             : 
   19299             : 
   19300             :     public:
   19301             :       void pickOutIRNodeData ( SgElementwisePowerOp* source );
   19302             :       static void arrangeStaticDataOfEasyStorageClassesInOneBlock ( );
   19303             :       static void deleteStaticDataOfEasyStorageClasses ( );
   19304             :       static void pickOutStaticDataMembers ( );
   19305             :       static void rebuildStaticDataMembers ( );
   19306             :       static void writeEasyStorageDataToFile (std::ostream& out);
   19307             :       static void readEasyStorageDataFromFile (std::istream& in);
   19308             :       static void writeStaticDataToFile (std::ostream& out );
   19309             :       static void readStaticDataFromFile (std::istream& in );
   19310             :       friend class SgElementwisePowerOp;
   19311             :    };
   19312             : /* #line 19313 "../../../src/frontend/SageIII//StorageClasses.h" */
   19313             : 
   19314             : 
   19315             : 
   19316             : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarStorageClassDeclatationMacros.macro" */
   19317             : /* 
   19318             :    JH (01/01/2006) ROSETTA generated class declarations for SgElementwiseLeftDivideOpStorageClass 
   19319             :    used for the ast file IO. Do not chance by hand! 
   19320             : */
   19321           0 : class SgElementwiseLeftDivideOpStorageClass  : public SgElementwiseOpStorageClass
   19322             :    {
   19323             : 
   19324             :     protected: 
   19325             : 
   19326             : 
   19327             : /* #line 19328 "../../../src/frontend/SageIII//StorageClasses.h" */
   19328             : 
   19329             : 
   19330             : 
   19331             : /* #line 10 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarStorageClassDeclatationMacros.macro" */
   19332             : 
   19333             : 
   19334             :     public:
   19335             :       void pickOutIRNodeData ( SgElementwiseLeftDivideOp* source );
   19336             :       static void arrangeStaticDataOfEasyStorageClassesInOneBlock ( );
   19337             :       static void deleteStaticDataOfEasyStorageClasses ( );
   19338             :       static void pickOutStaticDataMembers ( );
   19339             :       static void rebuildStaticDataMembers ( );
   19340             :       static void writeEasyStorageDataToFile (std::ostream& out);
   19341             :       static void readEasyStorageDataFromFile (std::istream& in);
   19342             :       static void writeStaticDataToFile (std::ostream& out );
   19343             :       static void readStaticDataFromFile (std::istream& in );
   19344             :       friend class SgElementwiseLeftDivideOp;
   19345             :    };
   19346             : /* #line 19347 "../../../src/frontend/SageIII//StorageClasses.h" */
   19347             : 
   19348             : 
   19349             : 
   19350             : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarStorageClassDeclatationMacros.macro" */
   19351             : /* 
   19352             :    JH (01/01/2006) ROSETTA generated class declarations for SgElementwiseDivideOpStorageClass 
   19353             :    used for the ast file IO. Do not chance by hand! 
   19354             : */
   19355           0 : class SgElementwiseDivideOpStorageClass  : public SgElementwiseOpStorageClass
   19356             :    {
   19357             : 
   19358             :     protected: 
   19359             : 
   19360             : 
   19361             : /* #line 19362 "../../../src/frontend/SageIII//StorageClasses.h" */
   19362             : 
   19363             : 
   19364             : 
   19365             : /* #line 10 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarStorageClassDeclatationMacros.macro" */
   19366             : 
   19367             : 
   19368             :     public:
   19369             :       void pickOutIRNodeData ( SgElementwiseDivideOp* source );
   19370             :       static void arrangeStaticDataOfEasyStorageClassesInOneBlock ( );
   19371             :       static void deleteStaticDataOfEasyStorageClasses ( );
   19372             :       static void pickOutStaticDataMembers ( );
   19373             :       static void rebuildStaticDataMembers ( );
   19374             :       static void writeEasyStorageDataToFile (std::ostream& out);
   19375             :       static void readEasyStorageDataFromFile (std::istream& in);
   19376             :       static void writeStaticDataToFile (std::ostream& out );
   19377             :       static void readStaticDataFromFile (std::istream& in );
   19378             :       friend class SgElementwiseDivideOp;
   19379             :    };
   19380             : /* #line 19381 "../../../src/frontend/SageIII//StorageClasses.h" */
   19381             : 
   19382             : 
   19383             : 
   19384             : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarStorageClassDeclatationMacros.macro" */
   19385             : /* 
   19386             :    JH (01/01/2006) ROSETTA generated class declarations for SgElementwiseAddOpStorageClass 
   19387             :    used for the ast file IO. Do not chance by hand! 
   19388             : */
   19389           0 : class SgElementwiseAddOpStorageClass  : public SgElementwiseOpStorageClass
   19390             :    {
   19391             : 
   19392             :     protected: 
   19393             : 
   19394             : 
   19395             : /* #line 19396 "../../../src/frontend/SageIII//StorageClasses.h" */
   19396             : 
   19397             : 
   19398             : 
   19399             : /* #line 10 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarStorageClassDeclatationMacros.macro" */
   19400             : 
   19401             : 
   19402             :     public:
   19403             :       void pickOutIRNodeData ( SgElementwiseAddOp* source );
   19404             :       static void arrangeStaticDataOfEasyStorageClassesInOneBlock ( );
   19405             :       static void deleteStaticDataOfEasyStorageClasses ( );
   19406             :       static void pickOutStaticDataMembers ( );
   19407             :       static void rebuildStaticDataMembers ( );
   19408             :       static void writeEasyStorageDataToFile (std::ostream& out);
   19409             :       static void readEasyStorageDataFromFile (std::istream& in);
   19410             :       static void writeStaticDataToFile (std::ostream& out );
   19411             :       static void readStaticDataFromFile (std::istream& in );
   19412             :       friend class SgElementwiseAddOp;
   19413             :    };
   19414             : /* #line 19415 "../../../src/frontend/SageIII//StorageClasses.h" */
   19415             : 
   19416             : 
   19417             : 
   19418             : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarStorageClassDeclatationMacros.macro" */
   19419             : /* 
   19420             :    JH (01/01/2006) ROSETTA generated class declarations for SgElementwiseSubtractOpStorageClass 
   19421             :    used for the ast file IO. Do not chance by hand! 
   19422             : */
   19423           0 : class SgElementwiseSubtractOpStorageClass  : public SgElementwiseOpStorageClass
   19424             :    {
   19425             : 
   19426             :     protected: 
   19427             : 
   19428             : 
   19429             : /* #line 19430 "../../../src/frontend/SageIII//StorageClasses.h" */
   19430             : 
   19431             : 
   19432             : 
   19433             : /* #line 10 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarStorageClassDeclatationMacros.macro" */
   19434             : 
   19435             : 
   19436             :     public:
   19437             :       void pickOutIRNodeData ( SgElementwiseSubtractOp* source );
   19438             :       static void arrangeStaticDataOfEasyStorageClassesInOneBlock ( );
   19439             :       static void deleteStaticDataOfEasyStorageClasses ( );
   19440             :       static void pickOutStaticDataMembers ( );
   19441             :       static void rebuildStaticDataMembers ( );
   19442             :       static void writeEasyStorageDataToFile (std::ostream& out);
   19443             :       static void readEasyStorageDataFromFile (std::istream& in);
   19444             :       static void writeStaticDataToFile (std::ostream& out );
   19445             :       static void readStaticDataFromFile (std::istream& in );
   19446             :       friend class SgElementwiseSubtractOp;
   19447             :    };
   19448             : /* #line 19449 "../../../src/frontend/SageIII//StorageClasses.h" */
   19449             : 
   19450             : 
   19451             : 
   19452             : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarStorageClassDeclatationMacros.macro" */
   19453             : /* 
   19454             :    JH (01/01/2006) ROSETTA generated class declarations for SgPowerOpStorageClass 
   19455             :    used for the ast file IO. Do not chance by hand! 
   19456             : */
   19457           0 : class SgPowerOpStorageClass  : public SgBinaryOpStorageClass
   19458             :    {
   19459             : 
   19460             :     protected: 
   19461             : 
   19462             : 
   19463             : /* #line 19464 "../../../src/frontend/SageIII//StorageClasses.h" */
   19464             : 
   19465             : 
   19466             : 
   19467             : /* #line 10 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarStorageClassDeclatationMacros.macro" */
   19468             : 
   19469             : 
   19470             :     public:
   19471             :       void pickOutIRNodeData ( SgPowerOp* source );
   19472             :       static void arrangeStaticDataOfEasyStorageClassesInOneBlock ( );
   19473             :       static void deleteStaticDataOfEasyStorageClasses ( );
   19474             :       static void pickOutStaticDataMembers ( );
   19475             :       static void rebuildStaticDataMembers ( );
   19476             :       static void writeEasyStorageDataToFile (std::ostream& out);
   19477             :       static void readEasyStorageDataFromFile (std::istream& in);
   19478             :       static void writeStaticDataToFile (std::ostream& out );
   19479             :       static void readStaticDataFromFile (std::istream& in );
   19480             :       friend class SgPowerOp;
   19481             :    };
   19482             : /* #line 19483 "../../../src/frontend/SageIII//StorageClasses.h" */
   19483             : 
   19484             : 
   19485             : 
   19486             : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarStorageClassDeclatationMacros.macro" */
   19487             : /* 
   19488             :    JH (01/01/2006) ROSETTA generated class declarations for SgLeftDivideOpStorageClass 
   19489             :    used for the ast file IO. Do not chance by hand! 
   19490             : */
   19491           0 : class SgLeftDivideOpStorageClass  : public SgBinaryOpStorageClass
   19492             :    {
   19493             : 
   19494             :     protected: 
   19495             : 
   19496             : 
   19497             : /* #line 19498 "../../../src/frontend/SageIII//StorageClasses.h" */
   19498             : 
   19499             : 
   19500             : 
   19501             : /* #line 10 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarStorageClassDeclatationMacros.macro" */
   19502             : 
   19503             : 
   19504             :     public:
   19505             :       void pickOutIRNodeData ( SgLeftDivideOp* source );
   19506             :       static void arrangeStaticDataOfEasyStorageClassesInOneBlock ( );
   19507             :       static void deleteStaticDataOfEasyStorageClasses ( );
   19508             :       static void pickOutStaticDataMembers ( );
   19509             :       static void rebuildStaticDataMembers ( );
   19510             :       static void writeEasyStorageDataToFile (std::ostream& out);
   19511             :       static void readEasyStorageDataFromFile (std::istream& in);
   19512             :       static void writeStaticDataToFile (std::ostream& out );
   19513             :       static void readStaticDataFromFile (std::istream& in );
   19514             :       friend class SgLeftDivideOp;
   19515             :    };
   19516             : /* #line 19517 "../../../src/frontend/SageIII//StorageClasses.h" */
   19517             : 
   19518             : 
   19519             : 
   19520             : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarStorageClassDeclatationMacros.macro" */
   19521             : /* 
   19522             :    JH (01/01/2006) ROSETTA generated class declarations for SgSIMDBinaryOpStorageClass 
   19523             :    used for the ast file IO. Do not chance by hand! 
   19524             : */
   19525           0 : class SgSIMDBinaryOpStorageClass  : public SgBinaryOpStorageClass
   19526             :    {
   19527             : 
   19528             :     protected: 
   19529             : 
   19530             : 
   19531             : /* #line 19532 "../../../src/frontend/SageIII//StorageClasses.h" */
   19532             : 
   19533             : 
   19534             : 
   19535             : /* #line 10 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarStorageClassDeclatationMacros.macro" */
   19536             : 
   19537             : 
   19538             :     public:
   19539             :       void pickOutIRNodeData ( SgSIMDBinaryOp* source );
   19540             :       static void arrangeStaticDataOfEasyStorageClassesInOneBlock ( );
   19541             :       static void deleteStaticDataOfEasyStorageClasses ( );
   19542             :       static void pickOutStaticDataMembers ( );
   19543             :       static void rebuildStaticDataMembers ( );
   19544             :       static void writeEasyStorageDataToFile (std::ostream& out);
   19545             :       static void readEasyStorageDataFromFile (std::istream& in);
   19546             :       static void writeStaticDataToFile (std::ostream& out );
   19547             :       static void readStaticDataFromFile (std::istream& in );
   19548             :       friend class SgSIMDBinaryOp;
   19549             :    };
   19550             : /* #line 19551 "../../../src/frontend/SageIII//StorageClasses.h" */
   19551             : 
   19552             : 
   19553             : 
   19554             : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarStorageClassDeclatationMacros.macro" */
   19555             : /* 
   19556             :    JH (01/01/2006) ROSETTA generated class declarations for SgSIMDAddOpStorageClass 
   19557             :    used for the ast file IO. Do not chance by hand! 
   19558             : */
   19559           0 : class SgSIMDAddOpStorageClass  : public SgSIMDBinaryOpStorageClass
   19560             :    {
   19561             : 
   19562             :     protected: 
   19563             : 
   19564             : 
   19565             : /* #line 19566 "../../../src/frontend/SageIII//StorageClasses.h" */
   19566             : 
   19567             : 
   19568             : 
   19569             : /* #line 10 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarStorageClassDeclatationMacros.macro" */
   19570             : 
   19571             : 
   19572             :     public:
   19573             :       void pickOutIRNodeData ( SgSIMDAddOp* source );
   19574             :       static void arrangeStaticDataOfEasyStorageClassesInOneBlock ( );
   19575             :       static void deleteStaticDataOfEasyStorageClasses ( );
   19576             :       static void pickOutStaticDataMembers ( );
   19577             :       static void rebuildStaticDataMembers ( );
   19578             :       static void writeEasyStorageDataToFile (std::ostream& out);
   19579             :       static void readEasyStorageDataFromFile (std::istream& in);
   19580             :       static void writeStaticDataToFile (std::ostream& out );
   19581             :       static void readStaticDataFromFile (std::istream& in );
   19582             :       friend class SgSIMDAddOp;
   19583             :    };
   19584             : /* #line 19585 "../../../src/frontend/SageIII//StorageClasses.h" */
   19585             : 
   19586             : 
   19587             : 
   19588             : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarStorageClassDeclatationMacros.macro" */
   19589             : /* 
   19590             :    JH (01/01/2006) ROSETTA generated class declarations for SgSIMDSubOpStorageClass 
   19591             :    used for the ast file IO. Do not chance by hand! 
   19592             : */
   19593           0 : class SgSIMDSubOpStorageClass  : public SgSIMDBinaryOpStorageClass
   19594             :    {
   19595             : 
   19596             :     protected: 
   19597             : 
   19598             : 
   19599             : /* #line 19600 "../../../src/frontend/SageIII//StorageClasses.h" */
   19600             : 
   19601             : 
   19602             : 
   19603             : /* #line 10 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarStorageClassDeclatationMacros.macro" */
   19604             : 
   19605             : 
   19606             :     public:
   19607             :       void pickOutIRNodeData ( SgSIMDSubOp* source );
   19608             :       static void arrangeStaticDataOfEasyStorageClassesInOneBlock ( );
   19609             :       static void deleteStaticDataOfEasyStorageClasses ( );
   19610             :       static void pickOutStaticDataMembers ( );
   19611             :       static void rebuildStaticDataMembers ( );
   19612             :       static void writeEasyStorageDataToFile (std::ostream& out);
   19613             :       static void readEasyStorageDataFromFile (std::istream& in);
   19614             :       static void writeStaticDataToFile (std::ostream& out );
   19615             :       static void readStaticDataFromFile (std::istream& in );
   19616             :       friend class SgSIMDSubOp;
   19617             :    };
   19618             : /* #line 19619 "../../../src/frontend/SageIII//StorageClasses.h" */
   19619             : 
   19620             : 
   19621             : 
   19622             : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarStorageClassDeclatationMacros.macro" */
   19623             : /* 
   19624             :    JH (01/01/2006) ROSETTA generated class declarations for SgSIMDMulOpStorageClass 
   19625             :    used for the ast file IO. Do not chance by hand! 
   19626             : */
   19627           0 : class SgSIMDMulOpStorageClass  : public SgSIMDBinaryOpStorageClass
   19628             :    {
   19629             : 
   19630             :     protected: 
   19631             : 
   19632             : 
   19633             : /* #line 19634 "../../../src/frontend/SageIII//StorageClasses.h" */
   19634             : 
   19635             : 
   19636             : 
   19637             : /* #line 10 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarStorageClassDeclatationMacros.macro" */
   19638             : 
   19639             : 
   19640             :     public:
   19641             :       void pickOutIRNodeData ( SgSIMDMulOp* source );
   19642             :       static void arrangeStaticDataOfEasyStorageClassesInOneBlock ( );
   19643             :       static void deleteStaticDataOfEasyStorageClasses ( );
   19644             :       static void pickOutStaticDataMembers ( );
   19645             :       static void rebuildStaticDataMembers ( );
   19646             :       static void writeEasyStorageDataToFile (std::ostream& out);
   19647             :       static void readEasyStorageDataFromFile (std::istream& in);
   19648             :       static void writeStaticDataToFile (std::ostream& out );
   19649             :       static void readStaticDataFromFile (std::istream& in );
   19650             :       friend class SgSIMDMulOp;
   19651             :    };
   19652             : /* #line 19653 "../../../src/frontend/SageIII//StorageClasses.h" */
   19653             : 
   19654             : 
   19655             : 
   19656             : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarStorageClassDeclatationMacros.macro" */
   19657             : /* 
   19658             :    JH (01/01/2006) ROSETTA generated class declarations for SgSIMDDivOpStorageClass 
   19659             :    used for the ast file IO. Do not chance by hand! 
   19660             : */
   19661           0 : class SgSIMDDivOpStorageClass  : public SgSIMDBinaryOpStorageClass
   19662             :    {
   19663             : 
   19664             :     protected: 
   19665             : 
   19666             : 
   19667             : /* #line 19668 "../../../src/frontend/SageIII//StorageClasses.h" */
   19668             : 
   19669             : 
   19670             : 
   19671             : /* #line 10 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarStorageClassDeclatationMacros.macro" */
   19672             : 
   19673             : 
   19674             :     public:
   19675             :       void pickOutIRNodeData ( SgSIMDDivOp* source );
   19676             :       static void arrangeStaticDataOfEasyStorageClassesInOneBlock ( );
   19677             :       static void deleteStaticDataOfEasyStorageClasses ( );
   19678             :       static void pickOutStaticDataMembers ( );
   19679             :       static void rebuildStaticDataMembers ( );
   19680             :       static void writeEasyStorageDataToFile (std::ostream& out);
   19681             :       static void readEasyStorageDataFromFile (std::istream& in);
   19682             :       static void writeStaticDataToFile (std::ostream& out );
   19683             :       static void readStaticDataFromFile (std::istream& in );
   19684             :       friend class SgSIMDDivOp;
   19685             :    };
   19686             : /* #line 19687 "../../../src/frontend/SageIII//StorageClasses.h" */
   19687             : 
   19688             : 
   19689             : 
   19690             : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarStorageClassDeclatationMacros.macro" */
   19691             : /* 
   19692             :    JH (01/01/2006) ROSETTA generated class declarations for SgSIMDFmaOpStorageClass 
   19693             :    used for the ast file IO. Do not chance by hand! 
   19694             : */
   19695           0 : class SgSIMDFmaOpStorageClass  : public SgSIMDBinaryOpStorageClass
   19696             :    {
   19697             : 
   19698             :     protected: 
   19699             : 
   19700             : 
   19701             : /* #line 19702 "../../../src/frontend/SageIII//StorageClasses.h" */
   19702             : 
   19703             : 
   19704             : 
   19705             : /* #line 10 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarStorageClassDeclatationMacros.macro" */
   19706             : 
   19707             : 
   19708             :     public:
   19709             :       void pickOutIRNodeData ( SgSIMDFmaOp* source );
   19710             :       static void arrangeStaticDataOfEasyStorageClassesInOneBlock ( );
   19711             :       static void deleteStaticDataOfEasyStorageClasses ( );
   19712             :       static void pickOutStaticDataMembers ( );
   19713             :       static void rebuildStaticDataMembers ( );
   19714             :       static void writeEasyStorageDataToFile (std::ostream& out);
   19715             :       static void readEasyStorageDataFromFile (std::istream& in);
   19716             :       static void writeStaticDataToFile (std::ostream& out );
   19717             :       static void readStaticDataFromFile (std::istream& in );
   19718             :       friend class SgSIMDFmaOp;
   19719             :    };
   19720             : /* #line 19721 "../../../src/frontend/SageIII//StorageClasses.h" */
   19721             : 
   19722             : 
   19723             : 
   19724             : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarStorageClassDeclatationMacros.macro" */
   19725             : /* 
   19726             :    JH (01/01/2006) ROSETTA generated class declarations for SgSIMDLoadStorageClass 
   19727             :    used for the ast file IO. Do not chance by hand! 
   19728             : */
   19729           0 : class SgSIMDLoadStorageClass  : public SgBinaryOpStorageClass
   19730             :    {
   19731             : 
   19732             :     protected: 
   19733             : 
   19734             : 
   19735             : /* #line 19736 "../../../src/frontend/SageIII//StorageClasses.h" */
   19736             : 
   19737             : 
   19738             : 
   19739             : /* #line 10 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarStorageClassDeclatationMacros.macro" */
   19740             : 
   19741             : 
   19742             :     public:
   19743             :       void pickOutIRNodeData ( SgSIMDLoad* source );
   19744             :       static void arrangeStaticDataOfEasyStorageClassesInOneBlock ( );
   19745             :       static void deleteStaticDataOfEasyStorageClasses ( );
   19746             :       static void pickOutStaticDataMembers ( );
   19747             :       static void rebuildStaticDataMembers ( );
   19748             :       static void writeEasyStorageDataToFile (std::ostream& out);
   19749             :       static void readEasyStorageDataFromFile (std::istream& in);
   19750             :       static void writeStaticDataToFile (std::ostream& out );
   19751             :       static void readStaticDataFromFile (std::istream& in );
   19752             :       friend class SgSIMDLoad;
   19753             :    };
   19754             : /* #line 19755 "../../../src/frontend/SageIII//StorageClasses.h" */
   19755             : 
   19756             : 
   19757             : 
   19758             : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarStorageClassDeclatationMacros.macro" */
   19759             : /* 
   19760             :    JH (01/01/2006) ROSETTA generated class declarations for SgSIMDBroadcastStorageClass 
   19761             :    used for the ast file IO. Do not chance by hand! 
   19762             : */
   19763           0 : class SgSIMDBroadcastStorageClass  : public SgBinaryOpStorageClass
   19764             :    {
   19765             : 
   19766             :     protected: 
   19767             : 
   19768             : 
   19769             : /* #line 19770 "../../../src/frontend/SageIII//StorageClasses.h" */
   19770             : 
   19771             : 
   19772             : 
   19773             : /* #line 10 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarStorageClassDeclatationMacros.macro" */
   19774             : 
   19775             : 
   19776             :     public:
   19777             :       void pickOutIRNodeData ( SgSIMDBroadcast* source );
   19778             :       static void arrangeStaticDataOfEasyStorageClassesInOneBlock ( );
   19779             :       static void deleteStaticDataOfEasyStorageClasses ( );
   19780             :       static void pickOutStaticDataMembers ( );
   19781             :       static void rebuildStaticDataMembers ( );
   19782             :       static void writeEasyStorageDataToFile (std::ostream& out);
   19783             :       static void readEasyStorageDataFromFile (std::istream& in);
   19784             :       static void writeStaticDataToFile (std::ostream& out );
   19785             :       static void readStaticDataFromFile (std::istream& in );
   19786             :       friend class SgSIMDBroadcast;
   19787             :    };
   19788             : /* #line 19789 "../../../src/frontend/SageIII//StorageClasses.h" */
   19789             : 
   19790             : 
   19791             : 
   19792             : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarStorageClassDeclatationMacros.macro" */
   19793             : /* 
   19794             :    JH (01/01/2006) ROSETTA generated class declarations for SgSIMDStoreStorageClass 
   19795             :    used for the ast file IO. Do not chance by hand! 
   19796             : */
   19797           0 : class SgSIMDStoreStorageClass  : public SgBinaryOpStorageClass
   19798             :    {
   19799             : 
   19800             :     protected: 
   19801             : 
   19802             : 
   19803             : /* #line 19804 "../../../src/frontend/SageIII//StorageClasses.h" */
   19804             : 
   19805             : 
   19806             : 
   19807             : /* #line 10 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarStorageClassDeclatationMacros.macro" */
   19808             : 
   19809             : 
   19810             :     public:
   19811             :       void pickOutIRNodeData ( SgSIMDStore* source );
   19812             :       static void arrangeStaticDataOfEasyStorageClassesInOneBlock ( );
   19813             :       static void deleteStaticDataOfEasyStorageClasses ( );
   19814             :       static void pickOutStaticDataMembers ( );
   19815             :       static void rebuildStaticDataMembers ( );
   19816             :       static void writeEasyStorageDataToFile (std::ostream& out);
   19817             :       static void readEasyStorageDataFromFile (std::istream& in);
   19818             :       static void writeStaticDataToFile (std::ostream& out );
   19819             :       static void readStaticDataFromFile (std::istream& in );
   19820             :       friend class SgSIMDStore;
   19821             :    };
   19822             : /* #line 19823 "../../../src/frontend/SageIII//StorageClasses.h" */
   19823             : 
   19824             : 
   19825             : 
   19826             : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarStorageClassDeclatationMacros.macro" */
   19827             : /* 
   19828             :    JH (01/01/2006) ROSETTA generated class declarations for SgSIMDPartialStoreStorageClass 
   19829             :    used for the ast file IO. Do not chance by hand! 
   19830             : */
   19831           0 : class SgSIMDPartialStoreStorageClass  : public SgBinaryOpStorageClass
   19832             :    {
   19833             : 
   19834             :     protected: 
   19835             : 
   19836             : 
   19837             : /* #line 19838 "../../../src/frontend/SageIII//StorageClasses.h" */
   19838             : 
   19839             : 
   19840             : 
   19841             : /* #line 10 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarStorageClassDeclatationMacros.macro" */
   19842             : 
   19843             : 
   19844             :     public:
   19845             :       void pickOutIRNodeData ( SgSIMDPartialStore* source );
   19846             :       static void arrangeStaticDataOfEasyStorageClassesInOneBlock ( );
   19847             :       static void deleteStaticDataOfEasyStorageClasses ( );
   19848             :       static void pickOutStaticDataMembers ( );
   19849             :       static void rebuildStaticDataMembers ( );
   19850             :       static void writeEasyStorageDataToFile (std::ostream& out);
   19851             :       static void readEasyStorageDataFromFile (std::istream& in);
   19852             :       static void writeStaticDataToFile (std::ostream& out );
   19853             :       static void readStaticDataFromFile (std::istream& in );
   19854             :       friend class SgSIMDPartialStore;
   19855             :    };
   19856             : /* #line 19857 "../../../src/frontend/SageIII//StorageClasses.h" */
   19857             : 
   19858             : 
   19859             : 
   19860             : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarStorageClassDeclatationMacros.macro" */
   19861             : /* 
   19862             :    JH (01/01/2006) ROSETTA generated class declarations for SgSIMDScalarStoreStorageClass 
   19863             :    used for the ast file IO. Do not chance by hand! 
   19864             : */
   19865           0 : class SgSIMDScalarStoreStorageClass  : public SgBinaryOpStorageClass
   19866             :    {
   19867             : 
   19868             :     protected: 
   19869             : 
   19870             : 
   19871             : /* #line 19872 "../../../src/frontend/SageIII//StorageClasses.h" */
   19872             : 
   19873             : 
   19874             : 
   19875             : /* #line 10 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarStorageClassDeclatationMacros.macro" */
   19876             : 
   19877             : 
   19878             :     public:
   19879             :       void pickOutIRNodeData ( SgSIMDScalarStore* source );
   19880             :       static void arrangeStaticDataOfEasyStorageClassesInOneBlock ( );
   19881             :       static void deleteStaticDataOfEasyStorageClasses ( );
   19882             :       static void pickOutStaticDataMembers ( );
   19883             :       static void rebuildStaticDataMembers ( );
   19884             :       static void writeEasyStorageDataToFile (std::ostream& out);
   19885             :       static void readEasyStorageDataFromFile (std::istream& in);
   19886             :       static void writeStaticDataToFile (std::ostream& out );
   19887             :       static void readStaticDataFromFile (std::istream& in );
   19888             :       friend class SgSIMDScalarStore;
   19889             :    };
   19890             : /* #line 19891 "../../../src/frontend/SageIII//StorageClasses.h" */
   19891             : 
   19892             : 
   19893             : 
   19894             : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarStorageClassDeclatationMacros.macro" */
   19895             : /* 
   19896             :    JH (01/01/2006) ROSETTA generated class declarations for SgSIMDGatherStorageClass 
   19897             :    used for the ast file IO. Do not chance by hand! 
   19898             : */
   19899           0 : class SgSIMDGatherStorageClass  : public SgBinaryOpStorageClass
   19900             :    {
   19901             : 
   19902             :     protected: 
   19903             : 
   19904             : 
   19905             : /* #line 19906 "../../../src/frontend/SageIII//StorageClasses.h" */
   19906             : 
   19907             : 
   19908             : 
   19909             : /* #line 10 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarStorageClassDeclatationMacros.macro" */
   19910             : 
   19911             : 
   19912             :     public:
   19913             :       void pickOutIRNodeData ( SgSIMDGather* source );
   19914             :       static void arrangeStaticDataOfEasyStorageClassesInOneBlock ( );
   19915             :       static void deleteStaticDataOfEasyStorageClasses ( );
   19916             :       static void pickOutStaticDataMembers ( );
   19917             :       static void rebuildStaticDataMembers ( );
   19918             :       static void writeEasyStorageDataToFile (std::ostream& out);
   19919             :       static void readEasyStorageDataFromFile (std::istream& in);
   19920             :       static void writeStaticDataToFile (std::ostream& out );
   19921             :       static void readStaticDataFromFile (std::istream& in );
   19922             :       friend class SgSIMDGather;
   19923             :    };
   19924             : /* #line 19925 "../../../src/frontend/SageIII//StorageClasses.h" */
   19925             : 
   19926             : 
   19927             : 
   19928             : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarStorageClassDeclatationMacros.macro" */
   19929             : /* 
   19930             :    JH (01/01/2006) ROSETTA generated class declarations for SgSIMDExplicitGatherStorageClass 
   19931             :    used for the ast file IO. Do not chance by hand! 
   19932             : */
   19933           0 : class SgSIMDExplicitGatherStorageClass  : public SgBinaryOpStorageClass
   19934             :    {
   19935             : 
   19936             :     protected: 
   19937             : 
   19938             : 
   19939             : /* #line 19940 "../../../src/frontend/SageIII//StorageClasses.h" */
   19940             : 
   19941             : 
   19942             : 
   19943             : /* #line 10 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarStorageClassDeclatationMacros.macro" */
   19944             : 
   19945             : 
   19946             :     public:
   19947             :       void pickOutIRNodeData ( SgSIMDExplicitGather* source );
   19948             :       static void arrangeStaticDataOfEasyStorageClassesInOneBlock ( );
   19949             :       static void deleteStaticDataOfEasyStorageClasses ( );
   19950             :       static void pickOutStaticDataMembers ( );
   19951             :       static void rebuildStaticDataMembers ( );
   19952             :       static void writeEasyStorageDataToFile (std::ostream& out);
   19953             :       static void readEasyStorageDataFromFile (std::istream& in);
   19954             :       static void writeStaticDataToFile (std::ostream& out );
   19955             :       static void readStaticDataFromFile (std::istream& in );
   19956             :       friend class SgSIMDExplicitGather;
   19957             :    };
   19958             : /* #line 19959 "../../../src/frontend/SageIII//StorageClasses.h" */
   19959             : 
   19960             : 
   19961             : 
   19962             : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarStorageClassDeclatationMacros.macro" */
   19963             : /* 
   19964             :    JH (01/01/2006) ROSETTA generated class declarations for SgSIMDScatterStorageClass 
   19965             :    used for the ast file IO. Do not chance by hand! 
   19966             : */
   19967           0 : class SgSIMDScatterStorageClass  : public SgBinaryOpStorageClass
   19968             :    {
   19969             : 
   19970             :     protected: 
   19971             : 
   19972             : 
   19973             : /* #line 19974 "../../../src/frontend/SageIII//StorageClasses.h" */
   19974             : 
   19975             : 
   19976             : 
   19977             : /* #line 10 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarStorageClassDeclatationMacros.macro" */
   19978             : 
   19979             : 
   19980             :     public:
   19981             :       void pickOutIRNodeData ( SgSIMDScatter* source );
   19982             :       static void arrangeStaticDataOfEasyStorageClassesInOneBlock ( );
   19983             :       static void deleteStaticDataOfEasyStorageClasses ( );
   19984             :       static void pickOutStaticDataMembers ( );
   19985             :       static void rebuildStaticDataMembers ( );
   19986             :       static void writeEasyStorageDataToFile (std::ostream& out);
   19987             :       static void readEasyStorageDataFromFile (std::istream& in);
   19988             :       static void writeStaticDataToFile (std::ostream& out );
   19989             :       static void readStaticDataFromFile (std::istream& in );
   19990             :       friend class SgSIMDScatter;
   19991             :    };
   19992             : /* #line 19993 "../../../src/frontend/SageIII//StorageClasses.h" */
   19993             : 
   19994             : 
   19995             : 
   19996             : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarStorageClassDeclatationMacros.macro" */
   19997             : /* 
   19998             :    JH (01/01/2006) ROSETTA generated class declarations for SgExprListExpStorageClass 
   19999             :    used for the ast file IO. Do not chance by hand! 
   20000             : */
   20001        7383 : class SgExprListExpStorageClass  : public SgExpressionStorageClass
   20002             :    {
   20003             : 
   20004             :     protected: 
   20005             : 
   20006             : 
   20007             : /* #line 20008 "../../../src/frontend/SageIII//StorageClasses.h" */
   20008             : 
   20009             :        EasyStorage < SgExpressionPtrList > storageOf_expressions;
   20010             : 
   20011             : 
   20012             : /* #line 10 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarStorageClassDeclatationMacros.macro" */
   20013             : 
   20014             : 
   20015             :     public:
   20016             :       void pickOutIRNodeData ( SgExprListExp* source );
   20017             :       static void arrangeStaticDataOfEasyStorageClassesInOneBlock ( );
   20018             :       static void deleteStaticDataOfEasyStorageClasses ( );
   20019             :       static void pickOutStaticDataMembers ( );
   20020             :       static void rebuildStaticDataMembers ( );
   20021             :       static void writeEasyStorageDataToFile (std::ostream& out);
   20022             :       static void readEasyStorageDataFromFile (std::istream& in);
   20023             :       static void writeStaticDataToFile (std::ostream& out );
   20024             :       static void readStaticDataFromFile (std::istream& in );
   20025             :       friend class SgExprListExp;
   20026             :    };
   20027             : /* #line 20028 "../../../src/frontend/SageIII//StorageClasses.h" */
   20028             : 
   20029             : 
   20030             : 
   20031             : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarStorageClassDeclatationMacros.macro" */
   20032             : /* 
   20033             :    JH (01/01/2006) ROSETTA generated class declarations for SgListExpStorageClass 
   20034             :    used for the ast file IO. Do not chance by hand! 
   20035             : */
   20036           0 : class SgListExpStorageClass  : public SgExprListExpStorageClass
   20037             :    {
   20038             : 
   20039             :     protected: 
   20040             : 
   20041             : 
   20042             : /* #line 20043 "../../../src/frontend/SageIII//StorageClasses.h" */
   20043             : 
   20044             : 
   20045             : 
   20046             : /* #line 10 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarStorageClassDeclatationMacros.macro" */
   20047             : 
   20048             : 
   20049             :     public:
   20050             :       void pickOutIRNodeData ( SgListExp* source );
   20051             :       static void arrangeStaticDataOfEasyStorageClassesInOneBlock ( );
   20052             :       static void deleteStaticDataOfEasyStorageClasses ( );
   20053             :       static void pickOutStaticDataMembers ( );
   20054             :       static void rebuildStaticDataMembers ( );
   20055             :       static void writeEasyStorageDataToFile (std::ostream& out);
   20056             :       static void readEasyStorageDataFromFile (std::istream& in);
   20057             :       static void writeStaticDataToFile (std::ostream& out );
   20058             :       static void readStaticDataFromFile (std::istream& in );
   20059             :       friend class SgListExp;
   20060             :    };
   20061             : /* #line 20062 "../../../src/frontend/SageIII//StorageClasses.h" */
   20062             : 
   20063             : 
   20064             : 
   20065             : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarStorageClassDeclatationMacros.macro" */
   20066             : /* 
   20067             :    JH (01/01/2006) ROSETTA generated class declarations for SgTupleExpStorageClass 
   20068             :    used for the ast file IO. Do not chance by hand! 
   20069             : */
   20070           0 : class SgTupleExpStorageClass  : public SgExprListExpStorageClass
   20071             :    {
   20072             : 
   20073             :     protected: 
   20074             : 
   20075             : 
   20076             : /* #line 20077 "../../../src/frontend/SageIII//StorageClasses.h" */
   20077             : 
   20078             : 
   20079             : 
   20080             : /* #line 10 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarStorageClassDeclatationMacros.macro" */
   20081             : 
   20082             : 
   20083             :     public:
   20084             :       void pickOutIRNodeData ( SgTupleExp* source );
   20085             :       static void arrangeStaticDataOfEasyStorageClassesInOneBlock ( );
   20086             :       static void deleteStaticDataOfEasyStorageClasses ( );
   20087             :       static void pickOutStaticDataMembers ( );
   20088             :       static void rebuildStaticDataMembers ( );
   20089             :       static void writeEasyStorageDataToFile (std::ostream& out);
   20090             :       static void readEasyStorageDataFromFile (std::istream& in);
   20091             :       static void writeStaticDataToFile (std::ostream& out );
   20092             :       static void readStaticDataFromFile (std::istream& in );
   20093             :       friend class SgTupleExp;
   20094             :    };
   20095             : /* #line 20096 "../../../src/frontend/SageIII//StorageClasses.h" */
   20096             : 
   20097             : 
   20098             : 
   20099             : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarStorageClassDeclatationMacros.macro" */
   20100             : /* 
   20101             :    JH (01/01/2006) ROSETTA generated class declarations for SgMatrixExpStorageClass 
   20102             :    used for the ast file IO. Do not chance by hand! 
   20103             : */
   20104           0 : class SgMatrixExpStorageClass  : public SgExprListExpStorageClass
   20105             :    {
   20106             : 
   20107             :     protected: 
   20108             : 
   20109             : 
   20110             : /* #line 20111 "../../../src/frontend/SageIII//StorageClasses.h" */
   20111             : 
   20112             : 
   20113             : 
   20114             : /* #line 10 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarStorageClassDeclatationMacros.macro" */
   20115             : 
   20116             : 
   20117             :     public:
   20118             :       void pickOutIRNodeData ( SgMatrixExp* source );
   20119             :       static void arrangeStaticDataOfEasyStorageClassesInOneBlock ( );
   20120             :       static void deleteStaticDataOfEasyStorageClasses ( );
   20121             :       static void pickOutStaticDataMembers ( );
   20122             :       static void rebuildStaticDataMembers ( );
   20123             :       static void writeEasyStorageDataToFile (std::ostream& out);
   20124             :       static void readEasyStorageDataFromFile (std::istream& in);
   20125             :       static void writeStaticDataToFile (std::ostream& out );
   20126             :       static void readStaticDataFromFile (std::istream& in );
   20127             :       friend class SgMatrixExp;
   20128             :    };
   20129             : /* #line 20130 "../../../src/frontend/SageIII//StorageClasses.h" */
   20130             : 
   20131             : 
   20132             : 
   20133             : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarStorageClassDeclatationMacros.macro" */
   20134             : /* 
   20135             :    JH (01/01/2006) ROSETTA generated class declarations for SgVarRefExpStorageClass 
   20136             :    used for the ast file IO. Do not chance by hand! 
   20137             : */
   20138       13022 : class SgVarRefExpStorageClass  : public SgExpressionStorageClass
   20139             :    {
   20140             : 
   20141             :     protected: 
   20142             : 
   20143             : 
   20144             : /* #line 20145 "../../../src/frontend/SageIII//StorageClasses.h" */
   20145             : 
   20146             :      unsigned long storageOf_symbol;
   20147             :      unsigned long storageOf_originalExpressionTree;
   20148             :       int storageOf_name_qualification_length;
   20149             :       bool storageOf_type_elaboration_required;
   20150             :       bool storageOf_global_qualification_required;
   20151             : 
   20152             : 
   20153             : /* #line 10 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarStorageClassDeclatationMacros.macro" */
   20154             : 
   20155             : 
   20156             :     public:
   20157             :       void pickOutIRNodeData ( SgVarRefExp* source );
   20158             :       static void arrangeStaticDataOfEasyStorageClassesInOneBlock ( );
   20159             :       static void deleteStaticDataOfEasyStorageClasses ( );
   20160             :       static void pickOutStaticDataMembers ( );
   20161             :       static void rebuildStaticDataMembers ( );
   20162             :       static void writeEasyStorageDataToFile (std::ostream& out);
   20163             :       static void readEasyStorageDataFromFile (std::istream& in);
   20164             :       static void writeStaticDataToFile (std::ostream& out );
   20165             :       static void readStaticDataFromFile (std::istream& in );
   20166             :       friend class SgVarRefExp;
   20167             :    };
   20168             : /* #line 20169 "../../../src/frontend/SageIII//StorageClasses.h" */
   20169             : 
   20170             : 
   20171             : 
   20172             : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarStorageClassDeclatationMacros.macro" */
   20173             : /* 
   20174             :    JH (01/01/2006) ROSETTA generated class declarations for SgClassNameRefExpStorageClass 
   20175             :    used for the ast file IO. Do not chance by hand! 
   20176             : */
   20177           0 : class SgClassNameRefExpStorageClass  : public SgExpressionStorageClass
   20178             :    {
   20179             : 
   20180             :     protected: 
   20181             : 
   20182             : 
   20183             : /* #line 20184 "../../../src/frontend/SageIII//StorageClasses.h" */
   20184             : 
   20185             :      unsigned long storageOf_symbol;
   20186             : 
   20187             : 
   20188             : /* #line 10 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarStorageClassDeclatationMacros.macro" */
   20189             : 
   20190             : 
   20191             :     public:
   20192             :       void pickOutIRNodeData ( SgClassNameRefExp* source );
   20193             :       static void arrangeStaticDataOfEasyStorageClassesInOneBlock ( );
   20194             :       static void deleteStaticDataOfEasyStorageClasses ( );
   20195             :       static void pickOutStaticDataMembers ( );
   20196             :       static void rebuildStaticDataMembers ( );
   20197             :       static void writeEasyStorageDataToFile (std::ostream& out);
   20198             :       static void readEasyStorageDataFromFile (std::istream& in);
   20199             :       static void writeStaticDataToFile (std::ostream& out );
   20200             :       static void readStaticDataFromFile (std::istream& in );
   20201             :       friend class SgClassNameRefExp;
   20202             :    };
   20203             : /* #line 20204 "../../../src/frontend/SageIII//StorageClasses.h" */
   20204             : 
   20205             : 
   20206             : 
   20207             : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarStorageClassDeclatationMacros.macro" */
   20208             : /* 
   20209             :    JH (01/01/2006) ROSETTA generated class declarations for SgFunctionRefExpStorageClass 
   20210             :    used for the ast file IO. Do not chance by hand! 
   20211             : */
   20212        1216 : class SgFunctionRefExpStorageClass  : public SgExpressionStorageClass
   20213             :    {
   20214             : 
   20215             :     protected: 
   20216             : 
   20217             : 
   20218             : /* #line 20219 "../../../src/frontend/SageIII//StorageClasses.h" */
   20219             : 
   20220             :      unsigned long storageOf_symbol_i;
   20221             :      unsigned long storageOf_function_type;
   20222             :      unsigned long storageOf_originalExpressionTree;
   20223             :       int storageOf_name_qualification_length;
   20224             :       bool storageOf_type_elaboration_required;
   20225             :       bool storageOf_global_qualification_required;
   20226             : 
   20227             : 
   20228             : /* #line 10 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarStorageClassDeclatationMacros.macro" */
   20229             : 
   20230             : 
   20231             :     public:
   20232             :       void pickOutIRNodeData ( SgFunctionRefExp* source );
   20233             :       static void arrangeStaticDataOfEasyStorageClassesInOneBlock ( );
   20234             :       static void deleteStaticDataOfEasyStorageClasses ( );
   20235             :       static void pickOutStaticDataMembers ( );
   20236             :       static void rebuildStaticDataMembers ( );
   20237             :       static void writeEasyStorageDataToFile (std::ostream& out);
   20238             :       static void readEasyStorageDataFromFile (std::istream& in);
   20239             :       static void writeStaticDataToFile (std::ostream& out );
   20240             :       static void readStaticDataFromFile (std::istream& in );
   20241             :       friend class SgFunctionRefExp;
   20242             :    };
   20243             : /* #line 20244 "../../../src/frontend/SageIII//StorageClasses.h" */
   20244             : 
   20245             : 
   20246             : 
   20247             : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarStorageClassDeclatationMacros.macro" */
   20248             : /* 
   20249             :    JH (01/01/2006) ROSETTA generated class declarations for SgMemberFunctionRefExpStorageClass 
   20250             :    used for the ast file IO. Do not chance by hand! 
   20251             : */
   20252        1080 : class SgMemberFunctionRefExpStorageClass  : public SgExpressionStorageClass
   20253             :    {
   20254             : 
   20255             :     protected: 
   20256             : 
   20257             : 
   20258             : /* #line 20259 "../../../src/frontend/SageIII//StorageClasses.h" */
   20259             : 
   20260             :      unsigned long storageOf_symbol_i;
   20261             :       int storageOf_virtual_call;
   20262             :      unsigned long storageOf_function_type;
   20263             :       int storageOf_need_qualifier;
   20264             :       int storageOf_name_qualification_length;
   20265             :       bool storageOf_type_elaboration_required;
   20266             :       bool storageOf_global_qualification_required;
   20267             : 
   20268             : 
   20269             : /* #line 10 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarStorageClassDeclatationMacros.macro" */
   20270             : 
   20271             : 
   20272             :     public:
   20273             :       void pickOutIRNodeData ( SgMemberFunctionRefExp* source );
   20274             :       static void arrangeStaticDataOfEasyStorageClassesInOneBlock ( );
   20275             :       static void deleteStaticDataOfEasyStorageClasses ( );
   20276             :       static void pickOutStaticDataMembers ( );
   20277             :       static void rebuildStaticDataMembers ( );
   20278             :       static void writeEasyStorageDataToFile (std::ostream& out);
   20279             :       static void readEasyStorageDataFromFile (std::istream& in);
   20280             :       static void writeStaticDataToFile (std::ostream& out );
   20281             :       static void readStaticDataFromFile (std::istream& in );
   20282             :       friend class SgMemberFunctionRefExp;
   20283             :    };
   20284             : /* #line 20285 "../../../src/frontend/SageIII//StorageClasses.h" */
   20285             : 
   20286             : 
   20287             : 
   20288             : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarStorageClassDeclatationMacros.macro" */
   20289             : /* 
   20290             :    JH (01/01/2006) ROSETTA generated class declarations for SgValueExpStorageClass 
   20291             :    used for the ast file IO. Do not chance by hand! 
   20292             : */
   20293           0 : class SgValueExpStorageClass  : public SgExpressionStorageClass
   20294             :    {
   20295             : 
   20296             :     protected: 
   20297             : 
   20298             : 
   20299             : /* #line 20300 "../../../src/frontend/SageIII//StorageClasses.h" */
   20300             : 
   20301             :      unsigned long storageOf_originalExpressionTree;
   20302             : 
   20303             : 
   20304             : /* #line 10 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarStorageClassDeclatationMacros.macro" */
   20305             : 
   20306             : 
   20307             :     public:
   20308             :       void pickOutIRNodeData ( SgValueExp* source );
   20309             :       static void arrangeStaticDataOfEasyStorageClassesInOneBlock ( );
   20310             :       static void deleteStaticDataOfEasyStorageClasses ( );
   20311             :       static void pickOutStaticDataMembers ( );
   20312             :       static void rebuildStaticDataMembers ( );
   20313             :       static void writeEasyStorageDataToFile (std::ostream& out);
   20314             :       static void readEasyStorageDataFromFile (std::istream& in);
   20315             :       static void writeStaticDataToFile (std::ostream& out );
   20316             :       static void readStaticDataFromFile (std::istream& in );
   20317             :       friend class SgValueExp;
   20318             :    };
   20319             : /* #line 20320 "../../../src/frontend/SageIII//StorageClasses.h" */
   20320             : 
   20321             : 
   20322             : 
   20323             : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarStorageClassDeclatationMacros.macro" */
   20324             : /* 
   20325             :    JH (01/01/2006) ROSETTA generated class declarations for SgBoolValExpStorageClass 
   20326             :    used for the ast file IO. Do not chance by hand! 
   20327             : */
   20328         796 : class SgBoolValExpStorageClass  : public SgValueExpStorageClass
   20329             :    {
   20330             : 
   20331             :     protected: 
   20332             : 
   20333             : 
   20334             : /* #line 20335 "../../../src/frontend/SageIII//StorageClasses.h" */
   20335             : 
   20336             :       int storageOf_value;
   20337             : 
   20338             : 
   20339             : /* #line 10 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarStorageClassDeclatationMacros.macro" */
   20340             : 
   20341             : 
   20342             :     public:
   20343             :       void pickOutIRNodeData ( SgBoolValExp* source );
   20344             :       static void arrangeStaticDataOfEasyStorageClassesInOneBlock ( );
   20345             :       static void deleteStaticDataOfEasyStorageClasses ( );
   20346             :       static void pickOutStaticDataMembers ( );
   20347             :       static void rebuildStaticDataMembers ( );
   20348             :       static void writeEasyStorageDataToFile (std::ostream& out);
   20349             :       static void readEasyStorageDataFromFile (std::istream& in);
   20350             :       static void writeStaticDataToFile (std::ostream& out );
   20351             :       static void readStaticDataFromFile (std::istream& in );
   20352             :       friend class SgBoolValExp;
   20353             :    };
   20354             : /* #line 20355 "../../../src/frontend/SageIII//StorageClasses.h" */
   20355             : 
   20356             : 
   20357             : 
   20358             : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarStorageClassDeclatationMacros.macro" */
   20359             : /* 
   20360             :    JH (01/01/2006) ROSETTA generated class declarations for SgStringValStorageClass 
   20361             :    used for the ast file IO. Do not chance by hand! 
   20362             : */
   20363         165 : class SgStringValStorageClass  : public SgValueExpStorageClass
   20364             :    {
   20365             : 
   20366             :     protected: 
   20367             : 
   20368             : 
   20369             : /* #line 20370 "../../../src/frontend/SageIII//StorageClasses.h" */
   20370             : 
   20371             :        EasyStorage < std::string > storageOf_value;
   20372             :       bool storageOf_wcharString;
   20373             :       char storageOf_stringDelimiter;
   20374             :       bool storageOf_is16bitString;
   20375             :       bool storageOf_is32bitString;
   20376             :       bool storageOf_isRawString;
   20377             :        EasyStorage < std::string > storageOf_raw_string_value;
   20378             : 
   20379             : 
   20380             : /* #line 10 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarStorageClassDeclatationMacros.macro" */
   20381             : 
   20382             : 
   20383             :     public:
   20384             :       void pickOutIRNodeData ( SgStringVal* source );
   20385             :       static void arrangeStaticDataOfEasyStorageClassesInOneBlock ( );
   20386             :       static void deleteStaticDataOfEasyStorageClasses ( );
   20387             :       static void pickOutStaticDataMembers ( );
   20388             :       static void rebuildStaticDataMembers ( );
   20389             :       static void writeEasyStorageDataToFile (std::ostream& out);
   20390             :       static void readEasyStorageDataFromFile (std::istream& in);
   20391             :       static void writeStaticDataToFile (std::ostream& out );
   20392             :       static void readStaticDataFromFile (std::istream& in );
   20393             :       friend class SgStringVal;
   20394             :    };
   20395             : /* #line 20396 "../../../src/frontend/SageIII//StorageClasses.h" */
   20396             : 
   20397             : 
   20398             : 
   20399             : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarStorageClassDeclatationMacros.macro" */
   20400             : /* 
   20401             :    JH (01/01/2006) ROSETTA generated class declarations for SgShortValStorageClass 
   20402             :    used for the ast file IO. Do not chance by hand! 
   20403             : */
   20404           0 : class SgShortValStorageClass  : public SgValueExpStorageClass
   20405             :    {
   20406             : 
   20407             :     protected: 
   20408             : 
   20409             : 
   20410             : /* #line 20411 "../../../src/frontend/SageIII//StorageClasses.h" */
   20411             : 
   20412             :       short storageOf_value;
   20413             :        EasyStorage < std::string > storageOf_valueString;
   20414             : 
   20415             : 
   20416             : /* #line 10 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarStorageClassDeclatationMacros.macro" */
   20417             : 
   20418             : 
   20419             :     public:
   20420             :       void pickOutIRNodeData ( SgShortVal* source );
   20421             :       static void arrangeStaticDataOfEasyStorageClassesInOneBlock ( );
   20422             :       static void deleteStaticDataOfEasyStorageClasses ( );
   20423             :       static void pickOutStaticDataMembers ( );
   20424             :       static void rebuildStaticDataMembers ( );
   20425             :       static void writeEasyStorageDataToFile (std::ostream& out);
   20426             :       static void readEasyStorageDataFromFile (std::istream& in);
   20427             :       static void writeStaticDataToFile (std::ostream& out );
   20428             :       static void readStaticDataFromFile (std::istream& in );
   20429             :       friend class SgShortVal;
   20430             :    };
   20431             : /* #line 20432 "../../../src/frontend/SageIII//StorageClasses.h" */
   20432             : 
   20433             : 
   20434             : 
   20435             : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarStorageClassDeclatationMacros.macro" */
   20436             : /* 
   20437             :    JH (01/01/2006) ROSETTA generated class declarations for SgCharValStorageClass 
   20438             :    used for the ast file IO. Do not chance by hand! 
   20439             : */
   20440          94 : class SgCharValStorageClass  : public SgValueExpStorageClass
   20441             :    {
   20442             : 
   20443             :     protected: 
   20444             : 
   20445             : 
   20446             : /* #line 20447 "../../../src/frontend/SageIII//StorageClasses.h" */
   20447             : 
   20448             :       char storageOf_value;
   20449             :        EasyStorage < std::string > storageOf_valueString;
   20450             : 
   20451             : 
   20452             : /* #line 10 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarStorageClassDeclatationMacros.macro" */
   20453             : 
   20454             : 
   20455             :     public:
   20456             :       void pickOutIRNodeData ( SgCharVal* source );
   20457             :       static void arrangeStaticDataOfEasyStorageClassesInOneBlock ( );
   20458             :       static void deleteStaticDataOfEasyStorageClasses ( );
   20459             :       static void pickOutStaticDataMembers ( );
   20460             :       static void rebuildStaticDataMembers ( );
   20461             :       static void writeEasyStorageDataToFile (std::ostream& out);
   20462             :       static void readEasyStorageDataFromFile (std::istream& in);
   20463             :       static void writeStaticDataToFile (std::ostream& out );
   20464             :       static void readStaticDataFromFile (std::istream& in );
   20465             :       friend class SgCharVal;
   20466             :    };
   20467             : /* #line 20468 "../../../src/frontend/SageIII//StorageClasses.h" */
   20468             : 
   20469             : 
   20470             : 
   20471             : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarStorageClassDeclatationMacros.macro" */
   20472             : /* 
   20473             :    JH (01/01/2006) ROSETTA generated class declarations for SgUnsignedCharValStorageClass 
   20474             :    used for the ast file IO. Do not chance by hand! 
   20475             : */
   20476           0 : class SgUnsignedCharValStorageClass  : public SgValueExpStorageClass
   20477             :    {
   20478             : 
   20479             :     protected: 
   20480             : 
   20481             : 
   20482             : /* #line 20483 "../../../src/frontend/SageIII//StorageClasses.h" */
   20483             : 
   20484             :       unsigned char storageOf_value;
   20485             :        EasyStorage < std::string > storageOf_valueString;
   20486             : 
   20487             : 
   20488             : /* #line 10 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarStorageClassDeclatationMacros.macro" */
   20489             : 
   20490             : 
   20491             :     public:
   20492             :       void pickOutIRNodeData ( SgUnsignedCharVal* source );
   20493             :       static void arrangeStaticDataOfEasyStorageClassesInOneBlock ( );
   20494             :       static void deleteStaticDataOfEasyStorageClasses ( );
   20495             :       static void pickOutStaticDataMembers ( );
   20496             :       static void rebuildStaticDataMembers ( );
   20497             :       static void writeEasyStorageDataToFile (std::ostream& out);
   20498             :       static void readEasyStorageDataFromFile (std::istream& in);
   20499             :       static void writeStaticDataToFile (std::ostream& out );
   20500             :       static void readStaticDataFromFile (std::istream& in );
   20501             :       friend class SgUnsignedCharVal;
   20502             :    };
   20503             : /* #line 20504 "../../../src/frontend/SageIII//StorageClasses.h" */
   20504             : 
   20505             : 
   20506             : 
   20507             : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarStorageClassDeclatationMacros.macro" */
   20508             : /* 
   20509             :    JH (01/01/2006) ROSETTA generated class declarations for SgWcharValStorageClass 
   20510             :    used for the ast file IO. Do not chance by hand! 
   20511             : */
   20512           0 : class SgWcharValStorageClass  : public SgValueExpStorageClass
   20513             :    {
   20514             : 
   20515             :     protected: 
   20516             : 
   20517             : 
   20518             : /* #line 20519 "../../../src/frontend/SageIII//StorageClasses.h" */
   20519             : 
   20520             :       unsigned long storageOf_valueUL;
   20521             :        EasyStorage < std::string > storageOf_valueString;
   20522             : 
   20523             : 
   20524             : /* #line 10 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarStorageClassDeclatationMacros.macro" */
   20525             : 
   20526             : 
   20527             :     public:
   20528             :       void pickOutIRNodeData ( SgWcharVal* source );
   20529             :       static void arrangeStaticDataOfEasyStorageClassesInOneBlock ( );
   20530             :       static void deleteStaticDataOfEasyStorageClasses ( );
   20531             :       static void pickOutStaticDataMembers ( );
   20532             :       static void rebuildStaticDataMembers ( );
   20533             :       static void writeEasyStorageDataToFile (std::ostream& out);
   20534             :       static void readEasyStorageDataFromFile (std::istream& in);
   20535             :       static void writeStaticDataToFile (std::ostream& out );
   20536             :       static void readStaticDataFromFile (std::istream& in );
   20537             :       friend class SgWcharVal;
   20538             :    };
   20539             : /* #line 20540 "../../../src/frontend/SageIII//StorageClasses.h" */
   20540             : 
   20541             : 
   20542             : 
   20543             : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarStorageClassDeclatationMacros.macro" */
   20544             : /* 
   20545             :    JH (01/01/2006) ROSETTA generated class declarations for SgUnsignedShortValStorageClass 
   20546             :    used for the ast file IO. Do not chance by hand! 
   20547             : */
   20548           0 : class SgUnsignedShortValStorageClass  : public SgValueExpStorageClass
   20549             :    {
   20550             : 
   20551             :     protected: 
   20552             : 
   20553             : 
   20554             : /* #line 20555 "../../../src/frontend/SageIII//StorageClasses.h" */
   20555             : 
   20556             :       unsigned short storageOf_value;
   20557             :        EasyStorage < std::string > storageOf_valueString;
   20558             : 
   20559             : 
   20560             : /* #line 10 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarStorageClassDeclatationMacros.macro" */
   20561             : 
   20562             : 
   20563             :     public:
   20564             :       void pickOutIRNodeData ( SgUnsignedShortVal* source );
   20565             :       static void arrangeStaticDataOfEasyStorageClassesInOneBlock ( );
   20566             :       static void deleteStaticDataOfEasyStorageClasses ( );
   20567             :       static void pickOutStaticDataMembers ( );
   20568             :       static void rebuildStaticDataMembers ( );
   20569             :       static void writeEasyStorageDataToFile (std::ostream& out);
   20570             :       static void readEasyStorageDataFromFile (std::istream& in);
   20571             :       static void writeStaticDataToFile (std::ostream& out );
   20572             :       static void readStaticDataFromFile (std::istream& in );
   20573             :       friend class SgUnsignedShortVal;
   20574             :    };
   20575             : /* #line 20576 "../../../src/frontend/SageIII//StorageClasses.h" */
   20576             : 
   20577             : 
   20578             : 
   20579             : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarStorageClassDeclatationMacros.macro" */
   20580             : /* 
   20581             :    JH (01/01/2006) ROSETTA generated class declarations for SgIntValStorageClass 
   20582             :    used for the ast file IO. Do not chance by hand! 
   20583             : */
   20584        1850 : class SgIntValStorageClass  : public SgValueExpStorageClass
   20585             :    {
   20586             : 
   20587             :     protected: 
   20588             : 
   20589             : 
   20590             : /* #line 20591 "../../../src/frontend/SageIII//StorageClasses.h" */
   20591             : 
   20592             :       int storageOf_value;
   20593             :        EasyStorage < std::string > storageOf_valueString;
   20594             : 
   20595             : 
   20596             : /* #line 10 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarStorageClassDeclatationMacros.macro" */
   20597             : 
   20598             : 
   20599             :     public:
   20600             :       void pickOutIRNodeData ( SgIntVal* source );
   20601             :       static void arrangeStaticDataOfEasyStorageClassesInOneBlock ( );
   20602             :       static void deleteStaticDataOfEasyStorageClasses ( );
   20603             :       static void pickOutStaticDataMembers ( );
   20604             :       static void rebuildStaticDataMembers ( );
   20605             :       static void writeEasyStorageDataToFile (std::ostream& out);
   20606             :       static void readEasyStorageDataFromFile (std::istream& in);
   20607             :       static void writeStaticDataToFile (std::ostream& out );
   20608             :       static void readStaticDataFromFile (std::istream& in );
   20609             :       friend class SgIntVal;
   20610             :    };
   20611             : /* #line 20612 "../../../src/frontend/SageIII//StorageClasses.h" */
   20612             : 
   20613             : 
   20614             : 
   20615             : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarStorageClassDeclatationMacros.macro" */
   20616             : /* 
   20617             :    JH (01/01/2006) ROSETTA generated class declarations for SgEnumValStorageClass 
   20618             :    used for the ast file IO. Do not chance by hand! 
   20619             : */
   20620        1100 : class SgEnumValStorageClass  : public SgValueExpStorageClass
   20621             :    {
   20622             : 
   20623             :     protected: 
   20624             : 
   20625             : 
   20626             : /* #line 20627 "../../../src/frontend/SageIII//StorageClasses.h" */
   20627             : 
   20628             :       long long int storageOf_value;
   20629             :      unsigned long storageOf_declaration;
   20630             :       SgNameStorageClass storageOf_name;
   20631             :       bool storageOf_requiresNameQualification;
   20632             :       int storageOf_name_qualification_length;
   20633             :       bool storageOf_type_elaboration_required;
   20634             :       bool storageOf_global_qualification_required;
   20635             : 
   20636             : 
   20637             : /* #line 10 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarStorageClassDeclatationMacros.macro" */
   20638             : 
   20639             : 
   20640             :     public:
   20641             :       void pickOutIRNodeData ( SgEnumVal* source );
   20642             :       static void arrangeStaticDataOfEasyStorageClassesInOneBlock ( );
   20643             :       static void deleteStaticDataOfEasyStorageClasses ( );
   20644             :       static void pickOutStaticDataMembers ( );
   20645             :       static void rebuildStaticDataMembers ( );
   20646             :       static void writeEasyStorageDataToFile (std::ostream& out);
   20647             :       static void readEasyStorageDataFromFile (std::istream& in);
   20648             :       static void writeStaticDataToFile (std::ostream& out );
   20649             :       static void readStaticDataFromFile (std::istream& in );
   20650             :       friend class SgEnumVal;
   20651             :    };
   20652             : /* #line 20653 "../../../src/frontend/SageIII//StorageClasses.h" */
   20653             : 
   20654             : 
   20655             : 
   20656             : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarStorageClassDeclatationMacros.macro" */
   20657             : /* 
   20658             :    JH (01/01/2006) ROSETTA generated class declarations for SgUnsignedIntValStorageClass 
   20659             :    used for the ast file IO. Do not chance by hand! 
   20660             : */
   20661          16 : class SgUnsignedIntValStorageClass  : public SgValueExpStorageClass
   20662             :    {
   20663             : 
   20664             :     protected: 
   20665             : 
   20666             : 
   20667             : /* #line 20668 "../../../src/frontend/SageIII//StorageClasses.h" */
   20668             : 
   20669             :       unsigned int storageOf_value;
   20670             :        EasyStorage < std::string > storageOf_valueString;
   20671             : 
   20672             : 
   20673             : /* #line 10 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarStorageClassDeclatationMacros.macro" */
   20674             : 
   20675             : 
   20676             :     public:
   20677             :       void pickOutIRNodeData ( SgUnsignedIntVal* source );
   20678             :       static void arrangeStaticDataOfEasyStorageClassesInOneBlock ( );
   20679             :       static void deleteStaticDataOfEasyStorageClasses ( );
   20680             :       static void pickOutStaticDataMembers ( );
   20681             :       static void rebuildStaticDataMembers ( );
   20682             :       static void writeEasyStorageDataToFile (std::ostream& out);
   20683             :       static void readEasyStorageDataFromFile (std::istream& in);
   20684             :       static void writeStaticDataToFile (std::ostream& out );
   20685             :       static void readStaticDataFromFile (std::istream& in );
   20686             :       friend class SgUnsignedIntVal;
   20687             :    };
   20688             : /* #line 20689 "../../../src/frontend/SageIII//StorageClasses.h" */
   20689             : 
   20690             : 
   20691             : 
   20692             : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarStorageClassDeclatationMacros.macro" */
   20693             : /* 
   20694             :    JH (01/01/2006) ROSETTA generated class declarations for SgLongIntValStorageClass 
   20695             :    used for the ast file IO. Do not chance by hand! 
   20696             : */
   20697          26 : class SgLongIntValStorageClass  : public SgValueExpStorageClass
   20698             :    {
   20699             : 
   20700             :     protected: 
   20701             : 
   20702             : 
   20703             : /* #line 20704 "../../../src/frontend/SageIII//StorageClasses.h" */
   20704             : 
   20705             :       long int storageOf_value;
   20706             :        EasyStorage < std::string > storageOf_valueString;
   20707             : 
   20708             : 
   20709             : /* #line 10 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarStorageClassDeclatationMacros.macro" */
   20710             : 
   20711             : 
   20712             :     public:
   20713             :       void pickOutIRNodeData ( SgLongIntVal* source );
   20714             :       static void arrangeStaticDataOfEasyStorageClassesInOneBlock ( );
   20715             :       static void deleteStaticDataOfEasyStorageClasses ( );
   20716             :       static void pickOutStaticDataMembers ( );
   20717             :       static void rebuildStaticDataMembers ( );
   20718             :       static void writeEasyStorageDataToFile (std::ostream& out);
   20719             :       static void readEasyStorageDataFromFile (std::istream& in);
   20720             :       static void writeStaticDataToFile (std::ostream& out );
   20721             :       static void readStaticDataFromFile (std::istream& in );
   20722             :       friend class SgLongIntVal;
   20723             :    };
   20724             : /* #line 20725 "../../../src/frontend/SageIII//StorageClasses.h" */
   20725             : 
   20726             : 
   20727             : 
   20728             : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarStorageClassDeclatationMacros.macro" */
   20729             : /* 
   20730             :    JH (01/01/2006) ROSETTA generated class declarations for SgLongLongIntValStorageClass 
   20731             :    used for the ast file IO. Do not chance by hand! 
   20732             : */
   20733           0 : class SgLongLongIntValStorageClass  : public SgValueExpStorageClass
   20734             :    {
   20735             : 
   20736             :     protected: 
   20737             : 
   20738             : 
   20739             : /* #line 20740 "../../../src/frontend/SageIII//StorageClasses.h" */
   20740             : 
   20741             :       long long int storageOf_value;
   20742             :        EasyStorage < std::string > storageOf_valueString;
   20743             : 
   20744             : 
   20745             : /* #line 10 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarStorageClassDeclatationMacros.macro" */
   20746             : 
   20747             : 
   20748             :     public:
   20749             :       void pickOutIRNodeData ( SgLongLongIntVal* source );
   20750             :       static void arrangeStaticDataOfEasyStorageClassesInOneBlock ( );
   20751             :       static void deleteStaticDataOfEasyStorageClasses ( );
   20752             :       static void pickOutStaticDataMembers ( );
   20753             :       static void rebuildStaticDataMembers ( );
   20754             :       static void writeEasyStorageDataToFile (std::ostream& out);
   20755             :       static void readEasyStorageDataFromFile (std::istream& in);
   20756             :       static void writeStaticDataToFile (std::ostream& out );
   20757             :       static void readStaticDataFromFile (std::istream& in );
   20758             :       friend class SgLongLongIntVal;
   20759             :    };
   20760             : /* #line 20761 "../../../src/frontend/SageIII//StorageClasses.h" */
   20761             : 
   20762             : 
   20763             : 
   20764             : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarStorageClassDeclatationMacros.macro" */
   20765             : /* 
   20766             :    JH (01/01/2006) ROSETTA generated class declarations for SgUnsignedLongLongIntValStorageClass 
   20767             :    used for the ast file IO. Do not chance by hand! 
   20768             : */
   20769           0 : class SgUnsignedLongLongIntValStorageClass  : public SgValueExpStorageClass
   20770             :    {
   20771             : 
   20772             :     protected: 
   20773             : 
   20774             : 
   20775             : /* #line 20776 "../../../src/frontend/SageIII//StorageClasses.h" */
   20776             : 
   20777             :       unsigned long long int storageOf_value;
   20778             :        EasyStorage < std::string > storageOf_valueString;
   20779             : 
   20780             : 
   20781             : /* #line 10 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarStorageClassDeclatationMacros.macro" */
   20782             : 
   20783             : 
   20784             :     public:
   20785             :       void pickOutIRNodeData ( SgUnsignedLongLongIntVal* source );
   20786             :       static void arrangeStaticDataOfEasyStorageClassesInOneBlock ( );
   20787             :       static void deleteStaticDataOfEasyStorageClasses ( );
   20788             :       static void pickOutStaticDataMembers ( );
   20789             :       static void rebuildStaticDataMembers ( );
   20790             :       static void writeEasyStorageDataToFile (std::ostream& out);
   20791             :       static void readEasyStorageDataFromFile (std::istream& in);
   20792             :       static void writeStaticDataToFile (std::ostream& out );
   20793             :       static void readStaticDataFromFile (std::istream& in );
   20794             :       friend class SgUnsignedLongLongIntVal;
   20795             :    };
   20796             : /* #line 20797 "../../../src/frontend/SageIII//StorageClasses.h" */
   20797             : 
   20798             : 
   20799             : 
   20800             : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarStorageClassDeclatationMacros.macro" */
   20801             : /* 
   20802             :    JH (01/01/2006) ROSETTA generated class declarations for SgUnsignedLongValStorageClass 
   20803             :    used for the ast file IO. Do not chance by hand! 
   20804             : */
   20805          38 : class SgUnsignedLongValStorageClass  : public SgValueExpStorageClass
   20806             :    {
   20807             : 
   20808             :     protected: 
   20809             : 
   20810             : 
   20811             : /* #line 20812 "../../../src/frontend/SageIII//StorageClasses.h" */
   20812             : 
   20813             :       unsigned long storageOf_value;
   20814             :        EasyStorage < std::string > storageOf_valueString;
   20815             : 
   20816             : 
   20817             : /* #line 10 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarStorageClassDeclatationMacros.macro" */
   20818             : 
   20819             : 
   20820             :     public:
   20821             :       void pickOutIRNodeData ( SgUnsignedLongVal* source );
   20822             :       static void arrangeStaticDataOfEasyStorageClassesInOneBlock ( );
   20823             :       static void deleteStaticDataOfEasyStorageClasses ( );
   20824             :       static void pickOutStaticDataMembers ( );
   20825             :       static void rebuildStaticDataMembers ( );
   20826             :       static void writeEasyStorageDataToFile (std::ostream& out);
   20827             :       static void readEasyStorageDataFromFile (std::istream& in);
   20828             :       static void writeStaticDataToFile (std::ostream& out );
   20829             :       static void readStaticDataFromFile (std::istream& in );
   20830             :       friend class SgUnsignedLongVal;
   20831             :    };
   20832             : /* #line 20833 "../../../src/frontend/SageIII//StorageClasses.h" */
   20833             : 
   20834             : 
   20835             : 
   20836             : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarStorageClassDeclatationMacros.macro" */
   20837             : /* 
   20838             :    JH (01/01/2006) ROSETTA generated class declarations for SgFloatValStorageClass 
   20839             :    used for the ast file IO. Do not chance by hand! 
   20840             : */
   20841           2 : class SgFloatValStorageClass  : public SgValueExpStorageClass
   20842             :    {
   20843             : 
   20844             :     protected: 
   20845             : 
   20846             : 
   20847             : /* #line 20848 "../../../src/frontend/SageIII//StorageClasses.h" */
   20848             : 
   20849             :       float storageOf_value;
   20850             :        EasyStorage < std::string > storageOf_valueString;
   20851             : 
   20852             : 
   20853             : /* #line 10 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarStorageClassDeclatationMacros.macro" */
   20854             : 
   20855             : 
   20856             :     public:
   20857             :       void pickOutIRNodeData ( SgFloatVal* source );
   20858             :       static void arrangeStaticDataOfEasyStorageClassesInOneBlock ( );
   20859             :       static void deleteStaticDataOfEasyStorageClasses ( );
   20860             :       static void pickOutStaticDataMembers ( );
   20861             :       static void rebuildStaticDataMembers ( );
   20862             :       static void writeEasyStorageDataToFile (std::ostream& out);
   20863             :       static void readEasyStorageDataFromFile (std::istream& in);
   20864             :       static void writeStaticDataToFile (std::ostream& out );
   20865             :       static void readStaticDataFromFile (std::istream& in );
   20866             :       friend class SgFloatVal;
   20867             :    };
   20868             : /* #line 20869 "../../../src/frontend/SageIII//StorageClasses.h" */
   20869             : 
   20870             : 
   20871             : 
   20872             : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarStorageClassDeclatationMacros.macro" */
   20873             : /* 
   20874             :    JH (01/01/2006) ROSETTA generated class declarations for SgDoubleValStorageClass 
   20875             :    used for the ast file IO. Do not chance by hand! 
   20876             : */
   20877           2 : class SgDoubleValStorageClass  : public SgValueExpStorageClass
   20878             :    {
   20879             : 
   20880             :     protected: 
   20881             : 
   20882             : 
   20883             : /* #line 20884 "../../../src/frontend/SageIII//StorageClasses.h" */
   20884             : 
   20885             :       double storageOf_value;
   20886             :        EasyStorage < std::string > storageOf_valueString;
   20887             : 
   20888             : 
   20889             : /* #line 10 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarStorageClassDeclatationMacros.macro" */
   20890             : 
   20891             : 
   20892             :     public:
   20893             :       void pickOutIRNodeData ( SgDoubleVal* source );
   20894             :       static void arrangeStaticDataOfEasyStorageClassesInOneBlock ( );
   20895             :       static void deleteStaticDataOfEasyStorageClasses ( );
   20896             :       static void pickOutStaticDataMembers ( );
   20897             :       static void rebuildStaticDataMembers ( );
   20898             :       static void writeEasyStorageDataToFile (std::ostream& out);
   20899             :       static void readEasyStorageDataFromFile (std::istream& in);
   20900             :       static void writeStaticDataToFile (std::ostream& out );
   20901             :       static void readStaticDataFromFile (std::istream& in );
   20902             :       friend class SgDoubleVal;
   20903             :    };
   20904             : /* #line 20905 "../../../src/frontend/SageIII//StorageClasses.h" */
   20905             : 
   20906             : 
   20907             : 
   20908             : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarStorageClassDeclatationMacros.macro" */
   20909             : /* 
   20910             :    JH (01/01/2006) ROSETTA generated class declarations for SgLongDoubleValStorageClass 
   20911             :    used for the ast file IO. Do not chance by hand! 
   20912             : */
   20913           0 : class SgLongDoubleValStorageClass  : public SgValueExpStorageClass
   20914             :    {
   20915             : 
   20916             :     protected: 
   20917             : 
   20918             : 
   20919             : /* #line 20920 "../../../src/frontend/SageIII//StorageClasses.h" */
   20920             : 
   20921             :       long double storageOf_value;
   20922             :        EasyStorage < std::string > storageOf_valueString;
   20923             : 
   20924             : 
   20925             : /* #line 10 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarStorageClassDeclatationMacros.macro" */
   20926             : 
   20927             : 
   20928             :     public:
   20929             :       void pickOutIRNodeData ( SgLongDoubleVal* source );
   20930             :       static void arrangeStaticDataOfEasyStorageClassesInOneBlock ( );
   20931             :       static void deleteStaticDataOfEasyStorageClasses ( );
   20932             :       static void pickOutStaticDataMembers ( );
   20933             :       static void rebuildStaticDataMembers ( );
   20934             :       static void writeEasyStorageDataToFile (std::ostream& out);
   20935             :       static void readEasyStorageDataFromFile (std::istream& in);
   20936             :       static void writeStaticDataToFile (std::ostream& out );
   20937             :       static void readStaticDataFromFile (std::istream& in );
   20938             :       friend class SgLongDoubleVal;
   20939             :    };
   20940             : /* #line 20941 "../../../src/frontend/SageIII//StorageClasses.h" */
   20941             : 
   20942             : 
   20943             : 
   20944             : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarStorageClassDeclatationMacros.macro" */
   20945             : /* 
   20946             :    JH (01/01/2006) ROSETTA generated class declarations for SgComplexValStorageClass 
   20947             :    used for the ast file IO. Do not chance by hand! 
   20948             : */
   20949           0 : class SgComplexValStorageClass  : public SgValueExpStorageClass
   20950             :    {
   20951             : 
   20952             :     protected: 
   20953             : 
   20954             : 
   20955             : /* #line 20956 "../../../src/frontend/SageIII//StorageClasses.h" */
   20956             : 
   20957             :      unsigned long storageOf_real_value;
   20958             :      unsigned long storageOf_imaginary_value;
   20959             :      unsigned long storageOf_precisionType;
   20960             :        EasyStorage < std::string > storageOf_valueString;
   20961             : 
   20962             : 
   20963             : /* #line 10 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarStorageClassDeclatationMacros.macro" */
   20964             : 
   20965             : 
   20966             :     public:
   20967             :       void pickOutIRNodeData ( SgComplexVal* source );
   20968             :       static void arrangeStaticDataOfEasyStorageClassesInOneBlock ( );
   20969             :       static void deleteStaticDataOfEasyStorageClasses ( );
   20970             :       static void pickOutStaticDataMembers ( );
   20971             :       static void rebuildStaticDataMembers ( );
   20972             :       static void writeEasyStorageDataToFile (std::ostream& out);
   20973             :       static void readEasyStorageDataFromFile (std::istream& in);
   20974             :       static void writeStaticDataToFile (std::ostream& out );
   20975             :       static void readStaticDataFromFile (std::istream& in );
   20976             :       friend class SgComplexVal;
   20977             :    };
   20978             : /* #line 20979 "../../../src/frontend/SageIII//StorageClasses.h" */
   20979             : 
   20980             : 
   20981             : 
   20982             : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarStorageClassDeclatationMacros.macro" */
   20983             : /* 
   20984             :    JH (01/01/2006) ROSETTA generated class declarations for SgUpcThreadsStorageClass 
   20985             :    used for the ast file IO. Do not chance by hand! 
   20986             : */
   20987           0 : class SgUpcThreadsStorageClass  : public SgValueExpStorageClass
   20988             :    {
   20989             : 
   20990             :     protected: 
   20991             : 
   20992             : 
   20993             : /* #line 20994 "../../../src/frontend/SageIII//StorageClasses.h" */
   20994             : 
   20995             :       int storageOf_value;
   20996             :        EasyStorage < std::string > storageOf_valueString;
   20997             : 
   20998             : 
   20999             : /* #line 10 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarStorageClassDeclatationMacros.macro" */
   21000             : 
   21001             : 
   21002             :     public:
   21003             :       void pickOutIRNodeData ( SgUpcThreads* source );
   21004             :       static void arrangeStaticDataOfEasyStorageClassesInOneBlock ( );
   21005             :       static void deleteStaticDataOfEasyStorageClasses ( );
   21006             :       static void pickOutStaticDataMembers ( );
   21007             :       static void rebuildStaticDataMembers ( );
   21008             :       static void writeEasyStorageDataToFile (std::ostream& out);
   21009             :       static void readEasyStorageDataFromFile (std::istream& in);
   21010             :       static void writeStaticDataToFile (std::ostream& out );
   21011             :       static void readStaticDataFromFile (std::istream& in );
   21012             :       friend class SgUpcThreads;
   21013             :    };
   21014             : /* #line 21015 "../../../src/frontend/SageIII//StorageClasses.h" */
   21015             : 
   21016             : 
   21017             : 
   21018             : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarStorageClassDeclatationMacros.macro" */
   21019             : /* 
   21020             :    JH (01/01/2006) ROSETTA generated class declarations for SgUpcMythreadStorageClass 
   21021             :    used for the ast file IO. Do not chance by hand! 
   21022             : */
   21023           0 : class SgUpcMythreadStorageClass  : public SgValueExpStorageClass
   21024             :    {
   21025             : 
   21026             :     protected: 
   21027             : 
   21028             : 
   21029             : /* #line 21030 "../../../src/frontend/SageIII//StorageClasses.h" */
   21030             : 
   21031             :       int storageOf_value;
   21032             :        EasyStorage < std::string > storageOf_valueString;
   21033             : 
   21034             : 
   21035             : /* #line 10 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarStorageClassDeclatationMacros.macro" */
   21036             : 
   21037             : 
   21038             :     public:
   21039             :       void pickOutIRNodeData ( SgUpcMythread* source );
   21040             :       static void arrangeStaticDataOfEasyStorageClassesInOneBlock ( );
   21041             :       static void deleteStaticDataOfEasyStorageClasses ( );
   21042             :       static void pickOutStaticDataMembers ( );
   21043             :       static void rebuildStaticDataMembers ( );
   21044             :       static void writeEasyStorageDataToFile (std::ostream& out);
   21045             :       static void readEasyStorageDataFromFile (std::istream& in);
   21046             :       static void writeStaticDataToFile (std::ostream& out );
   21047             :       static void readStaticDataFromFile (std::istream& in );
   21048             :       friend class SgUpcMythread;
   21049             :    };
   21050             : /* #line 21051 "../../../src/frontend/SageIII//StorageClasses.h" */
   21051             : 
   21052             : 
   21053             : 
   21054             : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarStorageClassDeclatationMacros.macro" */
   21055             : /* 
   21056             :    JH (01/01/2006) ROSETTA generated class declarations for SgTemplateParameterValStorageClass 
   21057             :    used for the ast file IO. Do not chance by hand! 
   21058             : */
   21059           0 : class SgTemplateParameterValStorageClass  : public SgValueExpStorageClass
   21060             :    {
   21061             : 
   21062             :     protected: 
   21063             : 
   21064             : 
   21065             : /* #line 21066 "../../../src/frontend/SageIII//StorageClasses.h" */
   21066             : 
   21067             :       int storageOf_template_parameter_position;
   21068             :        EasyStorage < std::string > storageOf_valueString;
   21069             :      unsigned long storageOf_valueType;
   21070             : 
   21071             : 
   21072             : /* #line 10 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarStorageClassDeclatationMacros.macro" */
   21073             : 
   21074             : 
   21075             :     public:
   21076             :       void pickOutIRNodeData ( SgTemplateParameterVal* source );
   21077             :       static void arrangeStaticDataOfEasyStorageClassesInOneBlock ( );
   21078             :       static void deleteStaticDataOfEasyStorageClasses ( );
   21079             :       static void pickOutStaticDataMembers ( );
   21080             :       static void rebuildStaticDataMembers ( );
   21081             :       static void writeEasyStorageDataToFile (std::ostream& out);
   21082             :       static void readEasyStorageDataFromFile (std::istream& in);
   21083             :       static void writeStaticDataToFile (std::ostream& out );
   21084             :       static void readStaticDataFromFile (std::istream& in );
   21085             :       friend class SgTemplateParameterVal;
   21086             :    };
   21087             : /* #line 21088 "../../../src/frontend/SageIII//StorageClasses.h" */
   21088             : 
   21089             : 
   21090             : 
   21091             : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarStorageClassDeclatationMacros.macro" */
   21092             : /* 
   21093             :    JH (01/01/2006) ROSETTA generated class declarations for SgNullptrValExpStorageClass 
   21094             :    used for the ast file IO. Do not chance by hand! 
   21095             : */
   21096          12 : class SgNullptrValExpStorageClass  : public SgValueExpStorageClass
   21097             :    {
   21098             : 
   21099             :     protected: 
   21100             : 
   21101             : 
   21102             : /* #line 21103 "../../../src/frontend/SageIII//StorageClasses.h" */
   21103             : 
   21104             : 
   21105             : 
   21106             : /* #line 10 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarStorageClassDeclatationMacros.macro" */
   21107             : 
   21108             : 
   21109             :     public:
   21110             :       void pickOutIRNodeData ( SgNullptrValExp* source );
   21111             :       static void arrangeStaticDataOfEasyStorageClassesInOneBlock ( );
   21112             :       static void deleteStaticDataOfEasyStorageClasses ( );
   21113             :       static void pickOutStaticDataMembers ( );
   21114             :       static void rebuildStaticDataMembers ( );
   21115             :       static void writeEasyStorageDataToFile (std::ostream& out);
   21116             :       static void readEasyStorageDataFromFile (std::istream& in);
   21117             :       static void writeStaticDataToFile (std::ostream& out );
   21118             :       static void readStaticDataFromFile (std::istream& in );
   21119             :       friend class SgNullptrValExp;
   21120             :    };
   21121             : /* #line 21122 "../../../src/frontend/SageIII//StorageClasses.h" */
   21122             : 
   21123             : 
   21124             : 
   21125             : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarStorageClassDeclatationMacros.macro" */
   21126             : /* 
   21127             :    JH (01/01/2006) ROSETTA generated class declarations for SgChar16ValStorageClass 
   21128             :    used for the ast file IO. Do not chance by hand! 
   21129             : */
   21130           0 : class SgChar16ValStorageClass  : public SgValueExpStorageClass
   21131             :    {
   21132             : 
   21133             :     protected: 
   21134             : 
   21135             : 
   21136             : /* #line 21137 "../../../src/frontend/SageIII//StorageClasses.h" */
   21137             : 
   21138             :       unsigned short storageOf_valueUL;
   21139             :        EasyStorage < std::string > storageOf_valueString;
   21140             : 
   21141             : 
   21142             : /* #line 10 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarStorageClassDeclatationMacros.macro" */
   21143             : 
   21144             : 
   21145             :     public:
   21146             :       void pickOutIRNodeData ( SgChar16Val* source );
   21147             :       static void arrangeStaticDataOfEasyStorageClassesInOneBlock ( );
   21148             :       static void deleteStaticDataOfEasyStorageClasses ( );
   21149             :       static void pickOutStaticDataMembers ( );
   21150             :       static void rebuildStaticDataMembers ( );
   21151             :       static void writeEasyStorageDataToFile (std::ostream& out);
   21152             :       static void readEasyStorageDataFromFile (std::istream& in);
   21153             :       static void writeStaticDataToFile (std::ostream& out );
   21154             :       static void readStaticDataFromFile (std::istream& in );
   21155             :       friend class SgChar16Val;
   21156             :    };
   21157             : /* #line 21158 "../../../src/frontend/SageIII//StorageClasses.h" */
   21158             : 
   21159             : 
   21160             : 
   21161             : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarStorageClassDeclatationMacros.macro" */
   21162             : /* 
   21163             :    JH (01/01/2006) ROSETTA generated class declarations for SgChar32ValStorageClass 
   21164             :    used for the ast file IO. Do not chance by hand! 
   21165             : */
   21166           0 : class SgChar32ValStorageClass  : public SgValueExpStorageClass
   21167             :    {
   21168             : 
   21169             :     protected: 
   21170             : 
   21171             : 
   21172             : /* #line 21173 "../../../src/frontend/SageIII//StorageClasses.h" */
   21173             : 
   21174             :       unsigned int storageOf_valueUL;
   21175             :        EasyStorage < std::string > storageOf_valueString;
   21176             : 
   21177             : 
   21178             : /* #line 10 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarStorageClassDeclatationMacros.macro" */
   21179             : 
   21180             : 
   21181             :     public:
   21182             :       void pickOutIRNodeData ( SgChar32Val* source );
   21183             :       static void arrangeStaticDataOfEasyStorageClassesInOneBlock ( );
   21184             :       static void deleteStaticDataOfEasyStorageClasses ( );
   21185             :       static void pickOutStaticDataMembers ( );
   21186             :       static void rebuildStaticDataMembers ( );
   21187             :       static void writeEasyStorageDataToFile (std::ostream& out);
   21188             :       static void readEasyStorageDataFromFile (std::istream& in);
   21189             :       static void writeStaticDataToFile (std::ostream& out );
   21190             :       static void readStaticDataFromFile (std::istream& in );
   21191             :       friend class SgChar32Val;
   21192             :    };
   21193             : /* #line 21194 "../../../src/frontend/SageIII//StorageClasses.h" */
   21194             : 
   21195             : 
   21196             : 
   21197             : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarStorageClassDeclatationMacros.macro" */
   21198             : /* 
   21199             :    JH (01/01/2006) ROSETTA generated class declarations for SgFloat80ValStorageClass 
   21200             :    used for the ast file IO. Do not chance by hand! 
   21201             : */
   21202           0 : class SgFloat80ValStorageClass  : public SgValueExpStorageClass
   21203             :    {
   21204             : 
   21205             :     protected: 
   21206             : 
   21207             : 
   21208             : /* #line 21209 "../../../src/frontend/SageIII//StorageClasses.h" */
   21209             : 
   21210             :       long double storageOf_value;
   21211             :        EasyStorage < std::string > storageOf_valueString;
   21212             : 
   21213             : 
   21214             : /* #line 10 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarStorageClassDeclatationMacros.macro" */
   21215             : 
   21216             : 
   21217             :     public:
   21218             :       void pickOutIRNodeData ( SgFloat80Val* source );
   21219             :       static void arrangeStaticDataOfEasyStorageClassesInOneBlock ( );
   21220             :       static void deleteStaticDataOfEasyStorageClasses ( );
   21221             :       static void pickOutStaticDataMembers ( );
   21222             :       static void rebuildStaticDataMembers ( );
   21223             :       static void writeEasyStorageDataToFile (std::ostream& out);
   21224             :       static void readEasyStorageDataFromFile (std::istream& in);
   21225             :       static void writeStaticDataToFile (std::ostream& out );
   21226             :       static void readStaticDataFromFile (std::istream& in );
   21227             :       friend class SgFloat80Val;
   21228             :    };
   21229             : /* #line 21230 "../../../src/frontend/SageIII//StorageClasses.h" */
   21230             : 
   21231             : 
   21232             : 
   21233             : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarStorageClassDeclatationMacros.macro" */
   21234             : /* 
   21235             :    JH (01/01/2006) ROSETTA generated class declarations for SgFloat128ValStorageClass 
   21236             :    used for the ast file IO. Do not chance by hand! 
   21237             : */
   21238           0 : class SgFloat128ValStorageClass  : public SgValueExpStorageClass
   21239             :    {
   21240             : 
   21241             :     protected: 
   21242             : 
   21243             : 
   21244             : /* #line 21245 "../../../src/frontend/SageIII//StorageClasses.h" */
   21245             : 
   21246             :       long double storageOf_value;
   21247             :        EasyStorage < std::string > storageOf_valueString;
   21248             : 
   21249             : 
   21250             : /* #line 10 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarStorageClassDeclatationMacros.macro" */
   21251             : 
   21252             : 
   21253             :     public:
   21254             :       void pickOutIRNodeData ( SgFloat128Val* source );
   21255             :       static void arrangeStaticDataOfEasyStorageClassesInOneBlock ( );
   21256             :       static void deleteStaticDataOfEasyStorageClasses ( );
   21257             :       static void pickOutStaticDataMembers ( );
   21258             :       static void rebuildStaticDataMembers ( );
   21259             :       static void writeEasyStorageDataToFile (std::ostream& out);
   21260             :       static void readEasyStorageDataFromFile (std::istream& in);
   21261             :       static void writeStaticDataToFile (std::ostream& out );
   21262             :       static void readStaticDataFromFile (std::istream& in );
   21263             :       friend class SgFloat128Val;
   21264             :    };
   21265             : /* #line 21266 "../../../src/frontend/SageIII//StorageClasses.h" */
   21266             : 
   21267             : 
   21268             : 
   21269             : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarStorageClassDeclatationMacros.macro" */
   21270             : /* 
   21271             :    JH (01/01/2006) ROSETTA generated class declarations for SgVoidValStorageClass 
   21272             :    used for the ast file IO. Do not chance by hand! 
   21273             : */
   21274           0 : class SgVoidValStorageClass  : public SgValueExpStorageClass
   21275             :    {
   21276             : 
   21277             :     protected: 
   21278             : 
   21279             : 
   21280             : /* #line 21281 "../../../src/frontend/SageIII//StorageClasses.h" */
   21281             : 
   21282             : 
   21283             : 
   21284             : /* #line 10 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarStorageClassDeclatationMacros.macro" */
   21285             : 
   21286             : 
   21287             :     public:
   21288             :       void pickOutIRNodeData ( SgVoidVal* source );
   21289             :       static void arrangeStaticDataOfEasyStorageClassesInOneBlock ( );
   21290             :       static void deleteStaticDataOfEasyStorageClasses ( );
   21291             :       static void pickOutStaticDataMembers ( );
   21292             :       static void rebuildStaticDataMembers ( );
   21293             :       static void writeEasyStorageDataToFile (std::ostream& out);
   21294             :       static void readEasyStorageDataFromFile (std::istream& in);
   21295             :       static void writeStaticDataToFile (std::ostream& out );
   21296             :       static void readStaticDataFromFile (std::istream& in );
   21297             :       friend class SgVoidVal;
   21298             :    };
   21299             : /* #line 21300 "../../../src/frontend/SageIII//StorageClasses.h" */
   21300             : 
   21301             : 
   21302             : 
   21303             : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarStorageClassDeclatationMacros.macro" */
   21304             : /* 
   21305             :    JH (01/01/2006) ROSETTA generated class declarations for SgCallExpressionStorageClass 
   21306             :    used for the ast file IO. Do not chance by hand! 
   21307             : */
   21308           0 : class SgCallExpressionStorageClass  : public SgExpressionStorageClass
   21309             :    {
   21310             : 
   21311             :     protected: 
   21312             : 
   21313             : 
   21314             : /* #line 21315 "../../../src/frontend/SageIII//StorageClasses.h" */
   21315             : 
   21316             :      unsigned long storageOf_function;
   21317             :      unsigned long storageOf_args;
   21318             :      unsigned long storageOf_expression_type;
   21319             : 
   21320             : 
   21321             : /* #line 10 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarStorageClassDeclatationMacros.macro" */
   21322             : 
   21323             : 
   21324             :     public:
   21325             :       void pickOutIRNodeData ( SgCallExpression* source );
   21326             :       static void arrangeStaticDataOfEasyStorageClassesInOneBlock ( );
   21327             :       static void deleteStaticDataOfEasyStorageClasses ( );
   21328             :       static void pickOutStaticDataMembers ( );
   21329             :       static void rebuildStaticDataMembers ( );
   21330             :       static void writeEasyStorageDataToFile (std::ostream& out);
   21331             :       static void readEasyStorageDataFromFile (std::istream& in);
   21332             :       static void writeStaticDataToFile (std::ostream& out );
   21333             :       static void readStaticDataFromFile (std::istream& in );
   21334             :       friend class SgCallExpression;
   21335             :    };
   21336             : /* #line 21337 "../../../src/frontend/SageIII//StorageClasses.h" */
   21337             : 
   21338             : 
   21339             : 
   21340             : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarStorageClassDeclatationMacros.macro" */
   21341             : /* 
   21342             :    JH (01/01/2006) ROSETTA generated class declarations for SgFunctionCallExpStorageClass 
   21343             :    used for the ast file IO. Do not chance by hand! 
   21344             : */
   21345        6444 : class SgFunctionCallExpStorageClass  : public SgCallExpressionStorageClass
   21346             :    {
   21347             : 
   21348             :     protected: 
   21349             : 
   21350             : 
   21351             : /* #line 21352 "../../../src/frontend/SageIII//StorageClasses.h" */
   21352             : 
   21353             :       bool storageOf_uses_operator_syntax;
   21354             : 
   21355             : 
   21356             : /* #line 10 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarStorageClassDeclatationMacros.macro" */
   21357             : 
   21358             : 
   21359             :     public:
   21360             :       void pickOutIRNodeData ( SgFunctionCallExp* source );
   21361             :       static void arrangeStaticDataOfEasyStorageClassesInOneBlock ( );
   21362             :       static void deleteStaticDataOfEasyStorageClasses ( );
   21363             :       static void pickOutStaticDataMembers ( );
   21364             :       static void rebuildStaticDataMembers ( );
   21365             :       static void writeEasyStorageDataToFile (std::ostream& out);
   21366             :       static void readEasyStorageDataFromFile (std::istream& in);
   21367             :       static void writeStaticDataToFile (std::ostream& out );
   21368             :       static void readStaticDataFromFile (std::istream& in );
   21369             :       friend class SgFunctionCallExp;
   21370             :    };
   21371             : /* #line 21372 "../../../src/frontend/SageIII//StorageClasses.h" */
   21372             : 
   21373             : 
   21374             : 
   21375             : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarStorageClassDeclatationMacros.macro" */
   21376             : /* 
   21377             :    JH (01/01/2006) ROSETTA generated class declarations for SgCudaKernelCallExpStorageClass 
   21378             :    used for the ast file IO. Do not chance by hand! 
   21379             : */
   21380           0 : class SgCudaKernelCallExpStorageClass  : public SgFunctionCallExpStorageClass
   21381             :    {
   21382             : 
   21383             :     protected: 
   21384             : 
   21385             : 
   21386             : /* #line 21387 "../../../src/frontend/SageIII//StorageClasses.h" */
   21387             : 
   21388             :      unsigned long storageOf_exec_config;
   21389             : 
   21390             : 
   21391             : /* #line 10 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarStorageClassDeclatationMacros.macro" */
   21392             : 
   21393             : 
   21394             :     public:
   21395             :       void pickOutIRNodeData ( SgCudaKernelCallExp* source );
   21396             :       static void arrangeStaticDataOfEasyStorageClassesInOneBlock ( );
   21397             :       static void deleteStaticDataOfEasyStorageClasses ( );
   21398             :       static void pickOutStaticDataMembers ( );
   21399             :       static void rebuildStaticDataMembers ( );
   21400             :       static void writeEasyStorageDataToFile (std::ostream& out);
   21401             :       static void readEasyStorageDataFromFile (std::istream& in);
   21402             :       static void writeStaticDataToFile (std::ostream& out );
   21403             :       static void readStaticDataFromFile (std::istream& in );
   21404             :       friend class SgCudaKernelCallExp;
   21405             :    };
   21406             : /* #line 21407 "../../../src/frontend/SageIII//StorageClasses.h" */
   21407             : 
   21408             : 
   21409             : 
   21410             : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarStorageClassDeclatationMacros.macro" */
   21411             : /* 
   21412             :    JH (01/01/2006) ROSETTA generated class declarations for SgSizeOfOpStorageClass 
   21413             :    used for the ast file IO. Do not chance by hand! 
   21414             : */
   21415         196 : class SgSizeOfOpStorageClass  : public SgExpressionStorageClass
   21416             :    {
   21417             : 
   21418             :     protected: 
   21419             : 
   21420             : 
   21421             : /* #line 21422 "../../../src/frontend/SageIII//StorageClasses.h" */
   21422             : 
   21423             :      unsigned long storageOf_operand_expr;
   21424             :      unsigned long storageOf_operand_type;
   21425             :      unsigned long storageOf_expression_type;
   21426             :       int storageOf_name_qualification_length;
   21427             :       bool storageOf_type_elaboration_required;
   21428             :       bool storageOf_global_qualification_required;
   21429             :       bool storageOf_sizeOfContainsBaseTypeDefiningDeclaration;
   21430             :       bool storageOf_is_objectless_nonstatic_data_member_reference;
   21431             :       int storageOf_name_qualification_for_pointer_to_member_class_length;
   21432             :       bool storageOf_type_elaboration_for_pointer_to_member_class_required;
   21433             :       bool storageOf_global_qualification_for_pointer_to_member_class_required;
   21434             : 
   21435             : 
   21436             : /* #line 10 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarStorageClassDeclatationMacros.macro" */
   21437             : 
   21438             : 
   21439             :     public:
   21440             :       void pickOutIRNodeData ( SgSizeOfOp* source );
   21441             :       static void arrangeStaticDataOfEasyStorageClassesInOneBlock ( );
   21442             :       static void deleteStaticDataOfEasyStorageClasses ( );
   21443             :       static void pickOutStaticDataMembers ( );
   21444             :       static void rebuildStaticDataMembers ( );
   21445             :       static void writeEasyStorageDataToFile (std::ostream& out);
   21446             :       static void readEasyStorageDataFromFile (std::istream& in);
   21447             :       static void writeStaticDataToFile (std::ostream& out );
   21448             :       static void readStaticDataFromFile (std::istream& in );
   21449             :       friend class SgSizeOfOp;
   21450             :    };
   21451             : /* #line 21452 "../../../src/frontend/SageIII//StorageClasses.h" */
   21452             : 
   21453             : 
   21454             : 
   21455             : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarStorageClassDeclatationMacros.macro" */
   21456             : /* 
   21457             :    JH (01/01/2006) ROSETTA generated class declarations for SgUpcLocalsizeofExpressionStorageClass 
   21458             :    used for the ast file IO. Do not chance by hand! 
   21459             : */
   21460           0 : class SgUpcLocalsizeofExpressionStorageClass  : public SgExpressionStorageClass
   21461             :    {
   21462             : 
   21463             :     protected: 
   21464             : 
   21465             : 
   21466             : /* #line 21467 "../../../src/frontend/SageIII//StorageClasses.h" */
   21467             : 
   21468             :      unsigned long storageOf_expression;
   21469             :      unsigned long storageOf_operand_type;
   21470             :      unsigned long storageOf_expression_type;
   21471             : 
   21472             : 
   21473             : /* #line 10 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarStorageClassDeclatationMacros.macro" */
   21474             : 
   21475             : 
   21476             :     public:
   21477             :       void pickOutIRNodeData ( SgUpcLocalsizeofExpression* source );
   21478             :       static void arrangeStaticDataOfEasyStorageClassesInOneBlock ( );
   21479             :       static void deleteStaticDataOfEasyStorageClasses ( );
   21480             :       static void pickOutStaticDataMembers ( );
   21481             :       static void rebuildStaticDataMembers ( );
   21482             :       static void writeEasyStorageDataToFile (std::ostream& out);
   21483             :       static void readEasyStorageDataFromFile (std::istream& in);
   21484             :       static void writeStaticDataToFile (std::ostream& out );
   21485             :       static void readStaticDataFromFile (std::istream& in );
   21486             :       friend class SgUpcLocalsizeofExpression;
   21487             :    };
   21488             : /* #line 21489 "../../../src/frontend/SageIII//StorageClasses.h" */
   21489             : 
   21490             : 
   21491             : 
   21492             : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarStorageClassDeclatationMacros.macro" */
   21493             : /* 
   21494             :    JH (01/01/2006) ROSETTA generated class declarations for SgUpcBlocksizeofExpressionStorageClass 
   21495             :    used for the ast file IO. Do not chance by hand! 
   21496             : */
   21497           0 : class SgUpcBlocksizeofExpressionStorageClass  : public SgExpressionStorageClass
   21498             :    {
   21499             : 
   21500             :     protected: 
   21501             : 
   21502             : 
   21503             : /* #line 21504 "../../../src/frontend/SageIII//StorageClasses.h" */
   21504             : 
   21505             :      unsigned long storageOf_expression;
   21506             :      unsigned long storageOf_operand_type;
   21507             :      unsigned long storageOf_expression_type;
   21508             : 
   21509             : 
   21510             : /* #line 10 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarStorageClassDeclatationMacros.macro" */
   21511             : 
   21512             : 
   21513             :     public:
   21514             :       void pickOutIRNodeData ( SgUpcBlocksizeofExpression* source );
   21515             :       static void arrangeStaticDataOfEasyStorageClassesInOneBlock ( );
   21516             :       static void deleteStaticDataOfEasyStorageClasses ( );
   21517             :       static void pickOutStaticDataMembers ( );
   21518             :       static void rebuildStaticDataMembers ( );
   21519             :       static void writeEasyStorageDataToFile (std::ostream& out);
   21520             :       static void readEasyStorageDataFromFile (std::istream& in);
   21521             :       static void writeStaticDataToFile (std::ostream& out );
   21522             :       static void readStaticDataFromFile (std::istream& in );
   21523             :       friend class SgUpcBlocksizeofExpression;
   21524             :    };
   21525             : /* #line 21526 "../../../src/frontend/SageIII//StorageClasses.h" */
   21526             : 
   21527             : 
   21528             : 
   21529             : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarStorageClassDeclatationMacros.macro" */
   21530             : /* 
   21531             :    JH (01/01/2006) ROSETTA generated class declarations for SgUpcElemsizeofExpressionStorageClass 
   21532             :    used for the ast file IO. Do not chance by hand! 
   21533             : */
   21534           0 : class SgUpcElemsizeofExpressionStorageClass  : public SgExpressionStorageClass
   21535             :    {
   21536             : 
   21537             :     protected: 
   21538             : 
   21539             : 
   21540             : /* #line 21541 "../../../src/frontend/SageIII//StorageClasses.h" */
   21541             : 
   21542             :      unsigned long storageOf_expression;
   21543             :      unsigned long storageOf_operand_type;
   21544             :      unsigned long storageOf_expression_type;
   21545             : 
   21546             : 
   21547             : /* #line 10 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarStorageClassDeclatationMacros.macro" */
   21548             : 
   21549             : 
   21550             :     public:
   21551             :       void pickOutIRNodeData ( SgUpcElemsizeofExpression* source );
   21552             :       static void arrangeStaticDataOfEasyStorageClassesInOneBlock ( );
   21553             :       static void deleteStaticDataOfEasyStorageClasses ( );
   21554             :       static void pickOutStaticDataMembers ( );
   21555             :       static void rebuildStaticDataMembers ( );
   21556             :       static void writeEasyStorageDataToFile (std::ostream& out);
   21557             :       static void readEasyStorageDataFromFile (std::istream& in);
   21558             :       static void writeStaticDataToFile (std::ostream& out );
   21559             :       static void readStaticDataFromFile (std::istream& in );
   21560             :       friend class SgUpcElemsizeofExpression;
   21561             :    };
   21562             : /* #line 21563 "../../../src/frontend/SageIII//StorageClasses.h" */
   21563             : 
   21564             : 
   21565             : 
   21566             : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarStorageClassDeclatationMacros.macro" */
   21567             : /* 
   21568             :    JH (01/01/2006) ROSETTA generated class declarations for SgSuperExpStorageClass 
   21569             :    used for the ast file IO. Do not chance by hand! 
   21570             : */
   21571           0 : class SgSuperExpStorageClass  : public SgExpressionStorageClass
   21572             :    {
   21573             : 
   21574             :     protected: 
   21575             : 
   21576             : 
   21577             : /* #line 21578 "../../../src/frontend/SageIII//StorageClasses.h" */
   21578             : 
   21579             :      unsigned long storageOf_class_symbol;
   21580             :       int storageOf_pobj_super;
   21581             : 
   21582             : 
   21583             : /* #line 10 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarStorageClassDeclatationMacros.macro" */
   21584             : 
   21585             : 
   21586             :     public:
   21587             :       void pickOutIRNodeData ( SgSuperExp* source );
   21588             :       static void arrangeStaticDataOfEasyStorageClassesInOneBlock ( );
   21589             :       static void deleteStaticDataOfEasyStorageClasses ( );
   21590             :       static void pickOutStaticDataMembers ( );
   21591             :       static void rebuildStaticDataMembers ( );
   21592             :       static void writeEasyStorageDataToFile (std::ostream& out);
   21593             :       static void readEasyStorageDataFromFile (std::istream& in);
   21594             :       static void writeStaticDataToFile (std::ostream& out );
   21595             :       static void readStaticDataFromFile (std::istream& in );
   21596             :       friend class SgSuperExp;
   21597             :    };
   21598             : /* #line 21599 "../../../src/frontend/SageIII//StorageClasses.h" */
   21599             : 
   21600             : 
   21601             : 
   21602             : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarStorageClassDeclatationMacros.macro" */
   21603             : /* 
   21604             :    JH (01/01/2006) ROSETTA generated class declarations for SgTypeIdOpStorageClass 
   21605             :    used for the ast file IO. Do not chance by hand! 
   21606             : */
   21607           2 : class SgTypeIdOpStorageClass  : public SgExpressionStorageClass
   21608             :    {
   21609             : 
   21610             :     protected: 
   21611             : 
   21612             : 
   21613             : /* #line 21614 "../../../src/frontend/SageIII//StorageClasses.h" */
   21614             : 
   21615             :      unsigned long storageOf_operand_expr;
   21616             :      unsigned long storageOf_operand_type;
   21617             :       int storageOf_name_qualification_length;
   21618             :       bool storageOf_type_elaboration_required;
   21619             :       bool storageOf_global_qualification_required;
   21620             :       int storageOf_name_qualification_for_pointer_to_member_class_length;
   21621             :       bool storageOf_type_elaboration_for_pointer_to_member_class_required;
   21622             :       bool storageOf_global_qualification_for_pointer_to_member_class_required;
   21623             : 
   21624             : 
   21625             : /* #line 10 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarStorageClassDeclatationMacros.macro" */
   21626             : 
   21627             : 
   21628             :     public:
   21629             :       void pickOutIRNodeData ( SgTypeIdOp* source );
   21630             :       static void arrangeStaticDataOfEasyStorageClassesInOneBlock ( );
   21631             :       static void deleteStaticDataOfEasyStorageClasses ( );
   21632             :       static void pickOutStaticDataMembers ( );
   21633             :       static void rebuildStaticDataMembers ( );
   21634             :       static void writeEasyStorageDataToFile (std::ostream& out);
   21635             :       static void readEasyStorageDataFromFile (std::istream& in);
   21636             :       static void writeStaticDataToFile (std::ostream& out );
   21637             :       static void readStaticDataFromFile (std::istream& in );
   21638             :       friend class SgTypeIdOp;
   21639             :    };
   21640             : /* #line 21641 "../../../src/frontend/SageIII//StorageClasses.h" */
   21641             : 
   21642             : 
   21643             : 
   21644             : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarStorageClassDeclatationMacros.macro" */
   21645             : /* 
   21646             :    JH (01/01/2006) ROSETTA generated class declarations for SgConditionalExpStorageClass 
   21647             :    used for the ast file IO. Do not chance by hand! 
   21648             : */
   21649         142 : class SgConditionalExpStorageClass  : public SgExpressionStorageClass
   21650             :    {
   21651             : 
   21652             :     protected: 
   21653             : 
   21654             : 
   21655             : /* #line 21656 "../../../src/frontend/SageIII//StorageClasses.h" */
   21656             : 
   21657             :      unsigned long storageOf_conditional_exp;
   21658             :      unsigned long storageOf_true_exp;
   21659             :      unsigned long storageOf_false_exp;
   21660             :      unsigned long storageOf_expression_type;
   21661             : 
   21662             : 
   21663             : /* #line 10 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarStorageClassDeclatationMacros.macro" */
   21664             : 
   21665             : 
   21666             :     public:
   21667             :       void pickOutIRNodeData ( SgConditionalExp* source );
   21668             :       static void arrangeStaticDataOfEasyStorageClassesInOneBlock ( );
   21669             :       static void deleteStaticDataOfEasyStorageClasses ( );
   21670             :       static void pickOutStaticDataMembers ( );
   21671             :       static void rebuildStaticDataMembers ( );
   21672             :       static void writeEasyStorageDataToFile (std::ostream& out);
   21673             :       static void readEasyStorageDataFromFile (std::istream& in);
   21674             :       static void writeStaticDataToFile (std::ostream& out );
   21675             :       static void readStaticDataFromFile (std::istream& in );
   21676             :       friend class SgConditionalExp;
   21677             :    };
   21678             : /* #line 21679 "../../../src/frontend/SageIII//StorageClasses.h" */
   21679             : 
   21680             : 
   21681             : 
   21682             : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarStorageClassDeclatationMacros.macro" */
   21683             : /* 
   21684             :    JH (01/01/2006) ROSETTA generated class declarations for SgNewExpStorageClass 
   21685             :    used for the ast file IO. Do not chance by hand! 
   21686             : */
   21687          28 : class SgNewExpStorageClass  : public SgExpressionStorageClass
   21688             :    {
   21689             : 
   21690             :     protected: 
   21691             : 
   21692             : 
   21693             : /* #line 21694 "../../../src/frontend/SageIII//StorageClasses.h" */
   21694             : 
   21695             :      unsigned long storageOf_specified_type;
   21696             :      unsigned long storageOf_placement_args;
   21697             :      unsigned long storageOf_constructor_args;
   21698             :      unsigned long storageOf_builtin_args;
   21699             :       short storageOf_need_global_specifier;
   21700             :      unsigned long storageOf_newOperatorDeclaration;
   21701             :       int storageOf_name_qualification_length;
   21702             :       bool storageOf_type_elaboration_required;
   21703             :       bool storageOf_global_qualification_required;
   21704             :       int storageOf_name_qualification_for_pointer_to_member_class_length;
   21705             :       bool storageOf_type_elaboration_for_pointer_to_member_class_required;
   21706             :       bool storageOf_global_qualification_for_pointer_to_member_class_required;
   21707             : 
   21708             : 
   21709             : /* #line 10 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarStorageClassDeclatationMacros.macro" */
   21710             : 
   21711             : 
   21712             :     public:
   21713             :       void pickOutIRNodeData ( SgNewExp* source );
   21714             :       static void arrangeStaticDataOfEasyStorageClassesInOneBlock ( );
   21715             :       static void deleteStaticDataOfEasyStorageClasses ( );
   21716             :       static void pickOutStaticDataMembers ( );
   21717             :       static void rebuildStaticDataMembers ( );
   21718             :       static void writeEasyStorageDataToFile (std::ostream& out);
   21719             :       static void readEasyStorageDataFromFile (std::istream& in);
   21720             :       static void writeStaticDataToFile (std::ostream& out );
   21721             :       static void readStaticDataFromFile (std::istream& in );
   21722             :       friend class SgNewExp;
   21723             :    };
   21724             : /* #line 21725 "../../../src/frontend/SageIII//StorageClasses.h" */
   21725             : 
   21726             : 
   21727             : 
   21728             : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarStorageClassDeclatationMacros.macro" */
   21729             : /* 
   21730             :    JH (01/01/2006) ROSETTA generated class declarations for SgDeleteExpStorageClass 
   21731             :    used for the ast file IO. Do not chance by hand! 
   21732             : */
   21733          30 : class SgDeleteExpStorageClass  : public SgExpressionStorageClass
   21734             :    {
   21735             : 
   21736             :     protected: 
   21737             : 
   21738             : 
   21739             : /* #line 21740 "../../../src/frontend/SageIII//StorageClasses.h" */
   21740             : 
   21741             :      unsigned long storageOf_variable;
   21742             :       short storageOf_is_array;
   21743             :       short storageOf_need_global_specifier;
   21744             :      unsigned long storageOf_deleteOperatorDeclaration;
   21745             : 
   21746             : 
   21747             : /* #line 10 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarStorageClassDeclatationMacros.macro" */
   21748             : 
   21749             : 
   21750             :     public:
   21751             :       void pickOutIRNodeData ( SgDeleteExp* source );
   21752             :       static void arrangeStaticDataOfEasyStorageClassesInOneBlock ( );
   21753             :       static void deleteStaticDataOfEasyStorageClasses ( );
   21754             :       static void pickOutStaticDataMembers ( );
   21755             :       static void rebuildStaticDataMembers ( );
   21756             :       static void writeEasyStorageDataToFile (std::ostream& out);
   21757             :       static void readEasyStorageDataFromFile (std::istream& in);
   21758             :       static void writeStaticDataToFile (std::ostream& out );
   21759             :       static void readStaticDataFromFile (std::istream& in );
   21760             :       friend class SgDeleteExp;
   21761             :    };
   21762             : /* #line 21763 "../../../src/frontend/SageIII//StorageClasses.h" */
   21763             : 
   21764             : 
   21765             : 
   21766             : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarStorageClassDeclatationMacros.macro" */
   21767             : /* 
   21768             :    JH (01/01/2006) ROSETTA generated class declarations for SgThisExpStorageClass 
   21769             :    used for the ast file IO. Do not chance by hand! 
   21770             : */
   21771        2472 : class SgThisExpStorageClass  : public SgExpressionStorageClass
   21772             :    {
   21773             : 
   21774             :     protected: 
   21775             : 
   21776             : 
   21777             : /* #line 21778 "../../../src/frontend/SageIII//StorageClasses.h" */
   21778             : 
   21779             :      unsigned long storageOf_class_symbol;
   21780             :      unsigned long storageOf_nonreal_symbol;
   21781             :       int storageOf_pobj_this;
   21782             : 
   21783             : 
   21784             : /* #line 10 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarStorageClassDeclatationMacros.macro" */
   21785             : 
   21786             : 
   21787             :     public:
   21788             :       void pickOutIRNodeData ( SgThisExp* source );
   21789             :       static void arrangeStaticDataOfEasyStorageClassesInOneBlock ( );
   21790             :       static void deleteStaticDataOfEasyStorageClasses ( );
   21791             :       static void pickOutStaticDataMembers ( );
   21792             :       static void rebuildStaticDataMembers ( );
   21793             :       static void writeEasyStorageDataToFile (std::ostream& out);
   21794             :       static void readEasyStorageDataFromFile (std::istream& in);
   21795             :       static void writeStaticDataToFile (std::ostream& out );
   21796             :       static void readStaticDataFromFile (std::istream& in );
   21797             :       friend class SgThisExp;
   21798             :    };
   21799             : /* #line 21800 "../../../src/frontend/SageIII//StorageClasses.h" */
   21800             : 
   21801             : 
   21802             : 
   21803             : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarStorageClassDeclatationMacros.macro" */
   21804             : /* 
   21805             :    JH (01/01/2006) ROSETTA generated class declarations for SgRefExpStorageClass 
   21806             :    used for the ast file IO. Do not chance by hand! 
   21807             : */
   21808           0 : class SgRefExpStorageClass  : public SgExpressionStorageClass
   21809             :    {
   21810             : 
   21811             :     protected: 
   21812             : 
   21813             : 
   21814             : /* #line 21815 "../../../src/frontend/SageIII//StorageClasses.h" */
   21815             : 
   21816             :      unsigned long storageOf_type_name;
   21817             : 
   21818             : 
   21819             : /* #line 10 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarStorageClassDeclatationMacros.macro" */
   21820             : 
   21821             : 
   21822             :     public:
   21823             :       void pickOutIRNodeData ( SgRefExp* source );
   21824             :       static void arrangeStaticDataOfEasyStorageClassesInOneBlock ( );
   21825             :       static void deleteStaticDataOfEasyStorageClasses ( );
   21826             :       static void pickOutStaticDataMembers ( );
   21827             :       static void rebuildStaticDataMembers ( );
   21828             :       static void writeEasyStorageDataToFile (std::ostream& out);
   21829             :       static void readEasyStorageDataFromFile (std::istream& in);
   21830             :       static void writeStaticDataToFile (std::ostream& out );
   21831             :       static void readStaticDataFromFile (std::istream& in );
   21832             :       friend class SgRefExp;
   21833             :    };
   21834             : /* #line 21835 "../../../src/frontend/SageIII//StorageClasses.h" */
   21835             : 
   21836             : 
   21837             : 
   21838             : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarStorageClassDeclatationMacros.macro" */
   21839             : /* 
   21840             :    JH (01/01/2006) ROSETTA generated class declarations for SgInitializerStorageClass 
   21841             :    used for the ast file IO. Do not chance by hand! 
   21842             : */
   21843           0 : class SgInitializerStorageClass  : public SgExpressionStorageClass
   21844             :    {
   21845             : 
   21846             :     protected: 
   21847             : 
   21848             : 
   21849             : /* #line 21850 "../../../src/frontend/SageIII//StorageClasses.h" */
   21850             : 
   21851             :       bool storageOf_is_explicit_cast;
   21852             :       bool storageOf_is_braced_initialized;
   21853             : 
   21854             : 
   21855             : /* #line 10 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarStorageClassDeclatationMacros.macro" */
   21856             : 
   21857             : 
   21858             :     public:
   21859             :       void pickOutIRNodeData ( SgInitializer* source );
   21860             :       static void arrangeStaticDataOfEasyStorageClassesInOneBlock ( );
   21861             :       static void deleteStaticDataOfEasyStorageClasses ( );
   21862             :       static void pickOutStaticDataMembers ( );
   21863             :       static void rebuildStaticDataMembers ( );
   21864             :       static void writeEasyStorageDataToFile (std::ostream& out);
   21865             :       static void readEasyStorageDataFromFile (std::istream& in);
   21866             :       static void writeStaticDataToFile (std::ostream& out );
   21867             :       static void readStaticDataFromFile (std::istream& in );
   21868             :       friend class SgInitializer;
   21869             :    };
   21870             : /* #line 21871 "../../../src/frontend/SageIII//StorageClasses.h" */
   21871             : 
   21872             : 
   21873             : 
   21874             : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarStorageClassDeclatationMacros.macro" */
   21875             : /* 
   21876             :    JH (01/01/2006) ROSETTA generated class declarations for SgAggregateInitializerStorageClass 
   21877             :    used for the ast file IO. Do not chance by hand! 
   21878             : */
   21879           6 : class SgAggregateInitializerStorageClass  : public SgInitializerStorageClass
   21880             :    {
   21881             : 
   21882             :     protected: 
   21883             : 
   21884             : 
   21885             : /* #line 21886 "../../../src/frontend/SageIII//StorageClasses.h" */
   21886             : 
   21887             :      unsigned long storageOf_initializers;
   21888             :      unsigned long storageOf_expression_type;
   21889             :       bool storageOf_need_explicit_braces;
   21890             :       bool storageOf_uses_compound_literal;
   21891             :       bool storageOf_requiresGlobalNameQualificationOnType;
   21892             :       int storageOf_name_qualification_length_for_type;
   21893             :       bool storageOf_type_elaboration_required_for_type;
   21894             :       bool storageOf_global_qualification_required_for_type;
   21895             :      unsigned long storageOf_originalExpressionTree;
   21896             : 
   21897             : 
   21898             : /* #line 10 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarStorageClassDeclatationMacros.macro" */
   21899             : 
   21900             : 
   21901             :     public:
   21902             :       void pickOutIRNodeData ( SgAggregateInitializer* source );
   21903             :       static void arrangeStaticDataOfEasyStorageClassesInOneBlock ( );
   21904             :       static void deleteStaticDataOfEasyStorageClasses ( );
   21905             :       static void pickOutStaticDataMembers ( );
   21906             :       static void rebuildStaticDataMembers ( );
   21907             :       static void writeEasyStorageDataToFile (std::ostream& out);
   21908             :       static void readEasyStorageDataFromFile (std::istream& in);
   21909             :       static void writeStaticDataToFile (std::ostream& out );
   21910             :       static void readStaticDataFromFile (std::istream& in );
   21911             :       friend class SgAggregateInitializer;
   21912             :    };
   21913             : /* #line 21914 "../../../src/frontend/SageIII//StorageClasses.h" */
   21914             : 
   21915             : 
   21916             : 
   21917             : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarStorageClassDeclatationMacros.macro" */
   21918             : /* 
   21919             :    JH (01/01/2006) ROSETTA generated class declarations for SgCompoundInitializerStorageClass 
   21920             :    used for the ast file IO. Do not chance by hand! 
   21921             : */
   21922           0 : class SgCompoundInitializerStorageClass  : public SgInitializerStorageClass
   21923             :    {
   21924             : 
   21925             :     protected: 
   21926             : 
   21927             : 
   21928             : /* #line 21929 "../../../src/frontend/SageIII//StorageClasses.h" */
   21929             : 
   21930             :      unsigned long storageOf_initializers;
   21931             :      unsigned long storageOf_expression_type;
   21932             : 
   21933             : 
   21934             : /* #line 10 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarStorageClassDeclatationMacros.macro" */
   21935             : 
   21936             : 
   21937             :     public:
   21938             :       void pickOutIRNodeData ( SgCompoundInitializer* source );
   21939             :       static void arrangeStaticDataOfEasyStorageClassesInOneBlock ( );
   21940             :       static void deleteStaticDataOfEasyStorageClasses ( );
   21941             :       static void pickOutStaticDataMembers ( );
   21942             :       static void rebuildStaticDataMembers ( );
   21943             :       static void writeEasyStorageDataToFile (std::ostream& out);
   21944             :       static void readEasyStorageDataFromFile (std::istream& in);
   21945             :       static void writeStaticDataToFile (std::ostream& out );
   21946             :       static void readStaticDataFromFile (std::istream& in );
   21947             :       friend class SgCompoundInitializer;
   21948             :    };
   21949             : /* #line 21950 "../../../src/frontend/SageIII//StorageClasses.h" */
   21950             : 
   21951             : 
   21952             : 
   21953             : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarStorageClassDeclatationMacros.macro" */
   21954             : /* 
   21955             :    JH (01/01/2006) ROSETTA generated class declarations for SgConstructorInitializerStorageClass 
   21956             :    used for the ast file IO. Do not chance by hand! 
   21957             : */
   21958         922 : class SgConstructorInitializerStorageClass  : public SgInitializerStorageClass
   21959             :    {
   21960             : 
   21961             :     protected: 
   21962             : 
   21963             : 
   21964             : /* #line 21965 "../../../src/frontend/SageIII//StorageClasses.h" */
   21965             : 
   21966             :      unsigned long storageOf_declaration;
   21967             :      unsigned long storageOf_args;
   21968             :      unsigned long storageOf_expression_type;
   21969             :       bool storageOf_need_name;
   21970             :       bool storageOf_need_qualifier;
   21971             :       bool storageOf_need_parenthesis_after_name;
   21972             :       bool storageOf_associated_class_unknown;
   21973             :       int storageOf_name_qualification_length;
   21974             :       bool storageOf_type_elaboration_required;
   21975             :       bool storageOf_global_qualification_required;
   21976             :       bool storageOf_is_used_in_conditional;
   21977             : 
   21978             : 
   21979             : /* #line 10 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarStorageClassDeclatationMacros.macro" */
   21980             : 
   21981             : 
   21982             :     public:
   21983             :       void pickOutIRNodeData ( SgConstructorInitializer* source );
   21984             :       static void arrangeStaticDataOfEasyStorageClassesInOneBlock ( );
   21985             :       static void deleteStaticDataOfEasyStorageClasses ( );
   21986             :       static void pickOutStaticDataMembers ( );
   21987             :       static void rebuildStaticDataMembers ( );
   21988             :       static void writeEasyStorageDataToFile (std::ostream& out);
   21989             :       static void readEasyStorageDataFromFile (std::istream& in);
   21990             :       static void writeStaticDataToFile (std::ostream& out );
   21991             :       static void readStaticDataFromFile (std::istream& in );
   21992             :       friend class SgConstructorInitializer;
   21993             :    };
   21994             : /* #line 21995 "../../../src/frontend/SageIII//StorageClasses.h" */
   21995             : 
   21996             : 
   21997             : 
   21998             : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarStorageClassDeclatationMacros.macro" */
   21999             : /* 
   22000             :    JH (01/01/2006) ROSETTA generated class declarations for SgAssignInitializerStorageClass 
   22001             :    used for the ast file IO. Do not chance by hand! 
   22002             : */
   22003        2386 : class SgAssignInitializerStorageClass  : public SgInitializerStorageClass
   22004             :    {
   22005             : 
   22006             :     protected: 
   22007             : 
   22008             : 
   22009             : /* #line 22010 "../../../src/frontend/SageIII//StorageClasses.h" */
   22010             : 
   22011             :      unsigned long storageOf_operand_i;
   22012             :      unsigned long storageOf_expression_type;
   22013             : 
   22014             : 
   22015             : /* #line 10 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarStorageClassDeclatationMacros.macro" */
   22016             : 
   22017             : 
   22018             :     public:
   22019             :       void pickOutIRNodeData ( SgAssignInitializer* source );
   22020             :       static void arrangeStaticDataOfEasyStorageClassesInOneBlock ( );
   22021             :       static void deleteStaticDataOfEasyStorageClasses ( );
   22022             :       static void pickOutStaticDataMembers ( );
   22023             :       static void rebuildStaticDataMembers ( );
   22024             :       static void writeEasyStorageDataToFile (std::ostream& out);
   22025             :       static void readEasyStorageDataFromFile (std::istream& in);
   22026             :       static void writeStaticDataToFile (std::ostream& out );
   22027             :       static void readStaticDataFromFile (std::istream& in );
   22028             :       friend class SgAssignInitializer;
   22029             :    };
   22030             : /* #line 22031 "../../../src/frontend/SageIII//StorageClasses.h" */
   22031             : 
   22032             : 
   22033             : 
   22034             : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarStorageClassDeclatationMacros.macro" */
   22035             : /* 
   22036             :    JH (01/01/2006) ROSETTA generated class declarations for SgDesignatedInitializerStorageClass 
   22037             :    used for the ast file IO. Do not chance by hand! 
   22038             : */
   22039           0 : class SgDesignatedInitializerStorageClass  : public SgInitializerStorageClass
   22040             :    {
   22041             : 
   22042             :     protected: 
   22043             : 
   22044             : 
   22045             : /* #line 22046 "../../../src/frontend/SageIII//StorageClasses.h" */
   22046             : 
   22047             :      unsigned long storageOf_designatorList;
   22048             :      unsigned long storageOf_memberInit;
   22049             : 
   22050             : 
   22051             : /* #line 10 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarStorageClassDeclatationMacros.macro" */
   22052             : 
   22053             : 
   22054             :     public:
   22055             :       void pickOutIRNodeData ( SgDesignatedInitializer* source );
   22056             :       static void arrangeStaticDataOfEasyStorageClassesInOneBlock ( );
   22057             :       static void deleteStaticDataOfEasyStorageClasses ( );
   22058             :       static void pickOutStaticDataMembers ( );
   22059             :       static void rebuildStaticDataMembers ( );
   22060             :       static void writeEasyStorageDataToFile (std::ostream& out);
   22061             :       static void readEasyStorageDataFromFile (std::istream& in);
   22062             :       static void writeStaticDataToFile (std::ostream& out );
   22063             :       static void readStaticDataFromFile (std::istream& in );
   22064             :       friend class SgDesignatedInitializer;
   22065             :    };
   22066             : /* #line 22067 "../../../src/frontend/SageIII//StorageClasses.h" */
   22067             : 
   22068             : 
   22069             : 
   22070             : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarStorageClassDeclatationMacros.macro" */
   22071             : /* 
   22072             :    JH (01/01/2006) ROSETTA generated class declarations for SgBracedInitializerStorageClass 
   22073             :    used for the ast file IO. Do not chance by hand! 
   22074             : */
   22075           2 : class SgBracedInitializerStorageClass  : public SgInitializerStorageClass
   22076             :    {
   22077             : 
   22078             :     protected: 
   22079             : 
   22080             : 
   22081             : /* #line 22082 "../../../src/frontend/SageIII//StorageClasses.h" */
   22082             : 
   22083             :      unsigned long storageOf_initializers;
   22084             :      unsigned long storageOf_expression_type;
   22085             : 
   22086             : 
   22087             : /* #line 10 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarStorageClassDeclatationMacros.macro" */
   22088             : 
   22089             : 
   22090             :     public:
   22091             :       void pickOutIRNodeData ( SgBracedInitializer* source );
   22092             :       static void arrangeStaticDataOfEasyStorageClassesInOneBlock ( );
   22093             :       static void deleteStaticDataOfEasyStorageClasses ( );
   22094             :       static void pickOutStaticDataMembers ( );
   22095             :       static void rebuildStaticDataMembers ( );
   22096             :       static void writeEasyStorageDataToFile (std::ostream& out);
   22097             :       static void readEasyStorageDataFromFile (std::istream& in);
   22098             :       static void writeStaticDataToFile (std::ostream& out );
   22099             :       static void readStaticDataFromFile (std::istream& in );
   22100             :       friend class SgBracedInitializer;
   22101             :    };
   22102             : /* #line 22103 "../../../src/frontend/SageIII//StorageClasses.h" */
   22103             : 
   22104             : 
   22105             : 
   22106             : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarStorageClassDeclatationMacros.macro" */
   22107             : /* 
   22108             :    JH (01/01/2006) ROSETTA generated class declarations for SgVarArgStartOpStorageClass 
   22109             :    used for the ast file IO. Do not chance by hand! 
   22110             : */
   22111           0 : class SgVarArgStartOpStorageClass  : public SgExpressionStorageClass
   22112             :    {
   22113             : 
   22114             :     protected: 
   22115             : 
   22116             : 
   22117             : /* #line 22118 "../../../src/frontend/SageIII//StorageClasses.h" */
   22118             : 
   22119             :      unsigned long storageOf_lhs_operand;
   22120             :      unsigned long storageOf_rhs_operand;
   22121             :      unsigned long storageOf_expression_type;
   22122             : 
   22123             : 
   22124             : /* #line 10 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarStorageClassDeclatationMacros.macro" */
   22125             : 
   22126             : 
   22127             :     public:
   22128             :       void pickOutIRNodeData ( SgVarArgStartOp* source );
   22129             :       static void arrangeStaticDataOfEasyStorageClassesInOneBlock ( );
   22130             :       static void deleteStaticDataOfEasyStorageClasses ( );
   22131             :       static void pickOutStaticDataMembers ( );
   22132             :       static void rebuildStaticDataMembers ( );
   22133             :       static void writeEasyStorageDataToFile (std::ostream& out);
   22134             :       static void readEasyStorageDataFromFile (std::istream& in);
   22135             :       static void writeStaticDataToFile (std::ostream& out );
   22136             :       static void readStaticDataFromFile (std::istream& in );
   22137             :       friend class SgVarArgStartOp;
   22138             :    };
   22139             : /* #line 22140 "../../../src/frontend/SageIII//StorageClasses.h" */
   22140             : 
   22141             : 
   22142             : 
   22143             : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarStorageClassDeclatationMacros.macro" */
   22144             : /* 
   22145             :    JH (01/01/2006) ROSETTA generated class declarations for SgVarArgOpStorageClass 
   22146             :    used for the ast file IO. Do not chance by hand! 
   22147             : */
   22148           0 : class SgVarArgOpStorageClass  : public SgExpressionStorageClass
   22149             :    {
   22150             : 
   22151             :     protected: 
   22152             : 
   22153             : 
   22154             : /* #line 22155 "../../../src/frontend/SageIII//StorageClasses.h" */
   22155             : 
   22156             :      unsigned long storageOf_operand_expr;
   22157             :      unsigned long storageOf_expression_type;
   22158             : 
   22159             : 
   22160             : /* #line 10 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarStorageClassDeclatationMacros.macro" */
   22161             : 
   22162             : 
   22163             :     public:
   22164             :       void pickOutIRNodeData ( SgVarArgOp* source );
   22165             :       static void arrangeStaticDataOfEasyStorageClassesInOneBlock ( );
   22166             :       static void deleteStaticDataOfEasyStorageClasses ( );
   22167             :       static void pickOutStaticDataMembers ( );
   22168             :       static void rebuildStaticDataMembers ( );
   22169             :       static void writeEasyStorageDataToFile (std::ostream& out);
   22170             :       static void readEasyStorageDataFromFile (std::istream& in);
   22171             :       static void writeStaticDataToFile (std::ostream& out );
   22172             :       static void readStaticDataFromFile (std::istream& in );
   22173             :       friend class SgVarArgOp;
   22174             :    };
   22175             : /* #line 22176 "../../../src/frontend/SageIII//StorageClasses.h" */
   22176             : 
   22177             : 
   22178             : 
   22179             : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarStorageClassDeclatationMacros.macro" */
   22180             : /* 
   22181             :    JH (01/01/2006) ROSETTA generated class declarations for SgVarArgEndOpStorageClass 
   22182             :    used for the ast file IO. Do not chance by hand! 
   22183             : */
   22184           0 : class SgVarArgEndOpStorageClass  : public SgExpressionStorageClass
   22185             :    {
   22186             : 
   22187             :     protected: 
   22188             : 
   22189             : 
   22190             : /* #line 22191 "../../../src/frontend/SageIII//StorageClasses.h" */
   22191             : 
   22192             :      unsigned long storageOf_operand_expr;
   22193             :      unsigned long storageOf_expression_type;
   22194             : 
   22195             : 
   22196             : /* #line 10 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarStorageClassDeclatationMacros.macro" */
   22197             : 
   22198             : 
   22199             :     public:
   22200             :       void pickOutIRNodeData ( SgVarArgEndOp* source );
   22201             :       static void arrangeStaticDataOfEasyStorageClassesInOneBlock ( );
   22202             :       static void deleteStaticDataOfEasyStorageClasses ( );
   22203             :       static void pickOutStaticDataMembers ( );
   22204             :       static void rebuildStaticDataMembers ( );
   22205             :       static void writeEasyStorageDataToFile (std::ostream& out);
   22206             :       static void readEasyStorageDataFromFile (std::istream& in);
   22207             :       static void writeStaticDataToFile (std::ostream& out );
   22208             :       static void readStaticDataFromFile (std::istream& in );
   22209             :       friend class SgVarArgEndOp;
   22210             :    };
   22211             : /* #line 22212 "../../../src/frontend/SageIII//StorageClasses.h" */
   22212             : 
   22213             : 
   22214             : 
   22215             : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarStorageClassDeclatationMacros.macro" */
   22216             : /* 
   22217             :    JH (01/01/2006) ROSETTA generated class declarations for SgVarArgCopyOpStorageClass 
   22218             :    used for the ast file IO. Do not chance by hand! 
   22219             : */
   22220           0 : class SgVarArgCopyOpStorageClass  : public SgExpressionStorageClass
   22221             :    {
   22222             : 
   22223             :     protected: 
   22224             : 
   22225             : 
   22226             : /* #line 22227 "../../../src/frontend/SageIII//StorageClasses.h" */
   22227             : 
   22228             :      unsigned long storageOf_lhs_operand;
   22229             :      unsigned long storageOf_rhs_operand;
   22230             :      unsigned long storageOf_expression_type;
   22231             : 
   22232             : 
   22233             : /* #line 10 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarStorageClassDeclatationMacros.macro" */
   22234             : 
   22235             : 
   22236             :     public:
   22237             :       void pickOutIRNodeData ( SgVarArgCopyOp* source );
   22238             :       static void arrangeStaticDataOfEasyStorageClassesInOneBlock ( );
   22239             :       static void deleteStaticDataOfEasyStorageClasses ( );
   22240             :       static void pickOutStaticDataMembers ( );
   22241             :       static void rebuildStaticDataMembers ( );
   22242             :       static void writeEasyStorageDataToFile (std::ostream& out);
   22243             :       static void readEasyStorageDataFromFile (std::istream& in);
   22244             :       static void writeStaticDataToFile (std::ostream& out );
   22245             :       static void readStaticDataFromFile (std::istream& in );
   22246             :       friend class SgVarArgCopyOp;
   22247             :    };
   22248             : /* #line 22249 "../../../src/frontend/SageIII//StorageClasses.h" */
   22249             : 
   22250             : 
   22251             : 
   22252             : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarStorageClassDeclatationMacros.macro" */
   22253             : /* 
   22254             :    JH (01/01/2006) ROSETTA generated class declarations for SgVarArgStartOneOperandOpStorageClass 
   22255             :    used for the ast file IO. Do not chance by hand! 
   22256             : */
   22257           0 : class SgVarArgStartOneOperandOpStorageClass  : public SgExpressionStorageClass
   22258             :    {
   22259             : 
   22260             :     protected: 
   22261             : 
   22262             : 
   22263             : /* #line 22264 "../../../src/frontend/SageIII//StorageClasses.h" */
   22264             : 
   22265             :      unsigned long storageOf_operand_expr;
   22266             :      unsigned long storageOf_expression_type;
   22267             : 
   22268             : 
   22269             : /* #line 10 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarStorageClassDeclatationMacros.macro" */
   22270             : 
   22271             : 
   22272             :     public:
   22273             :       void pickOutIRNodeData ( SgVarArgStartOneOperandOp* source );
   22274             :       static void arrangeStaticDataOfEasyStorageClassesInOneBlock ( );
   22275             :       static void deleteStaticDataOfEasyStorageClasses ( );
   22276             :       static void pickOutStaticDataMembers ( );
   22277             :       static void rebuildStaticDataMembers ( );
   22278             :       static void writeEasyStorageDataToFile (std::ostream& out);
   22279             :       static void readEasyStorageDataFromFile (std::istream& in);
   22280             :       static void writeStaticDataToFile (std::ostream& out );
   22281             :       static void readStaticDataFromFile (std::istream& in );
   22282             :       friend class SgVarArgStartOneOperandOp;
   22283             :    };
   22284             : /* #line 22285 "../../../src/frontend/SageIII//StorageClasses.h" */
   22285             : 
   22286             : 
   22287             : 
   22288             : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarStorageClassDeclatationMacros.macro" */
   22289             : /* 
   22290             :    JH (01/01/2006) ROSETTA generated class declarations for SgNullExpressionStorageClass 
   22291             :    used for the ast file IO. Do not chance by hand! 
   22292             : */
   22293         242 : class SgNullExpressionStorageClass  : public SgExpressionStorageClass
   22294             :    {
   22295             : 
   22296             :     protected: 
   22297             : 
   22298             : 
   22299             : /* #line 22300 "../../../src/frontend/SageIII//StorageClasses.h" */
   22300             : 
   22301             : 
   22302             : 
   22303             : /* #line 10 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarStorageClassDeclatationMacros.macro" */
   22304             : 
   22305             : 
   22306             :     public:
   22307             :       void pickOutIRNodeData ( SgNullExpression* source );
   22308             :       static void arrangeStaticDataOfEasyStorageClassesInOneBlock ( );
   22309             :       static void deleteStaticDataOfEasyStorageClasses ( );
   22310             :       static void pickOutStaticDataMembers ( );
   22311             :       static void rebuildStaticDataMembers ( );
   22312             :       static void writeEasyStorageDataToFile (std::ostream& out);
   22313             :       static void readEasyStorageDataFromFile (std::istream& in);
   22314             :       static void writeStaticDataToFile (std::ostream& out );
   22315             :       static void readStaticDataFromFile (std::istream& in );
   22316             :       friend class SgNullExpression;
   22317             :    };
   22318             : /* #line 22319 "../../../src/frontend/SageIII//StorageClasses.h" */
   22319             : 
   22320             : 
   22321             : 
   22322             : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarStorageClassDeclatationMacros.macro" */
   22323             : /* 
   22324             :    JH (01/01/2006) ROSETTA generated class declarations for SgVariantExpressionStorageClass 
   22325             :    used for the ast file IO. Do not chance by hand! 
   22326             : */
   22327           0 : class SgVariantExpressionStorageClass  : public SgExpressionStorageClass
   22328             :    {
   22329             : 
   22330             :     protected: 
   22331             : 
   22332             : 
   22333             : /* #line 22334 "../../../src/frontend/SageIII//StorageClasses.h" */
   22334             : 
   22335             : 
   22336             : 
   22337             : /* #line 10 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarStorageClassDeclatationMacros.macro" */
   22338             : 
   22339             : 
   22340             :     public:
   22341             :       void pickOutIRNodeData ( SgVariantExpression* source );
   22342             :       static void arrangeStaticDataOfEasyStorageClassesInOneBlock ( );
   22343             :       static void deleteStaticDataOfEasyStorageClasses ( );
   22344             :       static void pickOutStaticDataMembers ( );
   22345             :       static void rebuildStaticDataMembers ( );
   22346             :       static void writeEasyStorageDataToFile (std::ostream& out);
   22347             :       static void readEasyStorageDataFromFile (std::istream& in);
   22348             :       static void writeStaticDataToFile (std::ostream& out );
   22349             :       static void readStaticDataFromFile (std::istream& in );
   22350             :       friend class SgVariantExpression;
   22351             :    };
   22352             : /* #line 22353 "../../../src/frontend/SageIII//StorageClasses.h" */
   22353             : 
   22354             : 
   22355             : 
   22356             : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarStorageClassDeclatationMacros.macro" */
   22357             : /* 
   22358             :    JH (01/01/2006) ROSETTA generated class declarations for SgSubscriptExpressionStorageClass 
   22359             :    used for the ast file IO. Do not chance by hand! 
   22360             : */
   22361           0 : class SgSubscriptExpressionStorageClass  : public SgExpressionStorageClass
   22362             :    {
   22363             : 
   22364             :     protected: 
   22365             : 
   22366             : 
   22367             : /* #line 22368 "../../../src/frontend/SageIII//StorageClasses.h" */
   22368             : 
   22369             :      unsigned long storageOf_lowerBound;
   22370             :      unsigned long storageOf_upperBound;
   22371             :      unsigned long storageOf_stride;
   22372             : 
   22373             : 
   22374             : /* #line 10 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarStorageClassDeclatationMacros.macro" */
   22375             : 
   22376             : 
   22377             :     public:
   22378             :       void pickOutIRNodeData ( SgSubscriptExpression* source );
   22379             :       static void arrangeStaticDataOfEasyStorageClassesInOneBlock ( );
   22380             :       static void deleteStaticDataOfEasyStorageClasses ( );
   22381             :       static void pickOutStaticDataMembers ( );
   22382             :       static void rebuildStaticDataMembers ( );
   22383             :       static void writeEasyStorageDataToFile (std::ostream& out);
   22384             :       static void readEasyStorageDataFromFile (std::istream& in);
   22385             :       static void writeStaticDataToFile (std::ostream& out );
   22386             :       static void readStaticDataFromFile (std::istream& in );
   22387             :       friend class SgSubscriptExpression;
   22388             :    };
   22389             : /* #line 22390 "../../../src/frontend/SageIII//StorageClasses.h" */
   22390             : 
   22391             : 
   22392             : 
   22393             : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarStorageClassDeclatationMacros.macro" */
   22394             : /* 
   22395             :    JH (01/01/2006) ROSETTA generated class declarations for SgColonShapeExpStorageClass 
   22396             :    used for the ast file IO. Do not chance by hand! 
   22397             : */
   22398           0 : class SgColonShapeExpStorageClass  : public SgExpressionStorageClass
   22399             :    {
   22400             : 
   22401             :     protected: 
   22402             : 
   22403             : 
   22404             : /* #line 22405 "../../../src/frontend/SageIII//StorageClasses.h" */
   22405             : 
   22406             : 
   22407             : 
   22408             : /* #line 10 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarStorageClassDeclatationMacros.macro" */
   22409             : 
   22410             : 
   22411             :     public:
   22412             :       void pickOutIRNodeData ( SgColonShapeExp* source );
   22413             :       static void arrangeStaticDataOfEasyStorageClassesInOneBlock ( );
   22414             :       static void deleteStaticDataOfEasyStorageClasses ( );
   22415             :       static void pickOutStaticDataMembers ( );
   22416             :       static void rebuildStaticDataMembers ( );
   22417             :       static void writeEasyStorageDataToFile (std::ostream& out);
   22418             :       static void readEasyStorageDataFromFile (std::istream& in);
   22419             :       static void writeStaticDataToFile (std::ostream& out );
   22420             :       static void readStaticDataFromFile (std::istream& in );
   22421             :       friend class SgColonShapeExp;
   22422             :    };
   22423             : /* #line 22424 "../../../src/frontend/SageIII//StorageClasses.h" */
   22424             : 
   22425             : 
   22426             : 
   22427             : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarStorageClassDeclatationMacros.macro" */
   22428             : /* 
   22429             :    JH (01/01/2006) ROSETTA generated class declarations for SgAsteriskShapeExpStorageClass 
   22430             :    used for the ast file IO. Do not chance by hand! 
   22431             : */
   22432           1 : class SgAsteriskShapeExpStorageClass  : public SgExpressionStorageClass
   22433             :    {
   22434             : 
   22435             :     protected: 
   22436             : 
   22437             : 
   22438             : /* #line 22439 "../../../src/frontend/SageIII//StorageClasses.h" */
   22439             : 
   22440             : 
   22441             : 
   22442             : /* #line 10 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarStorageClassDeclatationMacros.macro" */
   22443             : 
   22444             : 
   22445             :     public:
   22446             :       void pickOutIRNodeData ( SgAsteriskShapeExp* source );
   22447             :       static void arrangeStaticDataOfEasyStorageClassesInOneBlock ( );
   22448             :       static void deleteStaticDataOfEasyStorageClasses ( );
   22449             :       static void pickOutStaticDataMembers ( );
   22450             :       static void rebuildStaticDataMembers ( );
   22451             :       static void writeEasyStorageDataToFile (std::ostream& out);
   22452             :       static void readEasyStorageDataFromFile (std::istream& in);
   22453             :       static void writeStaticDataToFile (std::ostream& out );
   22454             :       static void readStaticDataFromFile (std::istream& in );
   22455             :       friend class SgAsteriskShapeExp;
   22456             :    };
   22457             : /* #line 22458 "../../../src/frontend/SageIII//StorageClasses.h" */
   22458             : 
   22459             : 
   22460             : 
   22461             : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarStorageClassDeclatationMacros.macro" */
   22462             : /* 
   22463             :    JH (01/01/2006) ROSETTA generated class declarations for SgImpliedDoStorageClass 
   22464             :    used for the ast file IO. Do not chance by hand! 
   22465             : */
   22466           0 : class SgImpliedDoStorageClass  : public SgExpressionStorageClass
   22467             :    {
   22468             : 
   22469             :     protected: 
   22470             : 
   22471             : 
   22472             : /* #line 22473 "../../../src/frontend/SageIII//StorageClasses.h" */
   22473             : 
   22474             :      unsigned long storageOf_do_var_initialization;
   22475             :      unsigned long storageOf_last_val;
   22476             :      unsigned long storageOf_increment;
   22477             :      unsigned long storageOf_object_list;
   22478             :      unsigned long storageOf_implied_do_scope;
   22479             : 
   22480             : 
   22481             : /* #line 10 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarStorageClassDeclatationMacros.macro" */
   22482             : 
   22483             : 
   22484             :     public:
   22485             :       void pickOutIRNodeData ( SgImpliedDo* source );
   22486             :       static void arrangeStaticDataOfEasyStorageClassesInOneBlock ( );
   22487             :       static void deleteStaticDataOfEasyStorageClasses ( );
   22488             :       static void pickOutStaticDataMembers ( );
   22489             :       static void rebuildStaticDataMembers ( );
   22490             :       static void writeEasyStorageDataToFile (std::ostream& out);
   22491             :       static void readEasyStorageDataFromFile (std::istream& in);
   22492             :       static void writeStaticDataToFile (std::ostream& out );
   22493             :       static void readStaticDataFromFile (std::istream& in );
   22494             :       friend class SgImpliedDo;
   22495             :    };
   22496             : /* #line 22497 "../../../src/frontend/SageIII//StorageClasses.h" */
   22497             : 
   22498             : 
   22499             : 
   22500             : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarStorageClassDeclatationMacros.macro" */
   22501             : /* 
   22502             :    JH (01/01/2006) ROSETTA generated class declarations for SgIOItemExpressionStorageClass 
   22503             :    used for the ast file IO. Do not chance by hand! 
   22504             : */
   22505           0 : class SgIOItemExpressionStorageClass  : public SgExpressionStorageClass
   22506             :    {
   22507             : 
   22508             :     protected: 
   22509             : 
   22510             : 
   22511             : /* #line 22512 "../../../src/frontend/SageIII//StorageClasses.h" */
   22512             : 
   22513             :       SgNameStorageClass storageOf_name;
   22514             :      unsigned long storageOf_io_item;
   22515             : 
   22516             : 
   22517             : /* #line 10 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarStorageClassDeclatationMacros.macro" */
   22518             : 
   22519             : 
   22520             :     public:
   22521             :       void pickOutIRNodeData ( SgIOItemExpression* source );
   22522             :       static void arrangeStaticDataOfEasyStorageClassesInOneBlock ( );
   22523             :       static void deleteStaticDataOfEasyStorageClasses ( );
   22524             :       static void pickOutStaticDataMembers ( );
   22525             :       static void rebuildStaticDataMembers ( );
   22526             :       static void writeEasyStorageDataToFile (std::ostream& out);
   22527             :       static void readEasyStorageDataFromFile (std::istream& in);
   22528             :       static void writeStaticDataToFile (std::ostream& out );
   22529             :       static void readStaticDataFromFile (std::istream& in );
   22530             :       friend class SgIOItemExpression;
   22531             :    };
   22532             : /* #line 22533 "../../../src/frontend/SageIII//StorageClasses.h" */
   22533             : 
   22534             : 
   22535             : 
   22536             : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarStorageClassDeclatationMacros.macro" */
   22537             : /* 
   22538             :    JH (01/01/2006) ROSETTA generated class declarations for SgStatementExpressionStorageClass 
   22539             :    used for the ast file IO. Do not chance by hand! 
   22540             : */
   22541           0 : class SgStatementExpressionStorageClass  : public SgExpressionStorageClass
   22542             :    {
   22543             : 
   22544             :     protected: 
   22545             : 
   22546             : 
   22547             : /* #line 22548 "../../../src/frontend/SageIII//StorageClasses.h" */
   22548             : 
   22549             :      unsigned long storageOf_statement;
   22550             : 
   22551             : 
   22552             : /* #line 10 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarStorageClassDeclatationMacros.macro" */
   22553             : 
   22554             : 
   22555             :     public:
   22556             :       void pickOutIRNodeData ( SgStatementExpression* source );
   22557             :       static void arrangeStaticDataOfEasyStorageClassesInOneBlock ( );
   22558             :       static void deleteStaticDataOfEasyStorageClasses ( );
   22559             :       static void pickOutStaticDataMembers ( );
   22560             :       static void rebuildStaticDataMembers ( );
   22561             :       static void writeEasyStorageDataToFile (std::ostream& out);
   22562             :       static void readEasyStorageDataFromFile (std::istream& in);
   22563             :       static void writeStaticDataToFile (std::ostream& out );
   22564             :       static void readStaticDataFromFile (std::istream& in );
   22565             :       friend class SgStatementExpression;
   22566             :    };
   22567             : /* #line 22568 "../../../src/frontend/SageIII//StorageClasses.h" */
   22568             : 
   22569             : 
   22570             : 
   22571             : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarStorageClassDeclatationMacros.macro" */
   22572             : /* 
   22573             :    JH (01/01/2006) ROSETTA generated class declarations for SgAsmOpStorageClass 
   22574             :    used for the ast file IO. Do not chance by hand! 
   22575             : */
   22576           0 : class SgAsmOpStorageClass  : public SgExpressionStorageClass
   22577             :    {
   22578             : 
   22579             :     protected: 
   22580             : 
   22581             : 
   22582             : /* #line 22583 "../../../src/frontend/SageIII//StorageClasses.h" */
   22583             : 
   22584             :       SgAsmOp::asm_operand_constraint_enum storageOf_constraint;
   22585             :       SgAsmOp::asm_operand_modifier_enum storageOf_modifiers;
   22586             :      unsigned long storageOf_expression;
   22587             :       bool storageOf_recordRawAsmOperandDescriptions;
   22588             :       bool storageOf_isOutputOperand;
   22589             :        EasyStorage < std::string > storageOf_constraintString;
   22590             :        EasyStorage < std::string > storageOf_name;
   22591             : 
   22592             : 
   22593             : /* #line 10 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarStorageClassDeclatationMacros.macro" */
   22594             : 
   22595             : 
   22596             :     public:
   22597             :       void pickOutIRNodeData ( SgAsmOp* source );
   22598             :       static void arrangeStaticDataOfEasyStorageClassesInOneBlock ( );
   22599             :       static void deleteStaticDataOfEasyStorageClasses ( );
   22600             :       static void pickOutStaticDataMembers ( );
   22601             :       static void rebuildStaticDataMembers ( );
   22602             :       static void writeEasyStorageDataToFile (std::ostream& out);
   22603             :       static void readEasyStorageDataFromFile (std::istream& in);
   22604             :       static void writeStaticDataToFile (std::ostream& out );
   22605             :       static void readStaticDataFromFile (std::istream& in );
   22606             :       friend class SgAsmOp;
   22607             :    };
   22608             : /* #line 22609 "../../../src/frontend/SageIII//StorageClasses.h" */
   22609             : 
   22610             : 
   22611             : 
   22612             : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarStorageClassDeclatationMacros.macro" */
   22613             : /* 
   22614             :    JH (01/01/2006) ROSETTA generated class declarations for SgLabelRefExpStorageClass 
   22615             :    used for the ast file IO. Do not chance by hand! 
   22616             : */
   22617           0 : class SgLabelRefExpStorageClass  : public SgExpressionStorageClass
   22618             :    {
   22619             : 
   22620             :     protected: 
   22621             : 
   22622             : 
   22623             : /* #line 22624 "../../../src/frontend/SageIII//StorageClasses.h" */
   22624             : 
   22625             :      unsigned long storageOf_symbol;
   22626             : 
   22627             : 
   22628             : /* #line 10 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarStorageClassDeclatationMacros.macro" */
   22629             : 
   22630             : 
   22631             :     public:
   22632             :       void pickOutIRNodeData ( SgLabelRefExp* source );
   22633             :       static void arrangeStaticDataOfEasyStorageClassesInOneBlock ( );
   22634             :       static void deleteStaticDataOfEasyStorageClasses ( );
   22635             :       static void pickOutStaticDataMembers ( );
   22636             :       static void rebuildStaticDataMembers ( );
   22637             :       static void writeEasyStorageDataToFile (std::ostream& out);
   22638             :       static void readEasyStorageDataFromFile (std::istream& in);
   22639             :       static void writeStaticDataToFile (std::ostream& out );
   22640             :       static void readStaticDataFromFile (std::istream& in );
   22641             :       friend class SgLabelRefExp;
   22642             :    };
   22643             : /* #line 22644 "../../../src/frontend/SageIII//StorageClasses.h" */
   22644             : 
   22645             : 
   22646             : 
   22647             : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarStorageClassDeclatationMacros.macro" */
   22648             : /* 
   22649             :    JH (01/01/2006) ROSETTA generated class declarations for SgActualArgumentExpressionStorageClass 
   22650             :    used for the ast file IO. Do not chance by hand! 
   22651             : */
   22652           0 : class SgActualArgumentExpressionStorageClass  : public SgExpressionStorageClass
   22653             :    {
   22654             : 
   22655             :     protected: 
   22656             : 
   22657             : 
   22658             : /* #line 22659 "../../../src/frontend/SageIII//StorageClasses.h" */
   22659             : 
   22660             :       SgNameStorageClass storageOf_argument_name;
   22661             :      unsigned long storageOf_expression;
   22662             : 
   22663             : 
   22664             : /* #line 10 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarStorageClassDeclatationMacros.macro" */
   22665             : 
   22666             : 
   22667             :     public:
   22668             :       void pickOutIRNodeData ( SgActualArgumentExpression* source );
   22669             :       static void arrangeStaticDataOfEasyStorageClassesInOneBlock ( );
   22670             :       static void deleteStaticDataOfEasyStorageClasses ( );
   22671             :       static void pickOutStaticDataMembers ( );
   22672             :       static void rebuildStaticDataMembers ( );
   22673             :       static void writeEasyStorageDataToFile (std::ostream& out);
   22674             :       static void readEasyStorageDataFromFile (std::istream& in);
   22675             :       static void writeStaticDataToFile (std::ostream& out );
   22676             :       static void readStaticDataFromFile (std::istream& in );
   22677             :       friend class SgActualArgumentExpression;
   22678             :    };
   22679             : /* #line 22680 "../../../src/frontend/SageIII//StorageClasses.h" */
   22680             : 
   22681             : 
   22682             : 
   22683             : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarStorageClassDeclatationMacros.macro" */
   22684             : /* 
   22685             :    JH (01/01/2006) ROSETTA generated class declarations for SgUnknownArrayOrFunctionReferenceStorageClass 
   22686             :    used for the ast file IO. Do not chance by hand! 
   22687             : */
   22688           0 : class SgUnknownArrayOrFunctionReferenceStorageClass  : public SgExpressionStorageClass
   22689             :    {
   22690             : 
   22691             :     protected: 
   22692             : 
   22693             : 
   22694             : /* #line 22695 "../../../src/frontend/SageIII//StorageClasses.h" */
   22695             : 
   22696             :        EasyStorage < std::string > storageOf_name;
   22697             :      unsigned long storageOf_named_reference;
   22698             :      unsigned long storageOf_expression_list;
   22699             : 
   22700             : 
   22701             : /* #line 10 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarStorageClassDeclatationMacros.macro" */
   22702             : 
   22703             : 
   22704             :     public:
   22705             :       void pickOutIRNodeData ( SgUnknownArrayOrFunctionReference* source );
   22706             :       static void arrangeStaticDataOfEasyStorageClassesInOneBlock ( );
   22707             :       static void deleteStaticDataOfEasyStorageClasses ( );
   22708             :       static void pickOutStaticDataMembers ( );
   22709             :       static void rebuildStaticDataMembers ( );
   22710             :       static void writeEasyStorageDataToFile (std::ostream& out);
   22711             :       static void readEasyStorageDataFromFile (std::istream& in);
   22712             :       static void writeStaticDataToFile (std::ostream& out );
   22713             :       static void readStaticDataFromFile (std::istream& in );
   22714             :       friend class SgUnknownArrayOrFunctionReference;
   22715             :    };
   22716             : /* #line 22717 "../../../src/frontend/SageIII//StorageClasses.h" */
   22717             : 
   22718             : 
   22719             : 
   22720             : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarStorageClassDeclatationMacros.macro" */
   22721             : /* 
   22722             :    JH (01/01/2006) ROSETTA generated class declarations for SgPseudoDestructorRefExpStorageClass 
   22723             :    used for the ast file IO. Do not chance by hand! 
   22724             : */
   22725           0 : class SgPseudoDestructorRefExpStorageClass  : public SgExpressionStorageClass
   22726             :    {
   22727             : 
   22728             :     protected: 
   22729             : 
   22730             : 
   22731             : /* #line 22732 "../../../src/frontend/SageIII//StorageClasses.h" */
   22732             : 
   22733             :      unsigned long storageOf_object_type;
   22734             :      unsigned long storageOf_expression_type;
   22735             :       int storageOf_name_qualification_length;
   22736             :       bool storageOf_type_elaboration_required;
   22737             :       bool storageOf_global_qualification_required;
   22738             : 
   22739             : 
   22740             : /* #line 10 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarStorageClassDeclatationMacros.macro" */
   22741             : 
   22742             : 
   22743             :     public:
   22744             :       void pickOutIRNodeData ( SgPseudoDestructorRefExp* source );
   22745             :       static void arrangeStaticDataOfEasyStorageClassesInOneBlock ( );
   22746             :       static void deleteStaticDataOfEasyStorageClasses ( );
   22747             :       static void pickOutStaticDataMembers ( );
   22748             :       static void rebuildStaticDataMembers ( );
   22749             :       static void writeEasyStorageDataToFile (std::ostream& out);
   22750             :       static void readEasyStorageDataFromFile (std::istream& in);
   22751             :       static void writeStaticDataToFile (std::ostream& out );
   22752             :       static void readStaticDataFromFile (std::istream& in );
   22753             :       friend class SgPseudoDestructorRefExp;
   22754             :    };
   22755             : /* #line 22756 "../../../src/frontend/SageIII//StorageClasses.h" */
   22756             : 
   22757             : 
   22758             : 
   22759             : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarStorageClassDeclatationMacros.macro" */
   22760             : /* 
   22761             :    JH (01/01/2006) ROSETTA generated class declarations for SgCAFCoExpressionStorageClass 
   22762             :    used for the ast file IO. Do not chance by hand! 
   22763             : */
   22764           0 : class SgCAFCoExpressionStorageClass  : public SgExpressionStorageClass
   22765             :    {
   22766             : 
   22767             :     protected: 
   22768             : 
   22769             : 
   22770             : /* #line 22771 "../../../src/frontend/SageIII//StorageClasses.h" */
   22771             : 
   22772             :      unsigned long storageOf_teamId;
   22773             :      unsigned long storageOf_teamRank;
   22774             :      unsigned long storageOf_referData;
   22775             : 
   22776             : 
   22777             : /* #line 10 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarStorageClassDeclatationMacros.macro" */
   22778             : 
   22779             : 
   22780             :     public:
   22781             :       void pickOutIRNodeData ( SgCAFCoExpression* source );
   22782             :       static void arrangeStaticDataOfEasyStorageClassesInOneBlock ( );
   22783             :       static void deleteStaticDataOfEasyStorageClasses ( );
   22784             :       static void pickOutStaticDataMembers ( );
   22785             :       static void rebuildStaticDataMembers ( );
   22786             :       static void writeEasyStorageDataToFile (std::ostream& out);
   22787             :       static void readEasyStorageDataFromFile (std::istream& in);
   22788             :       static void writeStaticDataToFile (std::ostream& out );
   22789             :       static void readStaticDataFromFile (std::istream& in );
   22790             :       friend class SgCAFCoExpression;
   22791             :    };
   22792             : /* #line 22793 "../../../src/frontend/SageIII//StorageClasses.h" */
   22793             : 
   22794             : 
   22795             : 
   22796             : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarStorageClassDeclatationMacros.macro" */
   22797             : /* 
   22798             :    JH (01/01/2006) ROSETTA generated class declarations for SgCudaKernelExecConfigStorageClass 
   22799             :    used for the ast file IO. Do not chance by hand! 
   22800             : */
   22801           0 : class SgCudaKernelExecConfigStorageClass  : public SgExpressionStorageClass
   22802             :    {
   22803             : 
   22804             :     protected: 
   22805             : 
   22806             : 
   22807             : /* #line 22808 "../../../src/frontend/SageIII//StorageClasses.h" */
   22808             : 
   22809             :      unsigned long storageOf_grid;
   22810             :      unsigned long storageOf_blocks;
   22811             :      unsigned long storageOf_shared;
   22812             :      unsigned long storageOf_stream;
   22813             : 
   22814             : 
   22815             : /* #line 10 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarStorageClassDeclatationMacros.macro" */
   22816             : 
   22817             : 
   22818             :     public:
   22819             :       void pickOutIRNodeData ( SgCudaKernelExecConfig* source );
   22820             :       static void arrangeStaticDataOfEasyStorageClassesInOneBlock ( );
   22821             :       static void deleteStaticDataOfEasyStorageClasses ( );
   22822             :       static void pickOutStaticDataMembers ( );
   22823             :       static void rebuildStaticDataMembers ( );
   22824             :       static void writeEasyStorageDataToFile (std::ostream& out);
   22825             :       static void readEasyStorageDataFromFile (std::istream& in);
   22826             :       static void writeStaticDataToFile (std::ostream& out );
   22827             :       static void readStaticDataFromFile (std::istream& in );
   22828             :       friend class SgCudaKernelExecConfig;
   22829             :    };
   22830             : /* #line 22831 "../../../src/frontend/SageIII//StorageClasses.h" */
   22831             : 
   22832             : 
   22833             : 
   22834             : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarStorageClassDeclatationMacros.macro" */
   22835             : /* 
   22836             :    JH (01/01/2006) ROSETTA generated class declarations for SgLambdaRefExpStorageClass 
   22837             :    used for the ast file IO. Do not chance by hand! 
   22838             : */
   22839           0 : class SgLambdaRefExpStorageClass  : public SgExpressionStorageClass
   22840             :    {
   22841             : 
   22842             :     protected: 
   22843             : 
   22844             : 
   22845             : /* #line 22846 "../../../src/frontend/SageIII//StorageClasses.h" */
   22846             : 
   22847             :      unsigned long storageOf_functionDeclaration;
   22848             : 
   22849             : 
   22850             : /* #line 10 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarStorageClassDeclatationMacros.macro" */
   22851             : 
   22852             : 
   22853             :     public:
   22854             :       void pickOutIRNodeData ( SgLambdaRefExp* source );
   22855             :       static void arrangeStaticDataOfEasyStorageClassesInOneBlock ( );
   22856             :       static void deleteStaticDataOfEasyStorageClasses ( );
   22857             :       static void pickOutStaticDataMembers ( );
   22858             :       static void rebuildStaticDataMembers ( );
   22859             :       static void writeEasyStorageDataToFile (std::ostream& out);
   22860             :       static void readEasyStorageDataFromFile (std::istream& in);
   22861             :       static void writeStaticDataToFile (std::ostream& out );
   22862             :       static void readStaticDataFromFile (std::istream& in );
   22863             :       friend class SgLambdaRefExp;
   22864             :    };
   22865             : /* #line 22866 "../../../src/frontend/SageIII//StorageClasses.h" */
   22866             : 
   22867             : 
   22868             : 
   22869             : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarStorageClassDeclatationMacros.macro" */
   22870             : /* 
   22871             :    JH (01/01/2006) ROSETTA generated class declarations for SgDictionaryExpStorageClass 
   22872             :    used for the ast file IO. Do not chance by hand! 
   22873             : */
   22874           0 : class SgDictionaryExpStorageClass  : public SgExpressionStorageClass
   22875             :    {
   22876             : 
   22877             :     protected: 
   22878             : 
   22879             : 
   22880             : /* #line 22881 "../../../src/frontend/SageIII//StorageClasses.h" */
   22881             : 
   22882             :        EasyStorage < SgKeyDatumPairPtrList > storageOf_key_datum_pairs;
   22883             : 
   22884             : 
   22885             : /* #line 10 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarStorageClassDeclatationMacros.macro" */
   22886             : 
   22887             : 
   22888             :     public:
   22889             :       void pickOutIRNodeData ( SgDictionaryExp* source );
   22890             :       static void arrangeStaticDataOfEasyStorageClassesInOneBlock ( );
   22891             :       static void deleteStaticDataOfEasyStorageClasses ( );
   22892             :       static void pickOutStaticDataMembers ( );
   22893             :       static void rebuildStaticDataMembers ( );
   22894             :       static void writeEasyStorageDataToFile (std::ostream& out);
   22895             :       static void readEasyStorageDataFromFile (std::istream& in);
   22896             :       static void writeStaticDataToFile (std::ostream& out );
   22897             :       static void readStaticDataFromFile (std::istream& in );
   22898             :       friend class SgDictionaryExp;
   22899             :    };
   22900             : /* #line 22901 "../../../src/frontend/SageIII//StorageClasses.h" */
   22901             : 
   22902             : 
   22903             : 
   22904             : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarStorageClassDeclatationMacros.macro" */
   22905             : /* 
   22906             :    JH (01/01/2006) ROSETTA generated class declarations for SgKeyDatumPairStorageClass 
   22907             :    used for the ast file IO. Do not chance by hand! 
   22908             : */
   22909           0 : class SgKeyDatumPairStorageClass  : public SgExpressionStorageClass
   22910             :    {
   22911             : 
   22912             :     protected: 
   22913             : 
   22914             : 
   22915             : /* #line 22916 "../../../src/frontend/SageIII//StorageClasses.h" */
   22916             : 
   22917             :      unsigned long storageOf_key;
   22918             :      unsigned long storageOf_datum;
   22919             : 
   22920             : 
   22921             : /* #line 10 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarStorageClassDeclatationMacros.macro" */
   22922             : 
   22923             : 
   22924             :     public:
   22925             :       void pickOutIRNodeData ( SgKeyDatumPair* source );
   22926             :       static void arrangeStaticDataOfEasyStorageClassesInOneBlock ( );
   22927             :       static void deleteStaticDataOfEasyStorageClasses ( );
   22928             :       static void pickOutStaticDataMembers ( );
   22929             :       static void rebuildStaticDataMembers ( );
   22930             :       static void writeEasyStorageDataToFile (std::ostream& out);
   22931             :       static void readEasyStorageDataFromFile (std::istream& in);
   22932             :       static void writeStaticDataToFile (std::ostream& out );
   22933             :       static void readStaticDataFromFile (std::istream& in );
   22934             :       friend class SgKeyDatumPair;
   22935             :    };
   22936             : /* #line 22937 "../../../src/frontend/SageIII//StorageClasses.h" */
   22937             : 
   22938             : 
   22939             : 
   22940             : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarStorageClassDeclatationMacros.macro" */
   22941             : /* 
   22942             :    JH (01/01/2006) ROSETTA generated class declarations for SgComprehensionStorageClass 
   22943             :    used for the ast file IO. Do not chance by hand! 
   22944             : */
   22945           0 : class SgComprehensionStorageClass  : public SgExpressionStorageClass
   22946             :    {
   22947             : 
   22948             :     protected: 
   22949             : 
   22950             : 
   22951             : /* #line 22952 "../../../src/frontend/SageIII//StorageClasses.h" */
   22952             : 
   22953             :      unsigned long storageOf_target;
   22954             :      unsigned long storageOf_iter;
   22955             :      unsigned long storageOf_filters;
   22956             : 
   22957             : 
   22958             : /* #line 10 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarStorageClassDeclatationMacros.macro" */
   22959             : 
   22960             : 
   22961             :     public:
   22962             :       void pickOutIRNodeData ( SgComprehension* source );
   22963             :       static void arrangeStaticDataOfEasyStorageClassesInOneBlock ( );
   22964             :       static void deleteStaticDataOfEasyStorageClasses ( );
   22965             :       static void pickOutStaticDataMembers ( );
   22966             :       static void rebuildStaticDataMembers ( );
   22967             :       static void writeEasyStorageDataToFile (std::ostream& out);
   22968             :       static void readEasyStorageDataFromFile (std::istream& in);
   22969             :       static void writeStaticDataToFile (std::ostream& out );
   22970             :       static void readStaticDataFromFile (std::istream& in );
   22971             :       friend class SgComprehension;
   22972             :    };
   22973             : /* #line 22974 "../../../src/frontend/SageIII//StorageClasses.h" */
   22974             : 
   22975             : 
   22976             : 
   22977             : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarStorageClassDeclatationMacros.macro" */
   22978             : /* 
   22979             :    JH (01/01/2006) ROSETTA generated class declarations for SgListComprehensionStorageClass 
   22980             :    used for the ast file IO. Do not chance by hand! 
   22981             : */
   22982           0 : class SgListComprehensionStorageClass  : public SgExpressionStorageClass
   22983             :    {
   22984             : 
   22985             :     protected: 
   22986             : 
   22987             : 
   22988             : /* #line 22989 "../../../src/frontend/SageIII//StorageClasses.h" */
   22989             : 
   22990             :      unsigned long storageOf_element;
   22991             :      unsigned long storageOf_generators;
   22992             : 
   22993             : 
   22994             : /* #line 10 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarStorageClassDeclatationMacros.macro" */
   22995             : 
   22996             : 
   22997             :     public:
   22998             :       void pickOutIRNodeData ( SgListComprehension* source );
   22999             :       static void arrangeStaticDataOfEasyStorageClassesInOneBlock ( );
   23000             :       static void deleteStaticDataOfEasyStorageClasses ( );
   23001             :       static void pickOutStaticDataMembers ( );
   23002             :       static void rebuildStaticDataMembers ( );
   23003             :       static void writeEasyStorageDataToFile (std::ostream& out);
   23004             :       static void readEasyStorageDataFromFile (std::istream& in);
   23005             :       static void writeStaticDataToFile (std::ostream& out );
   23006             :       static void readStaticDataFromFile (std::istream& in );
   23007             :       friend class SgListComprehension;
   23008             :    };
   23009             : /* #line 23010 "../../../src/frontend/SageIII//StorageClasses.h" */
   23010             : 
   23011             : 
   23012             : 
   23013             : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarStorageClassDeclatationMacros.macro" */
   23014             : /* 
   23015             :    JH (01/01/2006) ROSETTA generated class declarations for SgSetComprehensionStorageClass 
   23016             :    used for the ast file IO. Do not chance by hand! 
   23017             : */
   23018           0 : class SgSetComprehensionStorageClass  : public SgExpressionStorageClass
   23019             :    {
   23020             : 
   23021             :     protected: 
   23022             : 
   23023             : 
   23024             : /* #line 23025 "../../../src/frontend/SageIII//StorageClasses.h" */
   23025             : 
   23026             :      unsigned long storageOf_element;
   23027             :      unsigned long storageOf_generators;
   23028             : 
   23029             : 
   23030             : /* #line 10 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarStorageClassDeclatationMacros.macro" */
   23031             : 
   23032             : 
   23033             :     public:
   23034             :       void pickOutIRNodeData ( SgSetComprehension* source );
   23035             :       static void arrangeStaticDataOfEasyStorageClassesInOneBlock ( );
   23036             :       static void deleteStaticDataOfEasyStorageClasses ( );
   23037             :       static void pickOutStaticDataMembers ( );
   23038             :       static void rebuildStaticDataMembers ( );
   23039             :       static void writeEasyStorageDataToFile (std::ostream& out);
   23040             :       static void readEasyStorageDataFromFile (std::istream& in);
   23041             :       static void writeStaticDataToFile (std::ostream& out );
   23042             :       static void readStaticDataFromFile (std::istream& in );
   23043             :       friend class SgSetComprehension;
   23044             :    };
   23045             : /* #line 23046 "../../../src/frontend/SageIII//StorageClasses.h" */
   23046             : 
   23047             : 
   23048             : 
   23049             : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarStorageClassDeclatationMacros.macro" */
   23050             : /* 
   23051             :    JH (01/01/2006) ROSETTA generated class declarations for SgDictionaryComprehensionStorageClass 
   23052             :    used for the ast file IO. Do not chance by hand! 
   23053             : */
   23054           0 : class SgDictionaryComprehensionStorageClass  : public SgExpressionStorageClass
   23055             :    {
   23056             : 
   23057             :     protected: 
   23058             : 
   23059             : 
   23060             : /* #line 23061 "../../../src/frontend/SageIII//StorageClasses.h" */
   23061             : 
   23062             :      unsigned long storageOf_element;
   23063             :      unsigned long storageOf_generators;
   23064             : 
   23065             : 
   23066             : /* #line 10 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarStorageClassDeclatationMacros.macro" */
   23067             : 
   23068             : 
   23069             :     public:
   23070             :       void pickOutIRNodeData ( SgDictionaryComprehension* source );
   23071             :       static void arrangeStaticDataOfEasyStorageClassesInOneBlock ( );
   23072             :       static void deleteStaticDataOfEasyStorageClasses ( );
   23073             :       static void pickOutStaticDataMembers ( );
   23074             :       static void rebuildStaticDataMembers ( );
   23075             :       static void writeEasyStorageDataToFile (std::ostream& out);
   23076             :       static void readEasyStorageDataFromFile (std::istream& in);
   23077             :       static void writeStaticDataToFile (std::ostream& out );
   23078             :       static void readStaticDataFromFile (std::istream& in );
   23079             :       friend class SgDictionaryComprehension;
   23080             :    };
   23081             : /* #line 23082 "../../../src/frontend/SageIII//StorageClasses.h" */
   23082             : 
   23083             : 
   23084             : 
   23085             : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarStorageClassDeclatationMacros.macro" */
   23086             : /* 
   23087             :    JH (01/01/2006) ROSETTA generated class declarations for SgNaryOpStorageClass 
   23088             :    used for the ast file IO. Do not chance by hand! 
   23089             : */
   23090           0 : class SgNaryOpStorageClass  : public SgExpressionStorageClass
   23091             :    {
   23092             : 
   23093             :     protected: 
   23094             : 
   23095             : 
   23096             : /* #line 23097 "../../../src/frontend/SageIII//StorageClasses.h" */
   23097             : 
   23098             :        EasyStorage < SgExpressionPtrList > storageOf_operands;
   23099             :        EasyStorage < VariantTList > storageOf_operators;
   23100             : 
   23101             : 
   23102             : /* #line 10 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarStorageClassDeclatationMacros.macro" */
   23103             : 
   23104             : 
   23105             :     public:
   23106             :       void pickOutIRNodeData ( SgNaryOp* source );
   23107             :       static void arrangeStaticDataOfEasyStorageClassesInOneBlock ( );
   23108             :       static void deleteStaticDataOfEasyStorageClasses ( );
   23109             :       static void pickOutStaticDataMembers ( );
   23110             :       static void rebuildStaticDataMembers ( );
   23111             :       static void writeEasyStorageDataToFile (std::ostream& out);
   23112             :       static void readEasyStorageDataFromFile (std::istream& in);
   23113             :       static void writeStaticDataToFile (std::ostream& out );
   23114             :       static void readStaticDataFromFile (std::istream& in );
   23115             :       friend class SgNaryOp;
   23116             :    };
   23117             : /* #line 23118 "../../../src/frontend/SageIII//StorageClasses.h" */
   23118             : 
   23119             : 
   23120             : 
   23121             : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarStorageClassDeclatationMacros.macro" */
   23122             : /* 
   23123             :    JH (01/01/2006) ROSETTA generated class declarations for SgNaryBooleanOpStorageClass 
   23124             :    used for the ast file IO. Do not chance by hand! 
   23125             : */
   23126           0 : class SgNaryBooleanOpStorageClass  : public SgNaryOpStorageClass
   23127             :    {
   23128             : 
   23129             :     protected: 
   23130             : 
   23131             : 
   23132             : /* #line 23133 "../../../src/frontend/SageIII//StorageClasses.h" */
   23133             : 
   23134             : 
   23135             : 
   23136             : /* #line 10 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarStorageClassDeclatationMacros.macro" */
   23137             : 
   23138             : 
   23139             :     public:
   23140             :       void pickOutIRNodeData ( SgNaryBooleanOp* source );
   23141             :       static void arrangeStaticDataOfEasyStorageClassesInOneBlock ( );
   23142             :       static void deleteStaticDataOfEasyStorageClasses ( );
   23143             :       static void pickOutStaticDataMembers ( );
   23144             :       static void rebuildStaticDataMembers ( );
   23145             :       static void writeEasyStorageDataToFile (std::ostream& out);
   23146             :       static void readEasyStorageDataFromFile (std::istream& in);
   23147             :       static void writeStaticDataToFile (std::ostream& out );
   23148             :       static void readStaticDataFromFile (std::istream& in );
   23149             :       friend class SgNaryBooleanOp;
   23150             :    };
   23151             : /* #line 23152 "../../../src/frontend/SageIII//StorageClasses.h" */
   23152             : 
   23153             : 
   23154             : 
   23155             : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarStorageClassDeclatationMacros.macro" */
   23156             : /* 
   23157             :    JH (01/01/2006) ROSETTA generated class declarations for SgNaryComparisonOpStorageClass 
   23158             :    used for the ast file IO. Do not chance by hand! 
   23159             : */
   23160           0 : class SgNaryComparisonOpStorageClass  : public SgNaryOpStorageClass
   23161             :    {
   23162             : 
   23163             :     protected: 
   23164             : 
   23165             : 
   23166             : /* #line 23167 "../../../src/frontend/SageIII//StorageClasses.h" */
   23167             : 
   23168             : 
   23169             : 
   23170             : /* #line 10 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarStorageClassDeclatationMacros.macro" */
   23171             : 
   23172             : 
   23173             :     public:
   23174             :       void pickOutIRNodeData ( SgNaryComparisonOp* source );
   23175             :       static void arrangeStaticDataOfEasyStorageClassesInOneBlock ( );
   23176             :       static void deleteStaticDataOfEasyStorageClasses ( );
   23177             :       static void pickOutStaticDataMembers ( );
   23178             :       static void rebuildStaticDataMembers ( );
   23179             :       static void writeEasyStorageDataToFile (std::ostream& out);
   23180             :       static void readEasyStorageDataFromFile (std::istream& in);
   23181             :       static void writeStaticDataToFile (std::ostream& out );
   23182             :       static void readStaticDataFromFile (std::istream& in );
   23183             :       friend class SgNaryComparisonOp;
   23184             :    };
   23185             : /* #line 23186 "../../../src/frontend/SageIII//StorageClasses.h" */
   23186             : 
   23187             : 
   23188             : 
   23189             : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarStorageClassDeclatationMacros.macro" */
   23190             : /* 
   23191             :    JH (01/01/2006) ROSETTA generated class declarations for SgStringConversionStorageClass 
   23192             :    used for the ast file IO. Do not chance by hand! 
   23193             : */
   23194           0 : class SgStringConversionStorageClass  : public SgExpressionStorageClass
   23195             :    {
   23196             : 
   23197             :     protected: 
   23198             : 
   23199             : 
   23200             : /* #line 23201 "../../../src/frontend/SageIII//StorageClasses.h" */
   23201             : 
   23202             :      unsigned long storageOf_expression;
   23203             : 
   23204             : 
   23205             : /* #line 10 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarStorageClassDeclatationMacros.macro" */
   23206             : 
   23207             : 
   23208             :     public:
   23209             :       void pickOutIRNodeData ( SgStringConversion* source );
   23210             :       static void arrangeStaticDataOfEasyStorageClassesInOneBlock ( );
   23211             :       static void deleteStaticDataOfEasyStorageClasses ( );
   23212             :       static void pickOutStaticDataMembers ( );
   23213             :       static void rebuildStaticDataMembers ( );
   23214             :       static void writeEasyStorageDataToFile (std::ostream& out);
   23215             :       static void readEasyStorageDataFromFile (std::istream& in);
   23216             :       static void writeStaticDataToFile (std::ostream& out );
   23217             :       static void readStaticDataFromFile (std::istream& in );
   23218             :       friend class SgStringConversion;
   23219             :    };
   23220             : /* #line 23221 "../../../src/frontend/SageIII//StorageClasses.h" */
   23221             : 
   23222             : 
   23223             : 
   23224             : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarStorageClassDeclatationMacros.macro" */
   23225             : /* 
   23226             :    JH (01/01/2006) ROSETTA generated class declarations for SgYieldExpressionStorageClass 
   23227             :    used for the ast file IO. Do not chance by hand! 
   23228             : */
   23229           0 : class SgYieldExpressionStorageClass  : public SgExpressionStorageClass
   23230             :    {
   23231             : 
   23232             :     protected: 
   23233             : 
   23234             : 
   23235             : /* #line 23236 "../../../src/frontend/SageIII//StorageClasses.h" */
   23236             : 
   23237             :      unsigned long storageOf_value;
   23238             : 
   23239             : 
   23240             : /* #line 10 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarStorageClassDeclatationMacros.macro" */
   23241             : 
   23242             : 
   23243             :     public:
   23244             :       void pickOutIRNodeData ( SgYieldExpression* source );
   23245             :       static void arrangeStaticDataOfEasyStorageClassesInOneBlock ( );
   23246             :       static void deleteStaticDataOfEasyStorageClasses ( );
   23247             :       static void pickOutStaticDataMembers ( );
   23248             :       static void rebuildStaticDataMembers ( );
   23249             :       static void writeEasyStorageDataToFile (std::ostream& out);
   23250             :       static void readEasyStorageDataFromFile (std::istream& in);
   23251             :       static void writeStaticDataToFile (std::ostream& out );
   23252             :       static void readStaticDataFromFile (std::istream& in );
   23253             :       friend class SgYieldExpression;
   23254             :    };
   23255             : /* #line 23256 "../../../src/frontend/SageIII//StorageClasses.h" */
   23256             : 
   23257             : 
   23258             : 
   23259             : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarStorageClassDeclatationMacros.macro" */
   23260             : /* 
   23261             :    JH (01/01/2006) ROSETTA generated class declarations for SgTemplateFunctionRefExpStorageClass 
   23262             :    used for the ast file IO. Do not chance by hand! 
   23263             : */
   23264         450 : class SgTemplateFunctionRefExpStorageClass  : public SgExpressionStorageClass
   23265             :    {
   23266             : 
   23267             :     protected: 
   23268             : 
   23269             : 
   23270             : /* #line 23271 "../../../src/frontend/SageIII//StorageClasses.h" */
   23271             : 
   23272             :      unsigned long storageOf_symbol_i;
   23273             :       int storageOf_name_qualification_length;
   23274             :       bool storageOf_type_elaboration_required;
   23275             :       bool storageOf_global_qualification_required;
   23276             : 
   23277             : 
   23278             : /* #line 10 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarStorageClassDeclatationMacros.macro" */
   23279             : 
   23280             : 
   23281             :     public:
   23282             :       void pickOutIRNodeData ( SgTemplateFunctionRefExp* source );
   23283             :       static void arrangeStaticDataOfEasyStorageClassesInOneBlock ( );
   23284             :       static void deleteStaticDataOfEasyStorageClasses ( );
   23285             :       static void pickOutStaticDataMembers ( );
   23286             :       static void rebuildStaticDataMembers ( );
   23287             :       static void writeEasyStorageDataToFile (std::ostream& out);
   23288             :       static void readEasyStorageDataFromFile (std::istream& in);
   23289             :       static void writeStaticDataToFile (std::ostream& out );
   23290             :       static void readStaticDataFromFile (std::istream& in );
   23291             :       friend class SgTemplateFunctionRefExp;
   23292             :    };
   23293             : /* #line 23294 "../../../src/frontend/SageIII//StorageClasses.h" */
   23294             : 
   23295             : 
   23296             : 
   23297             : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarStorageClassDeclatationMacros.macro" */
   23298             : /* 
   23299             :    JH (01/01/2006) ROSETTA generated class declarations for SgTemplateMemberFunctionRefExpStorageClass 
   23300             :    used for the ast file IO. Do not chance by hand! 
   23301             : */
   23302        1476 : class SgTemplateMemberFunctionRefExpStorageClass  : public SgExpressionStorageClass
   23303             :    {
   23304             : 
   23305             :     protected: 
   23306             : 
   23307             : 
   23308             : /* #line 23309 "../../../src/frontend/SageIII//StorageClasses.h" */
   23309             : 
   23310             :      unsigned long storageOf_symbol_i;
   23311             :       int storageOf_virtual_call;
   23312             :       int storageOf_need_qualifier;
   23313             :       int storageOf_name_qualification_length;
   23314             :       bool storageOf_type_elaboration_required;
   23315             :       bool storageOf_global_qualification_required;
   23316             : 
   23317             : 
   23318             : /* #line 10 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarStorageClassDeclatationMacros.macro" */
   23319             : 
   23320             : 
   23321             :     public:
   23322             :       void pickOutIRNodeData ( SgTemplateMemberFunctionRefExp* source );
   23323             :       static void arrangeStaticDataOfEasyStorageClassesInOneBlock ( );
   23324             :       static void deleteStaticDataOfEasyStorageClasses ( );
   23325             :       static void pickOutStaticDataMembers ( );
   23326             :       static void rebuildStaticDataMembers ( );
   23327             :       static void writeEasyStorageDataToFile (std::ostream& out);
   23328             :       static void readEasyStorageDataFromFile (std::istream& in);
   23329             :       static void writeStaticDataToFile (std::ostream& out );
   23330             :       static void readStaticDataFromFile (std::istream& in );
   23331             :       friend class SgTemplateMemberFunctionRefExp;
   23332             :    };
   23333             : /* #line 23334 "../../../src/frontend/SageIII//StorageClasses.h" */
   23334             : 
   23335             : 
   23336             : 
   23337             : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarStorageClassDeclatationMacros.macro" */
   23338             : /* 
   23339             :    JH (01/01/2006) ROSETTA generated class declarations for SgAlignOfOpStorageClass 
   23340             :    used for the ast file IO. Do not chance by hand! 
   23341             : */
   23342          10 : class SgAlignOfOpStorageClass  : public SgExpressionStorageClass
   23343             :    {
   23344             : 
   23345             :     protected: 
   23346             : 
   23347             : 
   23348             : /* #line 23349 "../../../src/frontend/SageIII//StorageClasses.h" */
   23349             : 
   23350             :      unsigned long storageOf_operand_expr;
   23351             :      unsigned long storageOf_operand_type;
   23352             :      unsigned long storageOf_expression_type;
   23353             :       int storageOf_name_qualification_length;
   23354             :       bool storageOf_type_elaboration_required;
   23355             :       bool storageOf_global_qualification_required;
   23356             :       bool storageOf_alignOfContainsBaseTypeDefiningDeclaration;
   23357             : 
   23358             : 
   23359             : /* #line 10 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarStorageClassDeclatationMacros.macro" */
   23360             : 
   23361             : 
   23362             :     public:
   23363             :       void pickOutIRNodeData ( SgAlignOfOp* source );
   23364             :       static void arrangeStaticDataOfEasyStorageClassesInOneBlock ( );
   23365             :       static void deleteStaticDataOfEasyStorageClasses ( );
   23366             :       static void pickOutStaticDataMembers ( );
   23367             :       static void rebuildStaticDataMembers ( );
   23368             :       static void writeEasyStorageDataToFile (std::ostream& out);
   23369             :       static void readEasyStorageDataFromFile (std::istream& in);
   23370             :       static void writeStaticDataToFile (std::ostream& out );
   23371             :       static void readStaticDataFromFile (std::istream& in );
   23372             :       friend class SgAlignOfOp;
   23373             :    };
   23374             : /* #line 23375 "../../../src/frontend/SageIII//StorageClasses.h" */
   23375             : 
   23376             : 
   23377             : 
   23378             : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarStorageClassDeclatationMacros.macro" */
   23379             : /* 
   23380             :    JH (01/01/2006) ROSETTA generated class declarations for SgRangeExpStorageClass 
   23381             :    used for the ast file IO. Do not chance by hand! 
   23382             : */
   23383           0 : class SgRangeExpStorageClass  : public SgExpressionStorageClass
   23384             :    {
   23385             : 
   23386             :     protected: 
   23387             : 
   23388             : 
   23389             : /* #line 23390 "../../../src/frontend/SageIII//StorageClasses.h" */
   23390             : 
   23391             :      unsigned long storageOf_start;
   23392             :      unsigned long storageOf_end;
   23393             :      unsigned long storageOf_stride;
   23394             : 
   23395             : 
   23396             : /* #line 10 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarStorageClassDeclatationMacros.macro" */
   23397             : 
   23398             : 
   23399             :     public:
   23400             :       void pickOutIRNodeData ( SgRangeExp* source );
   23401             :       static void arrangeStaticDataOfEasyStorageClassesInOneBlock ( );
   23402             :       static void deleteStaticDataOfEasyStorageClasses ( );
   23403             :       static void pickOutStaticDataMembers ( );
   23404             :       static void rebuildStaticDataMembers ( );
   23405             :       static void writeEasyStorageDataToFile (std::ostream& out);
   23406             :       static void readEasyStorageDataFromFile (std::istream& in);
   23407             :       static void writeStaticDataToFile (std::ostream& out );
   23408             :       static void readStaticDataFromFile (std::istream& in );
   23409             :       friend class SgRangeExp;
   23410             :    };
   23411             : /* #line 23412 "../../../src/frontend/SageIII//StorageClasses.h" */
   23412             : 
   23413             : 
   23414             : 
   23415             : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarStorageClassDeclatationMacros.macro" */
   23416             : /* 
   23417             :    JH (01/01/2006) ROSETTA generated class declarations for SgMagicColonExpStorageClass 
   23418             :    used for the ast file IO. Do not chance by hand! 
   23419             : */
   23420           0 : class SgMagicColonExpStorageClass  : public SgExpressionStorageClass
   23421             :    {
   23422             : 
   23423             :     protected: 
   23424             : 
   23425             : 
   23426             : /* #line 23427 "../../../src/frontend/SageIII//StorageClasses.h" */
   23427             : 
   23428             : 
   23429             : 
   23430             : /* #line 10 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarStorageClassDeclatationMacros.macro" */
   23431             : 
   23432             : 
   23433             :     public:
   23434             :       void pickOutIRNodeData ( SgMagicColonExp* source );
   23435             :       static void arrangeStaticDataOfEasyStorageClassesInOneBlock ( );
   23436             :       static void deleteStaticDataOfEasyStorageClasses ( );
   23437             :       static void pickOutStaticDataMembers ( );
   23438             :       static void rebuildStaticDataMembers ( );
   23439             :       static void writeEasyStorageDataToFile (std::ostream& out);
   23440             :       static void readEasyStorageDataFromFile (std::istream& in);
   23441             :       static void writeStaticDataToFile (std::ostream& out );
   23442             :       static void readStaticDataFromFile (std::istream& in );
   23443             :       friend class SgMagicColonExp;
   23444             :    };
   23445             : /* #line 23446 "../../../src/frontend/SageIII//StorageClasses.h" */
   23446             : 
   23447             : 
   23448             : 
   23449             : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarStorageClassDeclatationMacros.macro" */
   23450             : /* 
   23451             :    JH (01/01/2006) ROSETTA generated class declarations for SgTypeTraitBuiltinOperatorStorageClass 
   23452             :    used for the ast file IO. Do not chance by hand! 
   23453             : */
   23454          84 : class SgTypeTraitBuiltinOperatorStorageClass  : public SgExpressionStorageClass
   23455             :    {
   23456             : 
   23457             :     protected: 
   23458             : 
   23459             : 
   23460             : /* #line 23461 "../../../src/frontend/SageIII//StorageClasses.h" */
   23461             : 
   23462             :       SgNameStorageClass storageOf_name;
   23463             :        EasyStorage < SgNodePtrList > storageOf_args;
   23464             : 
   23465             : 
   23466             : /* #line 10 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarStorageClassDeclatationMacros.macro" */
   23467             : 
   23468             : 
   23469             :     public:
   23470             :       void pickOutIRNodeData ( SgTypeTraitBuiltinOperator* source );
   23471             :       static void arrangeStaticDataOfEasyStorageClassesInOneBlock ( );
   23472             :       static void deleteStaticDataOfEasyStorageClasses ( );
   23473             :       static void pickOutStaticDataMembers ( );
   23474             :       static void rebuildStaticDataMembers ( );
   23475             :       static void writeEasyStorageDataToFile (std::ostream& out);
   23476             :       static void readEasyStorageDataFromFile (std::istream& in);
   23477             :       static void writeStaticDataToFile (std::ostream& out );
   23478             :       static void readStaticDataFromFile (std::istream& in );
   23479             :       friend class SgTypeTraitBuiltinOperator;
   23480             :    };
   23481             : /* #line 23482 "../../../src/frontend/SageIII//StorageClasses.h" */
   23482             : 
   23483             : 
   23484             : 
   23485             : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarStorageClassDeclatationMacros.macro" */
   23486             : /* 
   23487             :    JH (01/01/2006) ROSETTA generated class declarations for SgCompoundLiteralExpStorageClass 
   23488             :    used for the ast file IO. Do not chance by hand! 
   23489             : */
   23490           0 : class SgCompoundLiteralExpStorageClass  : public SgExpressionStorageClass
   23491             :    {
   23492             : 
   23493             :     protected: 
   23494             : 
   23495             : 
   23496             : /* #line 23497 "../../../src/frontend/SageIII//StorageClasses.h" */
   23497             : 
   23498             :      unsigned long storageOf_symbol;
   23499             : 
   23500             : 
   23501             : /* #line 10 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarStorageClassDeclatationMacros.macro" */
   23502             : 
   23503             : 
   23504             :     public:
   23505             :       void pickOutIRNodeData ( SgCompoundLiteralExp* source );
   23506             :       static void arrangeStaticDataOfEasyStorageClassesInOneBlock ( );
   23507             :       static void deleteStaticDataOfEasyStorageClasses ( );
   23508             :       static void pickOutStaticDataMembers ( );
   23509             :       static void rebuildStaticDataMembers ( );
   23510             :       static void writeEasyStorageDataToFile (std::ostream& out);
   23511             :       static void readEasyStorageDataFromFile (std::istream& in);
   23512             :       static void writeStaticDataToFile (std::ostream& out );
   23513             :       static void readStaticDataFromFile (std::istream& in );
   23514             :       friend class SgCompoundLiteralExp;
   23515             :    };
   23516             : /* #line 23517 "../../../src/frontend/SageIII//StorageClasses.h" */
   23517             : 
   23518             : 
   23519             : 
   23520             : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarStorageClassDeclatationMacros.macro" */
   23521             : /* 
   23522             :    JH (01/01/2006) ROSETTA generated class declarations for SgTypeExpressionStorageClass 
   23523             :    used for the ast file IO. Do not chance by hand! 
   23524             : */
   23525           0 : class SgTypeExpressionStorageClass  : public SgExpressionStorageClass
   23526             :    {
   23527             : 
   23528             :     protected: 
   23529             : 
   23530             : 
   23531             : /* #line 23532 "../../../src/frontend/SageIII//StorageClasses.h" */
   23532             : 
   23533             :      unsigned long storageOf_type;
   23534             : 
   23535             : 
   23536             : /* #line 10 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarStorageClassDeclatationMacros.macro" */
   23537             : 
   23538             : 
   23539             :     public:
   23540             :       void pickOutIRNodeData ( SgTypeExpression* source );
   23541             :       static void arrangeStaticDataOfEasyStorageClassesInOneBlock ( );
   23542             :       static void deleteStaticDataOfEasyStorageClasses ( );
   23543             :       static void pickOutStaticDataMembers ( );
   23544             :       static void rebuildStaticDataMembers ( );
   23545             :       static void writeEasyStorageDataToFile (std::ostream& out);
   23546             :       static void readEasyStorageDataFromFile (std::istream& in);
   23547             :       static void writeStaticDataToFile (std::ostream& out );
   23548             :       static void readStaticDataFromFile (std::istream& in );
   23549             :       friend class SgTypeExpression;
   23550             :    };
   23551             : /* #line 23552 "../../../src/frontend/SageIII//StorageClasses.h" */
   23552             : 
   23553             : 
   23554             : 
   23555             : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarStorageClassDeclatationMacros.macro" */
   23556             : /* 
   23557             :    JH (01/01/2006) ROSETTA generated class declarations for SgClassExpStorageClass 
   23558             :    used for the ast file IO. Do not chance by hand! 
   23559             : */
   23560           0 : class SgClassExpStorageClass  : public SgExpressionStorageClass
   23561             :    {
   23562             : 
   23563             :     protected: 
   23564             : 
   23565             : 
   23566             : /* #line 23567 "../../../src/frontend/SageIII//StorageClasses.h" */
   23567             : 
   23568             :      unsigned long storageOf_class_symbol;
   23569             :       int storageOf_pobj_class;
   23570             : 
   23571             : 
   23572             : /* #line 10 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarStorageClassDeclatationMacros.macro" */
   23573             : 
   23574             : 
   23575             :     public:
   23576             :       void pickOutIRNodeData ( SgClassExp* source );
   23577             :       static void arrangeStaticDataOfEasyStorageClassesInOneBlock ( );
   23578             :       static void deleteStaticDataOfEasyStorageClasses ( );
   23579             :       static void pickOutStaticDataMembers ( );
   23580             :       static void rebuildStaticDataMembers ( );
   23581             :       static void writeEasyStorageDataToFile (std::ostream& out);
   23582             :       static void readEasyStorageDataFromFile (std::istream& in);
   23583             :       static void writeStaticDataToFile (std::ostream& out );
   23584             :       static void readStaticDataFromFile (std::istream& in );
   23585             :       friend class SgClassExp;
   23586             :    };
   23587             : /* #line 23588 "../../../src/frontend/SageIII//StorageClasses.h" */
   23588             : 
   23589             : 
   23590             : 
   23591             : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarStorageClassDeclatationMacros.macro" */
   23592             : /* 
   23593             :    JH (01/01/2006) ROSETTA generated class declarations for SgFunctionParameterRefExpStorageClass 
   23594             :    used for the ast file IO. Do not chance by hand! 
   23595             : */
   23596         134 : class SgFunctionParameterRefExpStorageClass  : public SgExpressionStorageClass
   23597             :    {
   23598             : 
   23599             :     protected: 
   23600             : 
   23601             : 
   23602             : /* #line 23603 "../../../src/frontend/SageIII//StorageClasses.h" */
   23603             : 
   23604             :       int storageOf_parameter_number;
   23605             :       int storageOf_parameter_levels_up;
   23606             :      unsigned long storageOf_parameter_expression;
   23607             :      unsigned long storageOf_parameter_type;
   23608             : 
   23609             : 
   23610             : /* #line 10 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarStorageClassDeclatationMacros.macro" */
   23611             : 
   23612             : 
   23613             :     public:
   23614             :       void pickOutIRNodeData ( SgFunctionParameterRefExp* source );
   23615             :       static void arrangeStaticDataOfEasyStorageClassesInOneBlock ( );
   23616             :       static void deleteStaticDataOfEasyStorageClasses ( );
   23617             :       static void pickOutStaticDataMembers ( );
   23618             :       static void rebuildStaticDataMembers ( );
   23619             :       static void writeEasyStorageDataToFile (std::ostream& out);
   23620             :       static void readEasyStorageDataFromFile (std::istream& in);
   23621             :       static void writeStaticDataToFile (std::ostream& out );
   23622             :       static void readStaticDataFromFile (std::istream& in );
   23623             :       friend class SgFunctionParameterRefExp;
   23624             :    };
   23625             : /* #line 23626 "../../../src/frontend/SageIII//StorageClasses.h" */
   23626             : 
   23627             : 
   23628             : 
   23629             : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarStorageClassDeclatationMacros.macro" */
   23630             : /* 
   23631             :    JH (01/01/2006) ROSETTA generated class declarations for SgLambdaExpStorageClass 
   23632             :    used for the ast file IO. Do not chance by hand! 
   23633             : */
   23634           0 : class SgLambdaExpStorageClass  : public SgExpressionStorageClass
   23635             :    {
   23636             : 
   23637             :     protected: 
   23638             : 
   23639             : 
   23640             : /* #line 23641 "../../../src/frontend/SageIII//StorageClasses.h" */
   23641             : 
   23642             :      unsigned long storageOf_lambda_capture_list;
   23643             :      unsigned long storageOf_lambda_closure_class;
   23644             :      unsigned long storageOf_lambda_function;
   23645             :       bool storageOf_is_mutable;
   23646             :       bool storageOf_capture_default;
   23647             :       bool storageOf_default_is_by_reference;
   23648             :       bool storageOf_explicit_return_type;
   23649             :       bool storageOf_has_parameter_decl;
   23650             :       bool storageOf_is_device;
   23651             : 
   23652             : 
   23653             : /* #line 10 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarStorageClassDeclatationMacros.macro" */
   23654             : 
   23655             : 
   23656             :     public:
   23657             :       void pickOutIRNodeData ( SgLambdaExp* source );
   23658             :       static void arrangeStaticDataOfEasyStorageClassesInOneBlock ( );
   23659             :       static void deleteStaticDataOfEasyStorageClasses ( );
   23660             :       static void pickOutStaticDataMembers ( );
   23661             :       static void rebuildStaticDataMembers ( );
   23662             :       static void writeEasyStorageDataToFile (std::ostream& out);
   23663             :       static void readEasyStorageDataFromFile (std::istream& in);
   23664             :       static void writeStaticDataToFile (std::ostream& out );
   23665             :       static void readStaticDataFromFile (std::istream& in );
   23666             :       friend class SgLambdaExp;
   23667             :    };
   23668             : /* #line 23669 "../../../src/frontend/SageIII//StorageClasses.h" */
   23669             : 
   23670             : 
   23671             : 
   23672             : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarStorageClassDeclatationMacros.macro" */
   23673             : /* 
   23674             :    JH (01/01/2006) ROSETTA generated class declarations for SgNoexceptOpStorageClass 
   23675             :    used for the ast file IO. Do not chance by hand! 
   23676             : */
   23677          36 : class SgNoexceptOpStorageClass  : public SgExpressionStorageClass
   23678             :    {
   23679             : 
   23680             :     protected: 
   23681             : 
   23682             : 
   23683             : /* #line 23684 "../../../src/frontend/SageIII//StorageClasses.h" */
   23684             : 
   23685             :      unsigned long storageOf_operand_expr;
   23686             : 
   23687             : 
   23688             : /* #line 10 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarStorageClassDeclatationMacros.macro" */
   23689             : 
   23690             : 
   23691             :     public:
   23692             :       void pickOutIRNodeData ( SgNoexceptOp* source );
   23693             :       static void arrangeStaticDataOfEasyStorageClassesInOneBlock ( );
   23694             :       static void deleteStaticDataOfEasyStorageClasses ( );
   23695             :       static void pickOutStaticDataMembers ( );
   23696             :       static void rebuildStaticDataMembers ( );
   23697             :       static void writeEasyStorageDataToFile (std::ostream& out);
   23698             :       static void readEasyStorageDataFromFile (std::istream& in);
   23699             :       static void writeStaticDataToFile (std::ostream& out );
   23700             :       static void readStaticDataFromFile (std::istream& in );
   23701             :       friend class SgNoexceptOp;
   23702             :    };
   23703             : /* #line 23704 "../../../src/frontend/SageIII//StorageClasses.h" */
   23704             : 
   23705             : 
   23706             : 
   23707             : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarStorageClassDeclatationMacros.macro" */
   23708             : /* 
   23709             :    JH (01/01/2006) ROSETTA generated class declarations for SgNonrealRefExpStorageClass 
   23710             :    used for the ast file IO. Do not chance by hand! 
   23711             : */
   23712        2988 : class SgNonrealRefExpStorageClass  : public SgExpressionStorageClass
   23713             :    {
   23714             : 
   23715             :     protected: 
   23716             : 
   23717             : 
   23718             : /* #line 23719 "../../../src/frontend/SageIII//StorageClasses.h" */
   23719             : 
   23720             :      unsigned long storageOf_symbol;
   23721             :       int storageOf_name_qualification_length;
   23722             :       bool storageOf_type_elaboration_required;
   23723             :       bool storageOf_global_qualification_required;
   23724             : 
   23725             : 
   23726             : /* #line 10 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarStorageClassDeclatationMacros.macro" */
   23727             : 
   23728             : 
   23729             :     public:
   23730             :       void pickOutIRNodeData ( SgNonrealRefExp* source );
   23731             :       static void arrangeStaticDataOfEasyStorageClassesInOneBlock ( );
   23732             :       static void deleteStaticDataOfEasyStorageClasses ( );
   23733             :       static void pickOutStaticDataMembers ( );
   23734             :       static void rebuildStaticDataMembers ( );
   23735             :       static void writeEasyStorageDataToFile (std::ostream& out);
   23736             :       static void readEasyStorageDataFromFile (std::istream& in);
   23737             :       static void writeStaticDataToFile (std::ostream& out );
   23738             :       static void readStaticDataFromFile (std::istream& in );
   23739             :       friend class SgNonrealRefExp;
   23740             :    };
   23741             : /* #line 23742 "../../../src/frontend/SageIII//StorageClasses.h" */
   23742             : 
   23743             : 
   23744             : 
   23745             : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarStorageClassDeclatationMacros.macro" */
   23746             : /* 
   23747             :    JH (01/01/2006) ROSETTA generated class declarations for SgFoldExpressionStorageClass 
   23748             :    used for the ast file IO. Do not chance by hand! 
   23749             : */
   23750           0 : class SgFoldExpressionStorageClass  : public SgExpressionStorageClass
   23751             :    {
   23752             : 
   23753             :     protected: 
   23754             : 
   23755             : 
   23756             : /* #line 23757 "../../../src/frontend/SageIII//StorageClasses.h" */
   23757             : 
   23758             :      unsigned long storageOf_operands;
   23759             :        EasyStorage < std::string > storageOf_operator_token;
   23760             :       bool storageOf_is_left_associative;
   23761             : 
   23762             : 
   23763             : /* #line 10 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarStorageClassDeclatationMacros.macro" */
   23764             : 
   23765             : 
   23766             :     public:
   23767             :       void pickOutIRNodeData ( SgFoldExpression* source );
   23768             :       static void arrangeStaticDataOfEasyStorageClassesInOneBlock ( );
   23769             :       static void deleteStaticDataOfEasyStorageClasses ( );
   23770             :       static void pickOutStaticDataMembers ( );
   23771             :       static void rebuildStaticDataMembers ( );
   23772             :       static void writeEasyStorageDataToFile (std::ostream& out);
   23773             :       static void readEasyStorageDataFromFile (std::istream& in);
   23774             :       static void writeStaticDataToFile (std::ostream& out );
   23775             :       static void readStaticDataFromFile (std::istream& in );
   23776             :       friend class SgFoldExpression;
   23777             :    };
   23778             : /* #line 23779 "../../../src/frontend/SageIII//StorageClasses.h" */
   23779             : 
   23780             : 
   23781             : 
   23782             : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarStorageClassDeclatationMacros.macro" */
   23783             : /* 
   23784             :    JH (01/01/2006) ROSETTA generated class declarations for SgAwaitExpressionStorageClass 
   23785             :    used for the ast file IO. Do not chance by hand! 
   23786             : */
   23787           0 : class SgAwaitExpressionStorageClass  : public SgExpressionStorageClass
   23788             :    {
   23789             : 
   23790             :     protected: 
   23791             : 
   23792             : 
   23793             : /* #line 23794 "../../../src/frontend/SageIII//StorageClasses.h" */
   23794             : 
   23795             :      unsigned long storageOf_value;
   23796             : 
   23797             : 
   23798             : /* #line 10 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarStorageClassDeclatationMacros.macro" */
   23799             : 
   23800             : 
   23801             :     public:
   23802             :       void pickOutIRNodeData ( SgAwaitExpression* source );
   23803             :       static void arrangeStaticDataOfEasyStorageClassesInOneBlock ( );
   23804             :       static void deleteStaticDataOfEasyStorageClasses ( );
   23805             :       static void pickOutStaticDataMembers ( );
   23806             :       static void rebuildStaticDataMembers ( );
   23807             :       static void writeEasyStorageDataToFile (std::ostream& out);
   23808             :       static void readEasyStorageDataFromFile (std::istream& in);
   23809             :       static void writeStaticDataToFile (std::ostream& out );
   23810             :       static void readStaticDataFromFile (std::istream& in );
   23811             :       friend class SgAwaitExpression;
   23812             :    };
   23813             : /* #line 23814 "../../../src/frontend/SageIII//StorageClasses.h" */
   23814             : 
   23815             : 
   23816             : 
   23817             : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarStorageClassDeclatationMacros.macro" */
   23818             : /* 
   23819             :    JH (01/01/2006) ROSETTA generated class declarations for SgChooseExpressionStorageClass 
   23820             :    used for the ast file IO. Do not chance by hand! 
   23821             : */
   23822           0 : class SgChooseExpressionStorageClass  : public SgExpressionStorageClass
   23823             :    {
   23824             : 
   23825             :     protected: 
   23826             : 
   23827             : 
   23828             : /* #line 23829 "../../../src/frontend/SageIII//StorageClasses.h" */
   23829             : 
   23830             :      unsigned long storageOf_value;
   23831             : 
   23832             : 
   23833             : /* #line 10 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarStorageClassDeclatationMacros.macro" */
   23834             : 
   23835             : 
   23836             :     public:
   23837             :       void pickOutIRNodeData ( SgChooseExpression* source );
   23838             :       static void arrangeStaticDataOfEasyStorageClassesInOneBlock ( );
   23839             :       static void deleteStaticDataOfEasyStorageClasses ( );
   23840             :       static void pickOutStaticDataMembers ( );
   23841             :       static void rebuildStaticDataMembers ( );
   23842             :       static void writeEasyStorageDataToFile (std::ostream& out);
   23843             :       static void readEasyStorageDataFromFile (std::istream& in);
   23844             :       static void writeStaticDataToFile (std::ostream& out );
   23845             :       static void readStaticDataFromFile (std::istream& in );
   23846             :       friend class SgChooseExpression;
   23847             :    };
   23848             : /* #line 23849 "../../../src/frontend/SageIII//StorageClasses.h" */
   23849             : 
   23850             : 
   23851             : 
   23852             : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarStorageClassDeclatationMacros.macro" */
   23853             : /* 
   23854             :    JH (01/01/2006) ROSETTA generated class declarations for SgSymbolStorageClass 
   23855             :    used for the ast file IO. Do not chance by hand! 
   23856             : */
   23857       91076 : class SgSymbolStorageClass  : public SgNodeStorageClass
   23858             :    {
   23859             : 
   23860             :     protected: 
   23861             : 
   23862             : 
   23863             : /* #line 23864 "../../../src/frontend/SageIII//StorageClasses.h" */
   23864             : 
   23865             :        EasyStorage < AstAttributeMechanism* > storageOf_attributeMechanism;
   23866             : 
   23867             : 
   23868             : /* #line 10 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarStorageClassDeclatationMacros.macro" */
   23869             : 
   23870             : 
   23871             :     public:
   23872             :       void pickOutIRNodeData ( SgSymbol* source );
   23873             :       static void arrangeStaticDataOfEasyStorageClassesInOneBlock ( );
   23874             :       static void deleteStaticDataOfEasyStorageClasses ( );
   23875             :       static void pickOutStaticDataMembers ( );
   23876             :       static void rebuildStaticDataMembers ( );
   23877             :       static void writeEasyStorageDataToFile (std::ostream& out);
   23878             :       static void readEasyStorageDataFromFile (std::istream& in);
   23879             :       static void writeStaticDataToFile (std::ostream& out );
   23880             :       static void readStaticDataFromFile (std::istream& in );
   23881             :       friend class SgSymbol;
   23882             :    };
   23883             : /* #line 23884 "../../../src/frontend/SageIII//StorageClasses.h" */
   23884             : 
   23885             : 
   23886             : 
   23887             : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarStorageClassDeclatationMacros.macro" */
   23888             : /* 
   23889             :    JH (01/01/2006) ROSETTA generated class declarations for SgVariableSymbolStorageClass 
   23890             :    used for the ast file IO. Do not chance by hand! 
   23891             : */
   23892        8452 : class SgVariableSymbolStorageClass  : public SgSymbolStorageClass
   23893             :    {
   23894             : 
   23895             :     protected: 
   23896             : 
   23897             : 
   23898             : /* #line 23899 "../../../src/frontend/SageIII//StorageClasses.h" */
   23899             : 
   23900             :      unsigned long storageOf_declaration;
   23901             : 
   23902             : 
   23903             : /* #line 10 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarStorageClassDeclatationMacros.macro" */
   23904             : 
   23905             : 
   23906             :     public:
   23907             :       void pickOutIRNodeData ( SgVariableSymbol* source );
   23908             :       static void arrangeStaticDataOfEasyStorageClassesInOneBlock ( );
   23909             :       static void deleteStaticDataOfEasyStorageClasses ( );
   23910             :       static void pickOutStaticDataMembers ( );
   23911             :       static void rebuildStaticDataMembers ( );
   23912             :       static void writeEasyStorageDataToFile (std::ostream& out);
   23913             :       static void readEasyStorageDataFromFile (std::istream& in);
   23914             :       static void writeStaticDataToFile (std::ostream& out );
   23915             :       static void readStaticDataFromFile (std::istream& in );
   23916             :       friend class SgVariableSymbol;
   23917             :    };
   23918             : /* #line 23919 "../../../src/frontend/SageIII//StorageClasses.h" */
   23919             : 
   23920             : 
   23921             : 
   23922             : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarStorageClassDeclatationMacros.macro" */
   23923             : /* 
   23924             :    JH (01/01/2006) ROSETTA generated class declarations for SgTemplateVariableSymbolStorageClass 
   23925             :    used for the ast file IO. Do not chance by hand! 
   23926             : */
   23927         172 : class SgTemplateVariableSymbolStorageClass  : public SgVariableSymbolStorageClass
   23928             :    {
   23929             : 
   23930             :     protected: 
   23931             : 
   23932             : 
   23933             : /* #line 23934 "../../../src/frontend/SageIII//StorageClasses.h" */
   23934             : 
   23935             : 
   23936             : 
   23937             : /* #line 10 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarStorageClassDeclatationMacros.macro" */
   23938             : 
   23939             : 
   23940             :     public:
   23941             :       void pickOutIRNodeData ( SgTemplateVariableSymbol* source );
   23942             :       static void arrangeStaticDataOfEasyStorageClassesInOneBlock ( );
   23943             :       static void deleteStaticDataOfEasyStorageClasses ( );
   23944             :       static void pickOutStaticDataMembers ( );
   23945             :       static void rebuildStaticDataMembers ( );
   23946             :       static void writeEasyStorageDataToFile (std::ostream& out);
   23947             :       static void readEasyStorageDataFromFile (std::istream& in);
   23948             :       static void writeStaticDataToFile (std::ostream& out );
   23949             :       static void readStaticDataFromFile (std::istream& in );
   23950             :       friend class SgTemplateVariableSymbol;
   23951             :    };
   23952             : /* #line 23953 "../../../src/frontend/SageIII//StorageClasses.h" */
   23953             : 
   23954             : 
   23955             : 
   23956             : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarStorageClassDeclatationMacros.macro" */
   23957             : /* 
   23958             :    JH (01/01/2006) ROSETTA generated class declarations for SgNonrealSymbolStorageClass 
   23959             :    used for the ast file IO. Do not chance by hand! 
   23960             : */
   23961       10160 : class SgNonrealSymbolStorageClass  : public SgSymbolStorageClass
   23962             :    {
   23963             : 
   23964             :     protected: 
   23965             : 
   23966             : 
   23967             : /* #line 23968 "../../../src/frontend/SageIII//StorageClasses.h" */
   23968             : 
   23969             :      unsigned long storageOf_declaration;
   23970             : 
   23971             : 
   23972             : /* #line 10 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarStorageClassDeclatationMacros.macro" */
   23973             : 
   23974             : 
   23975             :     public:
   23976             :       void pickOutIRNodeData ( SgNonrealSymbol* source );
   23977             :       static void arrangeStaticDataOfEasyStorageClassesInOneBlock ( );
   23978             :       static void deleteStaticDataOfEasyStorageClasses ( );
   23979             :       static void pickOutStaticDataMembers ( );
   23980             :       static void rebuildStaticDataMembers ( );
   23981             :       static void writeEasyStorageDataToFile (std::ostream& out);
   23982             :       static void readEasyStorageDataFromFile (std::istream& in);
   23983             :       static void writeStaticDataToFile (std::ostream& out );
   23984             :       static void readStaticDataFromFile (std::istream& in );
   23985             :       friend class SgNonrealSymbol;
   23986             :    };
   23987             : /* #line 23988 "../../../src/frontend/SageIII//StorageClasses.h" */
   23988             : 
   23989             : 
   23990             : 
   23991             : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarStorageClassDeclatationMacros.macro" */
   23992             : /* 
   23993             :    JH (01/01/2006) ROSETTA generated class declarations for SgFunctionSymbolStorageClass 
   23994             :    used for the ast file IO. Do not chance by hand! 
   23995             : */
   23996       11911 : class SgFunctionSymbolStorageClass  : public SgSymbolStorageClass
   23997             :    {
   23998             : 
   23999             :     protected: 
   24000             : 
   24001             : 
   24002             : /* #line 24003 "../../../src/frontend/SageIII//StorageClasses.h" */
   24003             : 
   24004             :      unsigned long storageOf_declaration;
   24005             : 
   24006             : 
   24007             : /* #line 10 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarStorageClassDeclatationMacros.macro" */
   24008             : 
   24009             : 
   24010             :     public:
   24011             :       void pickOutIRNodeData ( SgFunctionSymbol* source );
   24012             :       static void arrangeStaticDataOfEasyStorageClassesInOneBlock ( );
   24013             :       static void deleteStaticDataOfEasyStorageClasses ( );
   24014             :       static void pickOutStaticDataMembers ( );
   24015             :       static void rebuildStaticDataMembers ( );
   24016             :       static void writeEasyStorageDataToFile (std::ostream& out);
   24017             :       static void readEasyStorageDataFromFile (std::istream& in);
   24018             :       static void writeStaticDataToFile (std::ostream& out );
   24019             :       static void readStaticDataFromFile (std::istream& in );
   24020             :       friend class SgFunctionSymbol;
   24021             :    };
   24022             : /* #line 24023 "../../../src/frontend/SageIII//StorageClasses.h" */
   24023             : 
   24024             : 
   24025             : 
   24026             : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarStorageClassDeclatationMacros.macro" */
   24027             : /* 
   24028             :    JH (01/01/2006) ROSETTA generated class declarations for SgMemberFunctionSymbolStorageClass 
   24029             :    used for the ast file IO. Do not chance by hand! 
   24030             : */
   24031        3906 : class SgMemberFunctionSymbolStorageClass  : public SgFunctionSymbolStorageClass
   24032             :    {
   24033             : 
   24034             :     protected: 
   24035             : 
   24036             : 
   24037             : /* #line 24038 "../../../src/frontend/SageIII//StorageClasses.h" */
   24038             : 
   24039             : 
   24040             : 
   24041             : /* #line 10 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarStorageClassDeclatationMacros.macro" */
   24042             : 
   24043             : 
   24044             :     public:
   24045             :       void pickOutIRNodeData ( SgMemberFunctionSymbol* source );
   24046             :       static void arrangeStaticDataOfEasyStorageClassesInOneBlock ( );
   24047             :       static void deleteStaticDataOfEasyStorageClasses ( );
   24048             :       static void pickOutStaticDataMembers ( );
   24049             :       static void rebuildStaticDataMembers ( );
   24050             :       static void writeEasyStorageDataToFile (std::ostream& out);
   24051             :       static void readEasyStorageDataFromFile (std::istream& in);
   24052             :       static void writeStaticDataToFile (std::ostream& out );
   24053             :       static void readStaticDataFromFile (std::istream& in );
   24054             :       friend class SgMemberFunctionSymbol;
   24055             :    };
   24056             : /* #line 24057 "../../../src/frontend/SageIII//StorageClasses.h" */
   24057             : 
   24058             : 
   24059             : 
   24060             : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarStorageClassDeclatationMacros.macro" */
   24061             : /* 
   24062             :    JH (01/01/2006) ROSETTA generated class declarations for SgTemplateMemberFunctionSymbolStorageClass 
   24063             :    used for the ast file IO. Do not chance by hand! 
   24064             : */
   24065        2094 : class SgTemplateMemberFunctionSymbolStorageClass  : public SgMemberFunctionSymbolStorageClass
   24066             :    {
   24067             : 
   24068             :     protected: 
   24069             : 
   24070             : 
   24071             : /* #line 24072 "../../../src/frontend/SageIII//StorageClasses.h" */
   24072             : 
   24073             : 
   24074             : 
   24075             : /* #line 10 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarStorageClassDeclatationMacros.macro" */
   24076             : 
   24077             : 
   24078             :     public:
   24079             :       void pickOutIRNodeData ( SgTemplateMemberFunctionSymbol* source );
   24080             :       static void arrangeStaticDataOfEasyStorageClassesInOneBlock ( );
   24081             :       static void deleteStaticDataOfEasyStorageClasses ( );
   24082             :       static void pickOutStaticDataMembers ( );
   24083             :       static void rebuildStaticDataMembers ( );
   24084             :       static void writeEasyStorageDataToFile (std::ostream& out);
   24085             :       static void readEasyStorageDataFromFile (std::istream& in);
   24086             :       static void writeStaticDataToFile (std::ostream& out );
   24087             :       static void readStaticDataFromFile (std::istream& in );
   24088             :       friend class SgTemplateMemberFunctionSymbol;
   24089             :    };
   24090             : /* #line 24091 "../../../src/frontend/SageIII//StorageClasses.h" */
   24091             : 
   24092             : 
   24093             : 
   24094             : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarStorageClassDeclatationMacros.macro" */
   24095             : /* 
   24096             :    JH (01/01/2006) ROSETTA generated class declarations for SgTemplateFunctionSymbolStorageClass 
   24097             :    used for the ast file IO. Do not chance by hand! 
   24098             : */
   24099         680 : class SgTemplateFunctionSymbolStorageClass  : public SgFunctionSymbolStorageClass
   24100             :    {
   24101             : 
   24102             :     protected: 
   24103             : 
   24104             : 
   24105             : /* #line 24106 "../../../src/frontend/SageIII//StorageClasses.h" */
   24106             : 
   24107             : 
   24108             : 
   24109             : /* #line 10 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarStorageClassDeclatationMacros.macro" */
   24110             : 
   24111             : 
   24112             :     public:
   24113             :       void pickOutIRNodeData ( SgTemplateFunctionSymbol* source );
   24114             :       static void arrangeStaticDataOfEasyStorageClassesInOneBlock ( );
   24115             :       static void deleteStaticDataOfEasyStorageClasses ( );
   24116             :       static void pickOutStaticDataMembers ( );
   24117             :       static void rebuildStaticDataMembers ( );
   24118             :       static void writeEasyStorageDataToFile (std::ostream& out);
   24119             :       static void readEasyStorageDataFromFile (std::istream& in);
   24120             :       static void writeStaticDataToFile (std::ostream& out );
   24121             :       static void readStaticDataFromFile (std::istream& in );
   24122             :       friend class SgTemplateFunctionSymbol;
   24123             :    };
   24124             : /* #line 24125 "../../../src/frontend/SageIII//StorageClasses.h" */
   24125             : 
   24126             : 
   24127             : 
   24128             : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarStorageClassDeclatationMacros.macro" */
   24129             : /* 
   24130             :    JH (01/01/2006) ROSETTA generated class declarations for SgRenameSymbolStorageClass 
   24131             :    used for the ast file IO. Do not chance by hand! 
   24132             : */
   24133           0 : class SgRenameSymbolStorageClass  : public SgFunctionSymbolStorageClass
   24134             :    {
   24135             : 
   24136             :     protected: 
   24137             : 
   24138             : 
   24139             : /* #line 24140 "../../../src/frontend/SageIII//StorageClasses.h" */
   24140             : 
   24141             :      unsigned long storageOf_original_symbol;
   24142             :       SgNameStorageClass storageOf_new_name;
   24143             : 
   24144             : 
   24145             : /* #line 10 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarStorageClassDeclatationMacros.macro" */
   24146             : 
   24147             : 
   24148             :     public:
   24149             :       void pickOutIRNodeData ( SgRenameSymbol* source );
   24150             :       static void arrangeStaticDataOfEasyStorageClassesInOneBlock ( );
   24151             :       static void deleteStaticDataOfEasyStorageClasses ( );
   24152             :       static void pickOutStaticDataMembers ( );
   24153             :       static void rebuildStaticDataMembers ( );
   24154             :       static void writeEasyStorageDataToFile (std::ostream& out);
   24155             :       static void readEasyStorageDataFromFile (std::istream& in);
   24156             :       static void writeStaticDataToFile (std::ostream& out );
   24157             :       static void readStaticDataFromFile (std::istream& in );
   24158             :       friend class SgRenameSymbol;
   24159             :    };
   24160             : /* #line 24161 "../../../src/frontend/SageIII//StorageClasses.h" */
   24161             : 
   24162             : 
   24163             : 
   24164             : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarStorageClassDeclatationMacros.macro" */
   24165             : /* 
   24166             :    JH (01/01/2006) ROSETTA generated class declarations for SgFunctionTypeSymbolStorageClass 
   24167             :    used for the ast file IO. Do not chance by hand! 
   24168             : */
   24169       18364 : class SgFunctionTypeSymbolStorageClass  : public SgSymbolStorageClass
   24170             :    {
   24171             : 
   24172             :     protected: 
   24173             : 
   24174             : 
   24175             : /* #line 24176 "../../../src/frontend/SageIII//StorageClasses.h" */
   24176             : 
   24177             :       SgNameStorageClass storageOf_name;
   24178             :      unsigned long storageOf_type;
   24179             : 
   24180             : 
   24181             : /* #line 10 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarStorageClassDeclatationMacros.macro" */
   24182             : 
   24183             : 
   24184             :     public:
   24185             :       void pickOutIRNodeData ( SgFunctionTypeSymbol* source );
   24186             :       static void arrangeStaticDataOfEasyStorageClassesInOneBlock ( );
   24187             :       static void deleteStaticDataOfEasyStorageClasses ( );
   24188             :       static void pickOutStaticDataMembers ( );
   24189             :       static void rebuildStaticDataMembers ( );
   24190             :       static void writeEasyStorageDataToFile (std::ostream& out);
   24191             :       static void readEasyStorageDataFromFile (std::istream& in);
   24192             :       static void writeStaticDataToFile (std::ostream& out );
   24193             :       static void readStaticDataFromFile (std::istream& in );
   24194             :       friend class SgFunctionTypeSymbol;
   24195             :    };
   24196             : /* #line 24197 "../../../src/frontend/SageIII//StorageClasses.h" */
   24197             : 
   24198             : 
   24199             : 
   24200             : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarStorageClassDeclatationMacros.macro" */
   24201             : /* 
   24202             :    JH (01/01/2006) ROSETTA generated class declarations for SgClassSymbolStorageClass 
   24203             :    used for the ast file IO. Do not chance by hand! 
   24204             : */
   24205        1704 : class SgClassSymbolStorageClass  : public SgSymbolStorageClass
   24206             :    {
   24207             : 
   24208             :     protected: 
   24209             : 
   24210             : 
   24211             : /* #line 24212 "../../../src/frontend/SageIII//StorageClasses.h" */
   24212             : 
   24213             :      unsigned long storageOf_declaration;
   24214             : 
   24215             : 
   24216             : /* #line 10 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarStorageClassDeclatationMacros.macro" */
   24217             : 
   24218             : 
   24219             :     public:
   24220             :       void pickOutIRNodeData ( SgClassSymbol* source );
   24221             :       static void arrangeStaticDataOfEasyStorageClassesInOneBlock ( );
   24222             :       static void deleteStaticDataOfEasyStorageClasses ( );
   24223             :       static void pickOutStaticDataMembers ( );
   24224             :       static void rebuildStaticDataMembers ( );
   24225             :       static void writeEasyStorageDataToFile (std::ostream& out);
   24226             :       static void readEasyStorageDataFromFile (std::istream& in);
   24227             :       static void writeStaticDataToFile (std::ostream& out );
   24228             :       static void readStaticDataFromFile (std::istream& in );
   24229             :       friend class SgClassSymbol;
   24230             :    };
   24231             : /* #line 24232 "../../../src/frontend/SageIII//StorageClasses.h" */
   24232             : 
   24233             : 
   24234             : 
   24235             : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarStorageClassDeclatationMacros.macro" */
   24236             : /* 
   24237             :    JH (01/01/2006) ROSETTA generated class declarations for SgTemplateClassSymbolStorageClass 
   24238             :    used for the ast file IO. Do not chance by hand! 
   24239             : */
   24240        1144 : class SgTemplateClassSymbolStorageClass  : public SgClassSymbolStorageClass
   24241             :    {
   24242             : 
   24243             :     protected: 
   24244             : 
   24245             : 
   24246             : /* #line 24247 "../../../src/frontend/SageIII//StorageClasses.h" */
   24247             : 
   24248             : 
   24249             : 
   24250             : /* #line 10 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarStorageClassDeclatationMacros.macro" */
   24251             : 
   24252             : 
   24253             :     public:
   24254             :       void pickOutIRNodeData ( SgTemplateClassSymbol* source );
   24255             :       static void arrangeStaticDataOfEasyStorageClassesInOneBlock ( );
   24256             :       static void deleteStaticDataOfEasyStorageClasses ( );
   24257             :       static void pickOutStaticDataMembers ( );
   24258             :       static void rebuildStaticDataMembers ( );
   24259             :       static void writeEasyStorageDataToFile (std::ostream& out);
   24260             :       static void readEasyStorageDataFromFile (std::istream& in);
   24261             :       static void writeStaticDataToFile (std::ostream& out );
   24262             :       static void readStaticDataFromFile (std::istream& in );
   24263             :       friend class SgTemplateClassSymbol;
   24264             :    };
   24265             : /* #line 24266 "../../../src/frontend/SageIII//StorageClasses.h" */
   24266             : 
   24267             : 
   24268             : 
   24269             : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarStorageClassDeclatationMacros.macro" */
   24270             : /* 
   24271             :    JH (01/01/2006) ROSETTA generated class declarations for SgTemplateSymbolStorageClass 
   24272             :    used for the ast file IO. Do not chance by hand! 
   24273             : */
   24274           0 : class SgTemplateSymbolStorageClass  : public SgSymbolStorageClass
   24275             :    {
   24276             : 
   24277             :     protected: 
   24278             : 
   24279             : 
   24280             : /* #line 24281 "../../../src/frontend/SageIII//StorageClasses.h" */
   24281             : 
   24282             :      unsigned long storageOf_declaration;
   24283             : 
   24284             : 
   24285             : /* #line 10 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarStorageClassDeclatationMacros.macro" */
   24286             : 
   24287             : 
   24288             :     public:
   24289             :       void pickOutIRNodeData ( SgTemplateSymbol* source );
   24290             :       static void arrangeStaticDataOfEasyStorageClassesInOneBlock ( );
   24291             :       static void deleteStaticDataOfEasyStorageClasses ( );
   24292             :       static void pickOutStaticDataMembers ( );
   24293             :       static void rebuildStaticDataMembers ( );
   24294             :       static void writeEasyStorageDataToFile (std::ostream& out);
   24295             :       static void readEasyStorageDataFromFile (std::istream& in);
   24296             :       static void writeStaticDataToFile (std::ostream& out );
   24297             :       static void readStaticDataFromFile (std::istream& in );
   24298             :       friend class SgTemplateSymbol;
   24299             :    };
   24300             : /* #line 24301 "../../../src/frontend/SageIII//StorageClasses.h" */
   24301             : 
   24302             : 
   24303             : 
   24304             : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarStorageClassDeclatationMacros.macro" */
   24305             : /* 
   24306             :    JH (01/01/2006) ROSETTA generated class declarations for SgEnumSymbolStorageClass 
   24307             :    used for the ast file IO. Do not chance by hand! 
   24308             : */
   24309         176 : class SgEnumSymbolStorageClass  : public SgSymbolStorageClass
   24310             :    {
   24311             : 
   24312             :     protected: 
   24313             : 
   24314             : 
   24315             : /* #line 24316 "../../../src/frontend/SageIII//StorageClasses.h" */
   24316             : 
   24317             :      unsigned long storageOf_declaration;
   24318             : 
   24319             : 
   24320             : /* #line 10 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarStorageClassDeclatationMacros.macro" */
   24321             : 
   24322             : 
   24323             :     public:
   24324             :       void pickOutIRNodeData ( SgEnumSymbol* source );
   24325             :       static void arrangeStaticDataOfEasyStorageClassesInOneBlock ( );
   24326             :       static void deleteStaticDataOfEasyStorageClasses ( );
   24327             :       static void pickOutStaticDataMembers ( );
   24328             :       static void rebuildStaticDataMembers ( );
   24329             :       static void writeEasyStorageDataToFile (std::ostream& out);
   24330             :       static void readEasyStorageDataFromFile (std::istream& in);
   24331             :       static void writeStaticDataToFile (std::ostream& out );
   24332             :       static void readStaticDataFromFile (std::istream& in );
   24333             :       friend class SgEnumSymbol;
   24334             :    };
   24335             : /* #line 24336 "../../../src/frontend/SageIII//StorageClasses.h" */
   24336             : 
   24337             : 
   24338             : 
   24339             : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarStorageClassDeclatationMacros.macro" */
   24340             : /* 
   24341             :    JH (01/01/2006) ROSETTA generated class declarations for SgEnumFieldSymbolStorageClass 
   24342             :    used for the ast file IO. Do not chance by hand! 
   24343             : */
   24344         558 : class SgEnumFieldSymbolStorageClass  : public SgSymbolStorageClass
   24345             :    {
   24346             : 
   24347             :     protected: 
   24348             : 
   24349             : 
   24350             : /* #line 24351 "../../../src/frontend/SageIII//StorageClasses.h" */
   24351             : 
   24352             :      unsigned long storageOf_declaration;
   24353             : 
   24354             : 
   24355             : /* #line 10 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarStorageClassDeclatationMacros.macro" */
   24356             : 
   24357             : 
   24358             :     public:
   24359             :       void pickOutIRNodeData ( SgEnumFieldSymbol* source );
   24360             :       static void arrangeStaticDataOfEasyStorageClassesInOneBlock ( );
   24361             :       static void deleteStaticDataOfEasyStorageClasses ( );
   24362             :       static void pickOutStaticDataMembers ( );
   24363             :       static void rebuildStaticDataMembers ( );
   24364             :       static void writeEasyStorageDataToFile (std::ostream& out);
   24365             :       static void readEasyStorageDataFromFile (std::istream& in);
   24366             :       static void writeStaticDataToFile (std::ostream& out );
   24367             :       static void readStaticDataFromFile (std::istream& in );
   24368             :       friend class SgEnumFieldSymbol;
   24369             :    };
   24370             : /* #line 24371 "../../../src/frontend/SageIII//StorageClasses.h" */
   24371             : 
   24372             : 
   24373             : 
   24374             : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarStorageClassDeclatationMacros.macro" */
   24375             : /* 
   24376             :    JH (01/01/2006) ROSETTA generated class declarations for SgTypedefSymbolStorageClass 
   24377             :    used for the ast file IO. Do not chance by hand! 
   24378             : */
   24379        3438 : class SgTypedefSymbolStorageClass  : public SgSymbolStorageClass
   24380             :    {
   24381             : 
   24382             :     protected: 
   24383             : 
   24384             : 
   24385             : /* #line 24386 "../../../src/frontend/SageIII//StorageClasses.h" */
   24386             : 
   24387             :      unsigned long storageOf_declaration;
   24388             : 
   24389             : 
   24390             : /* #line 10 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarStorageClassDeclatationMacros.macro" */
   24391             : 
   24392             : 
   24393             :     public:
   24394             :       void pickOutIRNodeData ( SgTypedefSymbol* source );
   24395             :       static void arrangeStaticDataOfEasyStorageClassesInOneBlock ( );
   24396             :       static void deleteStaticDataOfEasyStorageClasses ( );
   24397             :       static void pickOutStaticDataMembers ( );
   24398             :       static void rebuildStaticDataMembers ( );
   24399             :       static void writeEasyStorageDataToFile (std::ostream& out);
   24400             :       static void readEasyStorageDataFromFile (std::istream& in);
   24401             :       static void writeStaticDataToFile (std::ostream& out );
   24402             :       static void readStaticDataFromFile (std::istream& in );
   24403             :       friend class SgTypedefSymbol;
   24404             :    };
   24405             : /* #line 24406 "../../../src/frontend/SageIII//StorageClasses.h" */
   24406             : 
   24407             : 
   24408             : 
   24409             : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarStorageClassDeclatationMacros.macro" */
   24410             : /* 
   24411             :    JH (01/01/2006) ROSETTA generated class declarations for SgTemplateTypedefSymbolStorageClass 
   24412             :    used for the ast file IO. Do not chance by hand! 
   24413             : */
   24414         320 : class SgTemplateTypedefSymbolStorageClass  : public SgTypedefSymbolStorageClass
   24415             :    {
   24416             : 
   24417             :     protected: 
   24418             : 
   24419             : 
   24420             : /* #line 24421 "../../../src/frontend/SageIII//StorageClasses.h" */
   24421             : 
   24422             : 
   24423             : 
   24424             : /* #line 10 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarStorageClassDeclatationMacros.macro" */
   24425             : 
   24426             : 
   24427             :     public:
   24428             :       void pickOutIRNodeData ( SgTemplateTypedefSymbol* source );
   24429             :       static void arrangeStaticDataOfEasyStorageClassesInOneBlock ( );
   24430             :       static void deleteStaticDataOfEasyStorageClasses ( );
   24431             :       static void pickOutStaticDataMembers ( );
   24432             :       static void rebuildStaticDataMembers ( );
   24433             :       static void writeEasyStorageDataToFile (std::ostream& out);
   24434             :       static void readEasyStorageDataFromFile (std::istream& in);
   24435             :       static void writeStaticDataToFile (std::ostream& out );
   24436             :       static void readStaticDataFromFile (std::istream& in );
   24437             :       friend class SgTemplateTypedefSymbol;
   24438             :    };
   24439             : /* #line 24440 "../../../src/frontend/SageIII//StorageClasses.h" */
   24440             : 
   24441             : 
   24442             : 
   24443             : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarStorageClassDeclatationMacros.macro" */
   24444             : /* 
   24445             :    JH (01/01/2006) ROSETTA generated class declarations for SgLabelSymbolStorageClass 
   24446             :    used for the ast file IO. Do not chance by hand! 
   24447             : */
   24448           0 : class SgLabelSymbolStorageClass  : public SgSymbolStorageClass
   24449             :    {
   24450             : 
   24451             :     protected: 
   24452             : 
   24453             : 
   24454             : /* #line 24455 "../../../src/frontend/SageIII//StorageClasses.h" */
   24455             : 
   24456             :      unsigned long storageOf_declaration;
   24457             :      unsigned long storageOf_fortran_statement;
   24458             :      unsigned long storageOf_fortran_alternate_return_parameter;
   24459             :       int storageOf_numeric_label_value;
   24460             :       SgLabelSymbol::label_type_enum storageOf_label_type;
   24461             : 
   24462             : 
   24463             : /* #line 10 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarStorageClassDeclatationMacros.macro" */
   24464             : 
   24465             : 
   24466             :     public:
   24467             :       void pickOutIRNodeData ( SgLabelSymbol* source );
   24468             :       static void arrangeStaticDataOfEasyStorageClassesInOneBlock ( );
   24469             :       static void deleteStaticDataOfEasyStorageClasses ( );
   24470             :       static void pickOutStaticDataMembers ( );
   24471             :       static void rebuildStaticDataMembers ( );
   24472             :       static void writeEasyStorageDataToFile (std::ostream& out);
   24473             :       static void readEasyStorageDataFromFile (std::istream& in);
   24474             :       static void writeStaticDataToFile (std::ostream& out );
   24475             :       static void readStaticDataFromFile (std::istream& in );
   24476             :       friend class SgLabelSymbol;
   24477             :    };
   24478             : /* #line 24479 "../../../src/frontend/SageIII//StorageClasses.h" */
   24479             : 
   24480             : 
   24481             : 
   24482             : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarStorageClassDeclatationMacros.macro" */
   24483             : /* 
   24484             :    JH (01/01/2006) ROSETTA generated class declarations for SgDefaultSymbolStorageClass 
   24485             :    used for the ast file IO. Do not chance by hand! 
   24486             : */
   24487           0 : class SgDefaultSymbolStorageClass  : public SgSymbolStorageClass
   24488             :    {
   24489             : 
   24490             :     protected: 
   24491             : 
   24492             : 
   24493             : /* #line 24494 "../../../src/frontend/SageIII//StorageClasses.h" */
   24494             : 
   24495             :      unsigned long storageOf_type;
   24496             : 
   24497             : 
   24498             : /* #line 10 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarStorageClassDeclatationMacros.macro" */
   24499             : 
   24500             : 
   24501             :     public:
   24502             :       void pickOutIRNodeData ( SgDefaultSymbol* source );
   24503             :       static void arrangeStaticDataOfEasyStorageClassesInOneBlock ( );
   24504             :       static void deleteStaticDataOfEasyStorageClasses ( );
   24505             :       static void pickOutStaticDataMembers ( );
   24506             :       static void rebuildStaticDataMembers ( );
   24507             :       static void writeEasyStorageDataToFile (std::ostream& out);
   24508             :       static void readEasyStorageDataFromFile (std::istream& in);
   24509             :       static void writeStaticDataToFile (std::ostream& out );
   24510             :       static void readStaticDataFromFile (std::istream& in );
   24511             :       friend class SgDefaultSymbol;
   24512             :    };
   24513             : /* #line 24514 "../../../src/frontend/SageIII//StorageClasses.h" */
   24514             : 
   24515             : 
   24516             : 
   24517             : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarStorageClassDeclatationMacros.macro" */
   24518             : /* 
   24519             :    JH (01/01/2006) ROSETTA generated class declarations for SgNamespaceSymbolStorageClass 
   24520             :    used for the ast file IO. Do not chance by hand! 
   24521             : */
   24522          28 : class SgNamespaceSymbolStorageClass  : public SgSymbolStorageClass
   24523             :    {
   24524             : 
   24525             :     protected: 
   24526             : 
   24527             : 
   24528             : /* #line 24529 "../../../src/frontend/SageIII//StorageClasses.h" */
   24529             : 
   24530             :       SgNameStorageClass storageOf_name;
   24531             :      unsigned long storageOf_declaration;
   24532             :      unsigned long storageOf_aliasDeclaration;
   24533             :       bool storageOf_isAlias;
   24534             : 
   24535             : 
   24536             : /* #line 10 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarStorageClassDeclatationMacros.macro" */
   24537             : 
   24538             : 
   24539             :     public:
   24540             :       void pickOutIRNodeData ( SgNamespaceSymbol* source );
   24541             :       static void arrangeStaticDataOfEasyStorageClassesInOneBlock ( );
   24542             :       static void deleteStaticDataOfEasyStorageClasses ( );
   24543             :       static void pickOutStaticDataMembers ( );
   24544             :       static void rebuildStaticDataMembers ( );
   24545             :       static void writeEasyStorageDataToFile (std::ostream& out);
   24546             :       static void readEasyStorageDataFromFile (std::istream& in);
   24547             :       static void writeStaticDataToFile (std::ostream& out );
   24548             :       static void readStaticDataFromFile (std::istream& in );
   24549             :       friend class SgNamespaceSymbol;
   24550             :    };
   24551             : /* #line 24552 "../../../src/frontend/SageIII//StorageClasses.h" */
   24552             : 
   24553             : 
   24554             : 
   24555             : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarStorageClassDeclatationMacros.macro" */
   24556             : /* 
   24557             :    JH (01/01/2006) ROSETTA generated class declarations for SgIntrinsicSymbolStorageClass 
   24558             :    used for the ast file IO. Do not chance by hand! 
   24559             : */
   24560           0 : class SgIntrinsicSymbolStorageClass  : public SgSymbolStorageClass
   24561             :    {
   24562             : 
   24563             :     protected: 
   24564             : 
   24565             : 
   24566             : /* #line 24567 "../../../src/frontend/SageIII//StorageClasses.h" */
   24567             : 
   24568             :      unsigned long storageOf_declaration;
   24569             : 
   24570             : 
   24571             : /* #line 10 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarStorageClassDeclatationMacros.macro" */
   24572             : 
   24573             : 
   24574             :     public:
   24575             :       void pickOutIRNodeData ( SgIntrinsicSymbol* source );
   24576             :       static void arrangeStaticDataOfEasyStorageClassesInOneBlock ( );
   24577             :       static void deleteStaticDataOfEasyStorageClasses ( );
   24578             :       static void pickOutStaticDataMembers ( );
   24579             :       static void rebuildStaticDataMembers ( );
   24580             :       static void writeEasyStorageDataToFile (std::ostream& out);
   24581             :       static void readEasyStorageDataFromFile (std::istream& in);
   24582             :       static void writeStaticDataToFile (std::ostream& out );
   24583             :       static void readStaticDataFromFile (std::istream& in );
   24584             :       friend class SgIntrinsicSymbol;
   24585             :    };
   24586             : /* #line 24587 "../../../src/frontend/SageIII//StorageClasses.h" */
   24587             : 
   24588             : 
   24589             : 
   24590             : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarStorageClassDeclatationMacros.macro" */
   24591             : /* 
   24592             :    JH (01/01/2006) ROSETTA generated class declarations for SgModuleSymbolStorageClass 
   24593             :    used for the ast file IO. Do not chance by hand! 
   24594             : */
   24595           0 : class SgModuleSymbolStorageClass  : public SgSymbolStorageClass
   24596             :    {
   24597             : 
   24598             :     protected: 
   24599             : 
   24600             : 
   24601             : /* #line 24602 "../../../src/frontend/SageIII//StorageClasses.h" */
   24602             : 
   24603             :      unsigned long storageOf_declaration;
   24604             : 
   24605             : 
   24606             : /* #line 10 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarStorageClassDeclatationMacros.macro" */
   24607             : 
   24608             : 
   24609             :     public:
   24610             :       void pickOutIRNodeData ( SgModuleSymbol* source );
   24611             :       static void arrangeStaticDataOfEasyStorageClassesInOneBlock ( );
   24612             :       static void deleteStaticDataOfEasyStorageClasses ( );
   24613             :       static void pickOutStaticDataMembers ( );
   24614             :       static void rebuildStaticDataMembers ( );
   24615             :       static void writeEasyStorageDataToFile (std::ostream& out);
   24616             :       static void readEasyStorageDataFromFile (std::istream& in);
   24617             :       static void writeStaticDataToFile (std::ostream& out );
   24618             :       static void readStaticDataFromFile (std::istream& in );
   24619             :       friend class SgModuleSymbol;
   24620             :    };
   24621             : /* #line 24622 "../../../src/frontend/SageIII//StorageClasses.h" */
   24622             : 
   24623             : 
   24624             : 
   24625             : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarStorageClassDeclatationMacros.macro" */
   24626             : /* 
   24627             :    JH (01/01/2006) ROSETTA generated class declarations for SgInterfaceSymbolStorageClass 
   24628             :    used for the ast file IO. Do not chance by hand! 
   24629             : */
   24630           0 : class SgInterfaceSymbolStorageClass  : public SgSymbolStorageClass
   24631             :    {
   24632             : 
   24633             :     protected: 
   24634             : 
   24635             : 
   24636             : /* #line 24637 "../../../src/frontend/SageIII//StorageClasses.h" */
   24637             : 
   24638             :      unsigned long storageOf_declaration;
   24639             : 
   24640             : 
   24641             : /* #line 10 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarStorageClassDeclatationMacros.macro" */
   24642             : 
   24643             : 
   24644             :     public:
   24645             :       void pickOutIRNodeData ( SgInterfaceSymbol* source );
   24646             :       static void arrangeStaticDataOfEasyStorageClassesInOneBlock ( );
   24647             :       static void deleteStaticDataOfEasyStorageClasses ( );
   24648             :       static void pickOutStaticDataMembers ( );
   24649             :       static void rebuildStaticDataMembers ( );
   24650             :       static void writeEasyStorageDataToFile (std::ostream& out);
   24651             :       static void readEasyStorageDataFromFile (std::istream& in);
   24652             :       static void writeStaticDataToFile (std::ostream& out );
   24653             :       static void readStaticDataFromFile (std::istream& in );
   24654             :       friend class SgInterfaceSymbol;
   24655             :    };
   24656             : /* #line 24657 "../../../src/frontend/SageIII//StorageClasses.h" */
   24657             : 
   24658             : 
   24659             : 
   24660             : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarStorageClassDeclatationMacros.macro" */
   24661             : /* 
   24662             :    JH (01/01/2006) ROSETTA generated class declarations for SgCommonSymbolStorageClass 
   24663             :    used for the ast file IO. Do not chance by hand! 
   24664             : */
   24665           0 : class SgCommonSymbolStorageClass  : public SgSymbolStorageClass
   24666             :    {
   24667             : 
   24668             :     protected: 
   24669             : 
   24670             : 
   24671             : /* #line 24672 "../../../src/frontend/SageIII//StorageClasses.h" */
   24672             : 
   24673             :      unsigned long storageOf_declaration;
   24674             : 
   24675             : 
   24676             : /* #line 10 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarStorageClassDeclatationMacros.macro" */
   24677             : 
   24678             : 
   24679             :     public:
   24680             :       void pickOutIRNodeData ( SgCommonSymbol* source );
   24681             :       static void arrangeStaticDataOfEasyStorageClassesInOneBlock ( );
   24682             :       static void deleteStaticDataOfEasyStorageClasses ( );
   24683             :       static void pickOutStaticDataMembers ( );
   24684             :       static void rebuildStaticDataMembers ( );
   24685             :       static void writeEasyStorageDataToFile (std::ostream& out);
   24686             :       static void readEasyStorageDataFromFile (std::istream& in);
   24687             :       static void writeStaticDataToFile (std::ostream& out );
   24688             :       static void readStaticDataFromFile (std::istream& in );
   24689             :       friend class SgCommonSymbol;
   24690             :    };
   24691             : /* #line 24692 "../../../src/frontend/SageIII//StorageClasses.h" */
   24692             : 
   24693             : 
   24694             : 
   24695             : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarStorageClassDeclatationMacros.macro" */
   24696             : /* 
   24697             :    JH (01/01/2006) ROSETTA generated class declarations for SgAliasSymbolStorageClass 
   24698             :    used for the ast file IO. Do not chance by hand! 
   24699             : */
   24700       27969 : class SgAliasSymbolStorageClass  : public SgSymbolStorageClass
   24701             :    {
   24702             : 
   24703             :     protected: 
   24704             : 
   24705             : 
   24706             : /* #line 24707 "../../../src/frontend/SageIII//StorageClasses.h" */
   24707             : 
   24708             :      unsigned long storageOf_alias;
   24709             :       bool storageOf_isRenamed;
   24710             :       SgNameStorageClass storageOf_new_name;
   24711             :        EasyStorage < SgNodePtrList > storageOf_causal_nodes;
   24712             : 
   24713             : 
   24714             : /* #line 10 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarStorageClassDeclatationMacros.macro" */
   24715             : 
   24716             : 
   24717             :     public:
   24718             :       void pickOutIRNodeData ( SgAliasSymbol* source );
   24719             :       static void arrangeStaticDataOfEasyStorageClassesInOneBlock ( );
   24720             :       static void deleteStaticDataOfEasyStorageClasses ( );
   24721             :       static void pickOutStaticDataMembers ( );
   24722             :       static void rebuildStaticDataMembers ( );
   24723             :       static void writeEasyStorageDataToFile (std::ostream& out);
   24724             :       static void readEasyStorageDataFromFile (std::istream& in);
   24725             :       static void writeStaticDataToFile (std::ostream& out );
   24726             :       static void readStaticDataFromFile (std::istream& in );
   24727             :       friend class SgAliasSymbol;
   24728             :    };
   24729             : /* #line 24730 "../../../src/frontend/SageIII//StorageClasses.h" */
   24730             : 
   24731             :