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/Range.h

Go to the documentation of this file.

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

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

#ifndef COMMA_AST_RANGE_HDR_GUARD
#define COMMA_AST_RANGE_HDR_GUARD

#include "comma/ast/AstBase.h"

#include "llvm/ADT/APInt.h"
#include "llvm/ADT/PointerIntPair.h"

namespace comma {

//===----------------------------------------------------------------------===//
// Range
//
class Range : public Ast {

public:
    Range(Expr *lower, Expr *upper, DiscreteType *type = 0);

    Location getLowerLocation() const;

    Location getUpperLocation() const;

    bool hasType() const { return rangeTy != 0; }

    void setType(DiscreteType *type) {
        assert(!hasType() && "Range already associated with a type!");
        rangeTy = type;
        checkAndAdjustLimits();
    }


    DiscreteType *getType() { return rangeTy; }
    const DiscreteType *getType() const { return rangeTy; }


    Expr *getLowerBound() { return lowerBound.getPointer(); }
    const Expr *getLowerBound() const { return lowerBound.getPointer(); }


    Expr *getUpperBound() { return upperBound.getPointer(); }
    const Expr *getUpperBound() const { return upperBound.getPointer(); }

    void setLowerBound(Expr *expr);

    void setUpperBound(Expr *expr);

    bool hasStaticLowerBound() const { return lowerBound.getInt(); }

    bool hasStaticUpperBound() const { return upperBound.getInt(); }

    bool isStatic() const {
        return hasStaticLowerBound() && hasStaticUpperBound();
    }

    const llvm::APInt &getStaticLowerBound() const {
        assert(hasStaticLowerBound() && "Lower bound not static!");
        return lowerValue;
    }

    const llvm::APInt &getStaticUpperBound() const {
        assert(hasStaticUpperBound() && "Upper bound not static!");
        return upperValue;
    }

    bool isNull() const;

    bool contains(const llvm::APInt &value) const;

    uint64_t length() const;

    // Support isa/dyn_cast.
    static bool classof(const Range *node) { return true; }
    static bool classof(const Ast *node) {
        return node->getKind() == AST_Range;
    }

private:
    Range(const Range &);       // Do not implement.

    void initializeStaticBounds();

    void checkAndAdjustLimits();



    void markLowerAsStatic() { lowerBound.setInt(1); }
    void markUpperAsStatic() { upperBound.setInt(1); }


    void markLowerAsDynamic() { lowerBound.setInt(0); }
    void markUpperAsDynamic() { upperBound.setInt(0); }

    typedef llvm::PointerIntPair<Expr *, 1> PtrInt;
    PtrInt lowerBound;          
    PtrInt upperBound;          
    llvm::APInt lowerValue;     
    llvm::APInt upperValue;     
    DiscreteType *rangeTy;      
};

} // end comma namespace.

#endif

---