transformationSupport.h

#ifndef ROSE_TRANSFORMATION_SUPPORT
#define ROSE_TRANSFORMATION_SUPPORT

// #include "transformationOptions.h"

#include "optionDeclaration.h"

// Access to Query Libraries
#include "roseQueryLib.h"

// include "nodeQuery.h"
// include "nameQuery.h"
// include "numberQuery.h"

class ROSE_DLL_API TransformationSupport
   {
     public:

          enum operatorCodeType
             {
               FUNCTION_CALL_OPERATOR_CODE = 0,

            // binary operators
               ADD_OPERATOR_CODE          = 1,
               SUBT_OPERATOR_CODE         = 2,
               MULT_OPERATOR_CODE         = 3,
               DIV_OPERATOR_CODE          = 4,
               INTEGER_DIV_OPERATOR_CODE  = 5,
               MOD_OPERATOR_CODE          = 6,
               AND_OPERATOR_CODE          = 7,
               OR_OPERATOR_CODE           = 8,
               BITXOR_OPERATOR_CODE       = 9,
               BITAND_OPERATOR_CODE       = 10,
               BITOR_OPERATOR_CODE        = 11,
               EQ_OPERATOR_CODE           = 12,
               LT_OPERATOR_CODE           = 13,
               GT_OPERATOR_CODE           = 14,
               NE_OPERATOR_CODE           = 15,
               LE_OPERATOR_CODE           = 16,
               GE_OPERATOR_CODE           = 17,
               ASSIGN_OPERATOR_CODE       = 18,
               PLUS_ASSIGN_OPERATOR_CODE  = 19,
               MINUS_ASSIGN_OPERATOR_CODE = 20,
               AND_ASSIGN_OPERATOR_CODE   = 21,
               IOR_ASSIGN_OPERATOR_CODE   = 22,
               MULT_ASSIGN_OPERATOR_CODE  = 23,
               DIV_ASSIGN_OPERATOR_CODE   = 24,
               MOD_ASSIGN_OPERATOR_CODE   = 25,
               XOR_ASSIGN_OPERATOR_CODE   = 26,

            // operator() and operator[]
               PARENTHESIS_OPERATOR_CODE  = 27,
               BRACKET_OPERATOR_CODE      = 28,

            // unary operators
               NOT_OPERATOR_CODE          = 29,
               DEREFERENCE_OPERATOR_CODE  = 30,
               ADDRESS_OPERATOR_CODE      = 31,
               LSHIFT_OPERATOR_CODE       = 32,
               RSHIFT_OPERATOR_CODE       = 33,
               LSHIFT_ASSIGN_OPERATOR_CODE      = 34,
               RSHIFT_ASSIGN_OPERATOR_CODE      = 35,
               PREFIX_PLUSPLUS_OPERATOR_CODE    = 36,
               POSTFIX_PLUSPLUS_OPERATOR_CODE   = 37,
               PREFIX_MINUSMINUS_OPERATOR_CODE  = 38,
               POSTFIX_MINUSMINUS_OPERATOR_CODE = 39,

            // End of list tag
               OPERATOR_CODE_LAST_TAG = 99
             };

          static std::string stringifyOperator (std::string name);

          static operatorCodeType classifyOverloadedOperator (
               std::string name,
               int numberOfParameters = 0,
               bool prefixOperator    = false);

          static std::string buildOperatorString ( SgNode* astNode );

          static std::string getFunctionName ( SgFunctionCallExp* functionCallExp );

          static std::string getTypeName ( SgType* type );

          static std::string getFunctionTypeName ( SgFunctionCallExp* functionCallExpression );

          static std::string buildMacro ( std::string s );

          static void getTransformationOptions (
                    SgNode* astNode,
                    std::list<OptionDeclaration> & variableNameList,
                    std::string identifingTypeName );

          static void getTransformationOptions (
                    SgNode* astNode,
                    std::list<int> & variableNameList,
                    std::string identifingTypeName );

          static void getTransformationOptionsFromVariableDeclarationConstructorArguments (
                    SgVariableDeclaration* variableDeclaration,
                    std::list<int> & returnList );

          static void getTransformationOptionsFromVariableDeclarationConstructorArguments (
                    SgVariableDeclaration* variableDeclaration,
                    std::list<OptionDeclaration> & returnList );
          static std::string internalSupportingGlobalDeclarations( SgNode* astNode, std::string prefixString );

       // DQ (9/26/03) Added here to eliminate ProjectQueryLibrary 
       // (which as mostly an experiment with the reverse traversal)
          static SgProject* getProject( const SgNode* astNode);
          static SgDirectory* getDirectory( const SgNode* astNode);
          static SgFile* getFile( const SgNode* astNode);
          static SgSourceFile* getSourceFile( const SgNode* astNode);
#ifdef ROSE_ENABLE_BINARY_ANALYSIS
          static SgBinaryComposite* getBinaryFile( const SgNode* astNode);
#endif
          static SgGlobal* getGlobalScope( const SgNode* astNode);
          static SgStatement* getStatement(const SgNode* astNode);
          static SgFunctionDeclaration* getFunctionDeclaration( const SgNode* astNode);
          static SgFunctionDefinition* getFunctionDefinition( const SgNode* astNode);
          static SgClassDefinition* getClassDefinition( const SgNode* astNode);
          static SgModuleStatement* getModuleStatement( const SgNode* astNode);

       // DQ (7/25/2012): Modified to reflect new template design using different types of template IR nodes.
       // static SgTemplateDeclaration* getTemplateDeclaration( const SgNode* astNode);
          static SgDeclarationStatement* getTemplateDeclaration( const SgNode* astNode);

       // DQ (8/19/2014): Iterate back through the parents and scopes to find the SgType that the current node is embedded into.
          static SgType* getAssociatedType( const SgNode* astNode );

       // DQ (5/11/2011): This function was moved to SgTemplateArgument a long time ago and is not longer available.
       // DQ (6/9/2007): This function traverses through the parents to the first scope (used for name qualification support of template arguments)
       // static SgScopeStatement* getScope(const SgNode* astNode);

       // static SgValueExp* getValueExpr(const SgNode* astNode);
   };

// endif for ROSE_TRANSFORMATION_SUPPORT
#endif