uniqueNameTraversal.h

#pragma once
 
// DQ (10/5/2014): This is more strict now that we include rose_config.h in the sage3basic.h.
// #include "rose.h"
// rose.h and sage3basic.h should not be included in librose header files. [Robb P. Matzke 2014-10-15]
// #include "sage3basic.h"
 
#include <vector>
 
namespace ssa_private
{
 
class VarUniqueName : public AstAttribute
{
private:
 
    std::vector<SgInitializedName*> key;
 
    bool usesThis;
 
public:
 
    VarUniqueName() : key(), usesThis(false)
    {
    }
 
    VarUniqueName(SgInitializedName* thisNode) : usesThis(false)
    {
        key.push_back(thisNode);
    }
 
    VarUniqueName(const std::vector<SgInitializedName*>& prefix, SgInitializedName* thisNode) : usesThis(false)
    {
        key.assign(prefix.begin(), prefix.end());
        key.push_back(thisNode);
    }
 
    VarUniqueName(const VarUniqueName& other) : AstAttribute(other), usesThis(false)
    {
        key.assign(other.key.begin(), other.key.end());
    }
 
    VarUniqueName* copy() const
    {
        VarUniqueName* newName = new VarUniqueName(*this);
        return newName;
    }
 
    const std::vector<SgInitializedName*>& getKey()
    {
        return key;
    }
 
    void setKey(const std::vector<SgInitializedName*>& newKey)
    {
        key.assign(newKey.begin(), newKey.end());
    }
 
    bool getUsesThis()
    {
        return usesThis;
    }
 
    void setUsesThis(bool uses)
    {
        usesThis = uses;
    }
 
    std::string getNameString()
    {
        std::string name = "";
        std::vector<SgInitializedName*>::iterator iter;
        if (usesThis)
            name += "this->";
        for (iter = key.begin(); iter != key.end(); ++iter)
        {
            if (iter != key.begin())
            {
                name += ":";
            }
            name += (*iter)->get_name().getString();
        }
 
        return name;
    }
};
 
class VariableReferenceSet
{
    SgNode* currentVar;
 
public:
 
 
    VariableReferenceSet() : currentVar(NULL)
    {
    }
 
    VariableReferenceSet(SgNode* var)
    {
        currentVar = var;
    }
 
    SgNode* getCurrentVar()
    {
        return currentVar;
    }
};
 
class UniqueNameTraversal : public AstBottomUpProcessing<VariableReferenceSet>
{
    std::vector<SgInitializedName*> allInitNames;
 
    SgInitializedName* resolveTemporaryInitNames(SgInitializedName* name);
 
    const bool treatPointersAsStructs;
 
    const bool propagateNamesThroughComma;
 
public:
 
    static std::string varKeyTag;
 
    typedef std::vector<SgInitializedName*> VarName;
 
 
    UniqueNameTraversal(const std::vector<SgInitializedName*>& allNames,
            bool treatPointersAsStructs = true, bool propagateNamesThroughComma = true) : allInitNames(allNames),
    treatPointersAsStructs(treatPointersAsStructs), propagateNamesThroughComma(propagateNamesThroughComma)
    {
    }
 
    virtual VariableReferenceSet evaluateSynthesizedAttribute(SgNode* node, SynthesizedAttributesList attrs);
};
 
} //namespace ssa_private