lib/typecheck/Stencil.h

Go to the documentation of this file.

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

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

#ifndef COMMA_TYPECHECK_STENCIL_HDR_GUARD
#define COMMA_TYPECHECK_STENCIL_HDR_GUARD

#include "comma/ast/AstBase.h"
#include "comma/ast/Expr.h"

#include "llvm/ADT/SmallVector.h"

#include <utility>

namespace comma {

//===----------------------------------------------------------------------===//
// ASTStencil
//
class ASTStencil {

public:
    ASTStencil() { reset(); }

    void init(IdentifierInfo *name, Location loc) {
        this->name = name;
        this->location = loc;
    }

    virtual void reset() {
        validFlag = true;
        subBits = 0;
        name = 0;
        location = 0;
    }

    IdentifierInfo *getIdInfo() const { return name; }

    Location getLocation() const { return location; }

    bool isValid() const { return validFlag; }

    bool isInvalid() const { return !validFlag; }

    void markInvalid() { validFlag = false; }

protected:
    IdentifierInfo *name;
    Location location;
    unsigned validFlag : 1;
    unsigned subBits : 8*sizeof(unsigned) - 1;
};

//===----------------------------------------------------------------------===//
//  ASTStencilReseter
//
class ASTStencilReseter {
public:
    ASTStencilReseter(ASTStencil &stencil) : stencil(stencil) { }

    ~ASTStencilReseter() { stencil.reset(); }
private:
    ASTStencil &stencil;
};

//===----------------------------------------------------------------------===//
//  EnumDeclStencil
//
class EnumDeclStencil : public ASTStencil {

public:
    EnumDeclStencil() { reset(); }

    void reset() {
        ASTStencil::reset();
        elements.clear();
    }

    typedef std::pair<IdentifierInfo*, Location> IdLocPair;

    void addElement(IdentifierInfo *name, Location loc) {
        elements.push_back(IdLocPair(name, loc));
    }

    unsigned numElements() const { return elements.size(); }

    IdLocPair getElement(unsigned i) {
        assert(i < numElements() && "Index out of range!");
        return elements[i];
    }

    typedef llvm::SmallVector<IdLocPair, 8> ElemVec;

    ElemVec &getElements() { return elements; }
    const ElemVec &getElements() const { return elements; }


    typedef ElemVec::iterator elem_iterator;
    elem_iterator begin_elems() { return elements.begin(); }
    elem_iterator end_elems() { return elements.end(); }

    void markAsCharacterType() { subBits = 1; }

    bool isCharacterType() const { return subBits == 1; }

private:
    ElemVec elements;           
};

//===----------------------------------------------------------------------===//
//  SRDeclStencil
//
class SRDeclStencil : public ASTStencil {

public:
    SRDeclStencil() { reset(); }

    enum StencilKind {
        UNKNOWN_Stencil,        
        FUNCTION_Stencil,       
        PROCEDURE_Stencil       
    };

    void init(IdentifierInfo *name, Location loc, StencilKind kind) {
        ASTStencil::init(name, loc);
        this->subBits = kind;
    }

    void reset() {
        ASTStencil::reset();
        returnTy = 0;
        subBits = UNKNOWN_Stencil;
        params.clear();
    };

    bool denotesProcedure() const { return subBits == PROCEDURE_Stencil; }

    bool denotesFunction() const { return subBits == FUNCTION_Stencil; }

    void addParameter(ParamValueDecl *param) { params.push_back(param); }

    unsigned numParameters() const { return params.size(); }

    ParamValueDecl *getParameter(unsigned i) {
        assert(i < numParameters() && "Index out of range!");
        return params[i];
    }

    typedef llvm::SmallVector<ParamValueDecl*, 8> ParamVec;

    ParamVec &getParams() { return params; }
    const ParamVec &getParams() const { return params; }


    typedef ParamVec::iterator param_iterator;
    param_iterator begin_params() { return params.begin(); }
    param_iterator end_params() { return params.end(); }

    void setReturnType(TypeDecl *retTy) {
        assert(denotesFunction() && "Wrong type of stencil for return type!");
        returnTy = retTy;

    }

    TypeDecl *getReturnType() { return returnTy; }

private:
    ParamVec params;            
    TypeDecl *returnTy;         
};

} // end comma namespace.

#endif

---