Welcome to the NetCologne GmbH open source mirroring service!

This machine mirrors various open-source projects. 20 Gbit/s uplink.

If there are any issues or you want another project mirrored, please contact mirror-service -=AT=- netcologne DOT de !

include/comma/ast/DeclRewriter.h

Go to the documentation of this file.

//===-- DeclRewriter.h ---------------------------------------- -*- C++ -*-===//
//
// This file is distributed under the MIT license. See LICENSE.txt for details.
//
// Copyright (C) 2009-2010, Stephen Wilson
//
//===----------------------------------------------------------------------===//

//===----------------------------------------------------------------------===//
//===----------------------------------------------------------------------===//

#ifndef COMMA_AST_DECLREWRITER_HDR_GUARD
#define COMMA_AST_DECLREWRITER_HDR_GUARD

#include "comma/ast/AstRewriter.h"

#include "llvm/ADT/DenseMap.h"

namespace comma {

class DeclRewriter : public AstRewriter {

public:

    DeclRewriter(AstResource &resource,
                 DeclRegion *context, DeclRegion *origin)
        : AstRewriter(resource), context(context), origin(origin) { }

    DeclRewriter(const AstRewriter &rewrites,
                 DeclRegion *context, DeclRegion *origin)
        : AstRewriter(rewrites), context(context), origin(origin) { }

    void setContext(DeclRegion *context) {
        assert(context->getParent() == this->context);
        this->context = context;
    }

    void setOrigin(DeclRegion *origin) {
        assert(origin->getParent() == this->origin);
        this->origin = origin;
    }


    const DeclRegion *getContext() const { return context; }
    DeclRegion *getContext() { return context; }


    const DeclRegion *getOrigin() const { return origin; }
    DeclRegion *getOrigin() { return origin; }


    TypeDecl *rewriteTypeDecl(TypeDecl *tdecl);

    FunctionDecl *rewriteFunctionDecl(FunctionDecl *fdecl);

    ProcedureDecl *rewriteProcedureDecl(ProcedureDecl *pdecl);

    EnumerationDecl *rewriteEnumerationDecl(EnumerationDecl *edecl);

    ArrayDecl *rewriteArrayDecl(ArrayDecl *adecl);

    IntegerDecl *rewriteIntegerDecl(IntegerDecl *idecl);

    RecordDecl *rewriteRecordDecl(RecordDecl *rdecl);

    IncompleteTypeDecl *rewriteIncompleteTypeDecl(IncompleteTypeDecl *ITD);

    AccessDecl *rewriteAccessDecl(AccessDecl *access);

    CarrierDecl *rewriteCarrierDecl(CarrierDecl *carrier);

    Decl *rewriteDecl(Decl *decl);

private:
    DeclRegion *context;
    DeclRegion *origin;

    typedef llvm::DenseMap<Decl*, Decl*> DeclMap;
    DeclMap declRewrites;

    Decl *findRewrite(Decl *source) const { return declRewrites.lookup(source); }

    bool hasRewrite(Decl *source) const { return findRewrite(source) != 0; }

    void addDeclRewrite(Decl *source, Decl *target) {
        assert(!hasRewrite(source) && "Cannot override decl rewrite rules!");
        declRewrites[source] = target;
    }

    void mirrorRegion(DeclRegion *source, DeclRegion *target);

    Type *rewriteType(Type *type);
    AccessType *rewriteAccessType(AccessType *type);
    RecordType *rewriteRecordType(RecordType *type);
    ArrayType *rewriteArrayType(ArrayType *type);
    IncompleteType *rewriteIncompleteType(IncompleteType *type);

    Expr *rewriteExpr(Expr *expr);

    IntegerLiteral *rewriteIntegerLiteral(IntegerLiteral *lit);
    FunctionCallExpr *rewriteFunctionCall(FunctionCallExpr *call);
    AttribExpr *rewriteAttrib(AttribExpr *attrib);
    ConversionExpr *rewriteConversion(ConversionExpr *conv);
};

} // end comma namespace.

#endif

---