uniqueNameTraversal.h

Go to the documentation of this file.

#pragma once
#include <rose.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()
    {
        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