Snippet.h

// Main documentation is in the "Snippet" class.
 
#ifndef ROSE_AST_SNIPPET
#define ROSE_AST_SNIPPET
 
// rose.h and sage3basic.h should not be included in librose header files. [Robb P. Matzke 2014-10-15]
// #include "sage3basic.h"
#include "Map.h"
 
#include <boost/shared_ptr.hpp>
#include <boost/enable_shared_from_this.hpp>
 
namespace Rose {
 
typedef boost::shared_ptr<class SnippetFile> SnippetFilePtr;
 
typedef boost::shared_ptr<class Snippet> SnippetPtr;
 
struct SnippetInsertion {
    SgNode *inserted;                                   
    SgNode *original;                                   
    SgNode *insertedBefore;                             
    SnippetInsertion()
        : inserted(NULL), original(NULL), insertedBefore(NULL) {}
    SnippetInsertion(SgNode *inserted, SgNode *original, SgNode *insertedBefore)
        : inserted(inserted), original(original), insertedBefore(insertedBefore) {}
};
struct SnippetInsertion {…};
 
std::ostream& operator<<(std::ostream&, const SnippetInsertion&);
 
class SnippetFile: public boost::enable_shared_from_this<SnippetFile> {
    friend class Snippet;
private:
    std::string fileName;                               // non-canonical source file name
    SgSourceFile *ast;                                  // AST corresponding to the file; null after parse errors
 
    typedef Map<std::string/*functionName*/, std::vector<SgFunctionDefinition*> > FunctionDefinitionMap;
    FunctionDefinitionMap functions;                    // cache the functions so we don't have to do a traversal every lookup
 
    std::set<SgGlobal*> globals;                        // global scopes where this snippet has been inserted
    std::map<std::string/*filename*/, std::set<SgGlobal*>/*insertion points*/> headersIncluded;
 
    typedef Map<std::string/*fileName*/, SnippetFilePtr> Registry;
    static Registry registry;
 
    static std::vector<std::string> varNameList;        // list of variable names to use when renaming things
    bool copyAllSnippetDefinitions;                     // should all snippet definitions be copied to global scope?
 
    Map<std::string, SgTypePtrList> blackListedDeclarations; // things we don't want to copy to the target AST
 
    std::vector<SnippetInsertion> insertions;           // list of everything we've inserted related to this snippet file
 
protected:
    explicit SnippetFile(const std::string &fileName, SgSourceFile *ast=NULL)
        : fileName(fileName), ast(ast), copyAllSnippetDefinitions(false) {}
    explicit SnippetFile(const std::string &fileName, SgSourceFile *ast=NULL) {…}
 
public:
    static SnippetFilePtr instance(const std::string &fileName, SgSourceFile *snippetAst=NULL);
 
    static SnippetFilePtr lookup(const std::string &fileName);
 
    const std::string& getName() const { return fileName; }
 
    std::vector<std::string> getSnippetNames() const;
 
    SnippetPtr findSnippet(const std::string &snippetName);
 
    std::vector<SnippetPtr> findSnippets(const std::string &snippetName);
 
    void expandSnippets(SgNode *ast);
 
    bool globallyInjected(SgGlobal *destination_scope);
 
    bool fileIsIncluded(const std::string &filename, SgGlobal *destination_scope);
 
    static size_t loadVariableNames(const std::string &fileName);
 
    static std::string randomVariableName();
 
    SgFile *getAst() const { return ast; }
 
    bool getCopyAllSnippetDefinitions() const { return copyAllSnippetDefinitions; }
    void setCopyAllSnippetDefinitions(bool b=true) { copyAllSnippetDefinitions = b; }
    void clearCopyAllSnippetDefinitions() { copyAllSnippetDefinitions = false; }
    void doNotInsert(const std::string &name, SgType *type=NULL);
 
    bool isBlackListed(SgDeclarationStatement*);
 
    const std::vector<SnippetInsertion>& getInsertedItems() const { return insertions; }
 
protected:
    static SgSourceFile* parse(const std::string &fileName);
 
    void findSnippetFunctions();
 
    void addInsertionRecord(const SnippetInsertion &inserted) { insertions.push_back(inserted); }
};
class SnippetFile: public boost::enable_shared_from_this<SnippetFile> {…};
 
 
 
class Snippet {
    friend class SnippetFile;                           // for protected constructor
 
public:
    enum InsertMechanism {
        INSERT_BODY,                                    
        INSERT_STMTS,                                   
    };
    enum InsertMechanism {…};
 
    enum LocalDeclarationPosition {
        LOCDECLS_AT_BEGINNING,                          
        LOCDECLS_AT_END,                                
        LOCDECLS_AT_CURSOR                              
    };
    enum LocalDeclarationPosition {…};
 
private:
    typedef Map<SgSymbol*, SgNode*> ArgumentBindings;   // bindings from snippet formals to actual vars and/or expressions
    std::string name;                                   // name of snippet
    SnippetFilePtr file;                                // file containing the snippet definition
    SgFunctionDefinition *ast;                          // snippet definition
    InsertMechanism insertMechanism;                    // how snippet is inserted
    LocalDeclarationPosition locDeclsPosition;          // position for local declarations for INSERT_STMTS mode
    bool insertRecursively;                             // is the insert() operation recursive?
    bool fixupAst;                                      // whether to fix up the target AST after inserting things
 
protected:
    // Use one of the "instance" methods instead.
    Snippet(const std::string &name, const SnippetFilePtr &file, SgFunctionDefinition *ast)
        : name(name), file(file), ast(ast), insertMechanism(INSERT_STMTS), locDeclsPosition(LOCDECLS_AT_END),
          insertRecursively(true), fixupAst(true) {
        assert(!name.empty());
        assert(file!=NULL);
        assert(ast!=NULL);
    }
 
public:
    static SnippetPtr instance(const std::string &snippetName, const SnippetFilePtr &snippetFile);
    static SnippetPtr instanceFromFile(const std::string &snippetName, const std::string &fileName);
    const std::string& getName() const /*final*/ { return name; }
 
    SnippetFilePtr getFile() const { return file; }
 
    SgFunctionDefinition* getDefinition() const { return ast; }
 
    size_t numberOfArguments() const;
 
    InsertMechanism getInsertMechanism() const { return insertMechanism; }
    void setInsertMechanism(InsertMechanism im) { insertMechanism = im; }
    LocalDeclarationPosition getLocalDeclarationPosition() const { return locDeclsPosition; }
    void setLocalDeclarationPosition(LocalDeclarationPosition pos) { locDeclsPosition = pos; }
    bool getInsertRecursively() const { return insertRecursively; }
    void setInsertRecursively(bool b=true) { insertRecursively = b; }
    void clearInsertRecursively() { insertRecursively = false; }
    void insert(SgStatement *insertionPoint);
    void insert(SgStatement *insertionPoint, SgNode *arg1);
    void insert(SgStatement *insertionPoint, SgNode *arg1, SgNode *arg2);
    void insert(SgStatement *insertionPoint, SgNode *arg1, SgNode *arg2, SgNode *arg3);
    void insert(SgStatement *insertionPoint, SgNode *arg1, SgNode *arg2, SgNode *arg3, SgNode *arg4);
    void insert(SgStatement *insertionPoint, const std::vector<SgNode*> &args);
    bool getFixupAst() const { return fixupAst; }
    void setFixupAst(bool b=true) { fixupAst = b; }
    void clearFixupAst() { fixupAst = false; }
protected:
    void causeUnparsing(SgNode *ast, Sg_File_Info *targetLocation);
 
    static void replaceArguments(SgNode *ast, const ArgumentBindings&);
 
    static void replaceVariable(SgVarRefExp*, SgExpression*);
 
    static void removeIncludeDirectives(SgNode*);
 
    void insertRelatedThings(SgStatement *snippetInsertionPoint);
 
    void insertRelatedThingsForJava(SgStatement *snippetInsertionPoint);
 
    void insertRelatedThingsForC(SgStatement *snippetInsertionPoint);
 
    void renameTemporaries(SgNode *ast);
 
    // DQ (2/26/2014): Added functionality to address requirement to make snippet AST conform to expectations for any new transforamtion.
    /* Fixup the AST fragement being inserted into the target AST to reset all possible references to the original snippet file. */
    // void fixupSnippetInNewTargetAST(SgStatement *insertionPoint, SgStatement *toInsert);
 
};
class Snippet {…};
 
class SnippetAstTraversal {
public:
    virtual ~SnippetAstTraversal() {}
    void traverse(SgNode *ast);
    virtual void operator()(SgNode*, AstSimpleProcessing::Order) = 0;
};
class SnippetAstTraversal {…};
 
} // namespace
#endif