Dekker1/on-restart-benchmarks
Archived
1
0
Fork 0
Code
This repository has been archived on 2025-03-06. You can view files and clone it, but cannot push or open issues or pull requests.
on-restart-benchmarks/software/mza/include/minizinc/ast.hh

1951 lines
56 KiB
C++
Raw Blame History

/* -*- mode: C++; c-basic-offset: 2; indent-tabs-mode: nil -*- */
/*
* Main authors:
* Guido Tack <guido.tack@monash.edu>
*/
/* This Source Code Form is subject to the terms of the Mozilla Public
* License, v. 2.0. If a copy of the MPL was not distributed with this
* file, You can obtain one at http://mozilla.org/MPL/2.0/. */
#ifndef __MINIZINC_AST_HH__
#define __MINIZINC_AST_HH__
#include <minizinc/aststring.hh>
#include <minizinc/astvec.hh>
#include <minizinc/gc.hh>
#include <minizinc/type.hh>
#include <minizinc/values.hh>
#include <cstddef>
#include <cstdint>
#include <iostream>
#include <limits>
#include <utility>
#include <vector>
namespace MiniZinc {
class IntLit;
class FloatLit;
class SetLit;
class BoolLit;
class StringLit;
class Id;
class AnonVar;
class ArrayLit;
class ArrayAccess;
class Comprehension;
class ITE;
class BinOp;
class UnOp;
class Call;
class VarDecl;
class Let;
class TypeInst;
class Item;
class FunctionI;
class ExpressionSet;
class ExpressionSetIter;
/// %Location of an expression used during parsing
class ParserLocation {
protected:
/// Source code file name
ASTString _filename;
/// Line where expression starts
unsigned int _first_line;
/// Line where expression ends
unsigned int _last_line;
/// Column where expression starts
unsigned int _first_column;
/// Column where expression ends
unsigned int _last_column;
public:
/// Construct empty location
ParserLocation(void) : _first_line(1), _last_line(1), _first_column(0), _last_column(0) {}
/// Construct location
ParserLocation(const ASTString& filename, unsigned int first_line, unsigned int first_column,
unsigned int last_line, unsigned int last_column)
: _filename(filename),
_first_line(first_line),
_last_line(last_line),
_first_column(first_column),
_last_column(last_column) {}
ASTString filename(void) const { return _filename; }
void filename(const ASTString& f) { _filename = f; }
unsigned int first_line(void) const { return _first_line; }
void first_line(unsigned int l) { _first_line = l; }
unsigned int last_line(void) const { return _last_line; }
void last_line(unsigned int l) { _last_line = l; }
unsigned int first_column(void) const { return _first_column; }
void first_column(unsigned int c) { _first_column = c; }
unsigned int last_column(void) const { return _last_column; }
void last_column(unsigned int c) { _last_column = c; }
std::string toString(void) const {
std::ostringstream oss;
oss << _filename << ":" << _first_line << "." << _first_column;
if (_first_line != _last_line) {
oss << "-" << _last_line << "." << _last_column;
} else if (_first_column != _last_column) {
oss << "-" << _last_column;
}
return oss.str();
}
};
/// %Location of an expression in the source code
class Location {
protected:
/// Internal representation of a Location
/// Layout depends on sizeof pointer and arguments
/// 32 bit pointers:
/// Layout 1: filename (32 bit), first line (8 bit), last line-first line (7 bit), first column
/// (6 bit), last column (7 bit) Layout 2: filename (32 bit), 4 IntLit for the lines/columns
/// 64 bit pointers:
/// Layout 1: filename (64 bit), first line (20 bit), last line-first line (20 bit), first
/// column (10 bit), last column (10 bit) Layout 2: filename (64 bit), 4 IntLit for the
/// lines/columns
class LocVec : public ASTVec {
protected:
LocVec(const ASTString& filename, unsigned int first_line, unsigned int first_column,
unsigned int last_line, unsigned int last_column);
LocVec(const ASTString& filename, IntVal combined);
public:
static LocVec* a(const ASTString& filename, unsigned int first_line, unsigned int first_column,
unsigned int last_line, unsigned int last_column);
void mark(void) {
_gc_mark = 1;
if (_data[0]) static_cast<ASTStringO*>(_data[0])->mark();
}
ASTString filename(void) const;
unsigned int first_line(void) const;
unsigned int last_line(void) const;
unsigned int first_column(void) const;
unsigned int last_column(void) const;
};
union LI {
LocVec* lv;
ptrdiff_t t;
} _loc_info;
LocVec* lv(void) const {
LI li = _loc_info;
li.t &= ~static_cast<ptrdiff_t>(1);
return li.lv;
}
public:
/// Construct empty location
Location(void) { _loc_info.lv = NULL; }
/// Construct location
Location(const ASTString& filename, unsigned int first_line, unsigned int first_column,
unsigned int last_line, unsigned int last_column) {
if (last_line < first_line) throw InternalError("invalid location");
_loc_info.lv = LocVec::a(filename, first_line, first_column, last_line, last_column);
}
Location(const ParserLocation& loc) {
_loc_info.lv = LocVec::a(loc.filename(), loc.first_line(), loc.first_column(), loc.last_line(),
loc.last_column());
}
/// Return string representation
std::string toString(void) const;
/// Return filename
ASTString filename(void) const { return lv() ? lv()->filename() : ASTString(); }
/// Return first line number
unsigned int first_line(void) const { return lv() ? lv()->first_line() : 0; }
/// Return last line number
unsigned int last_line(void) const { return lv() ? lv()->last_line() : 0; }
/// Return first column number
unsigned int first_column(void) const { return lv() ? lv()->first_column() : 0; }
/// Return last column number
unsigned int last_column(void) const { return lv() ? lv()->last_column() : 0; }
/// Return whether location is introduced by the compiler
bool is_introduced(void) const { return _loc_info.lv == NULL || ((_loc_info.t & 1) != 0); }
/// Mark as alive for garbage collection
void mark(void) const;
/// Return location with introduced flag set
Location introduce(void) const;
/// Location used for un-allocated expressions
static Location nonalloc;
ParserLocation parserLocation(void) const {
return ParserLocation(filename(), first_line(), first_column(), last_line(), last_column());
}
};
/// Output operator for locations
template <class Char, class Traits>
std::basic_ostream<Char, Traits>& operator<<(std::basic_ostream<Char, Traits>& os,
const Location& loc) {
std::basic_ostringstream<Char, Traits> s;
s.copyfmt(os);
s.width(0);
if (loc.filename() == "") {
s << "unknown file";
} else {
s << loc.filename();
}
s << ":" << loc.first_line() << "." << loc.first_column();
if (loc.first_line() != loc.last_line()) {
s << "-" << loc.last_line() << "." << loc.last_column();
} else if (loc.first_column() != loc.last_column()) {
s << "-" << loc.last_column();
}
return os << s.str();
}
/**
* \brief Annotations
*/
class Annotation {
private:
ExpressionSet* _s;
/// Delete
Annotation(const Annotation&);
/// Delete
Annotation& operator=(const Annotation&);
public:
Annotation(void) : _s(NULL) {}
~Annotation(void);
bool contains(Expression* e) const;
bool containsCall(const ASTString& id) const;
bool isEmpty(void) const;
ExpressionSetIter begin(void) const;
ExpressionSetIter end(void) const;
void add(Expression* e);
void add(std::vector<Expression*> e);
void remove(Expression* e);
void removeCall(const ASTString& id);
void clear(void);
void merge(const Annotation& ann);
Call* getCall(const ASTString& id) const;
static Annotation empty;
};
/// returns the Annotation specified by the string; returns NULL if not exists
Expression* getAnnotation(const Annotation& ann, std::string str);
/// returns the Annotation specified by the string; returns NULL if not exists
Expression* getAnnotation(const Annotation& ann, const ASTString& str);
/**
* \brief Base class for expressions
*/
class Expression : public ASTNode {
protected:
/// The %MiniZinc type of the expression
Type _type;
/// The annotations
Annotation _ann;
/// The location of the expression
Location _loc;
/// The hash value of the expression
size_t _hash;
public:
/// Identifier of the concrete expression type
enum ExpressionId {
E_INTLIT = ASTNode::NID_END + 1,
E_FLOATLIT,
E_SETLIT,
E_BOOLLIT,
E_STRINGLIT,
E_ID,
E_ANON,
E_ARRAYLIT,
E_ARRAYACCESS,
E_COMP,
E_ITE,
E_BINOP,
E_UNOP,
E_CALL,
E_VARDECL,
E_LET,
E_TI,
E_TIID,
EID_END = E_TIID
};
bool isUnboxedVal(void) const {
if (sizeof(double) <= sizeof(FloatLit*)) {
// bit 1 or bit 0 is set
return (reinterpret_cast<ptrdiff_t>(this) & static_cast<ptrdiff_t>(3)) != 0;
} else {
// bit 0 is set
return (reinterpret_cast<ptrdiff_t>(this) & static_cast<ptrdiff_t>(1)) != 0;
}
}
bool isUnboxedInt(void) const {
if (sizeof(double) <= sizeof(FloatLit*)) {
// bit 1 is set, bit 0 is not set
return (reinterpret_cast<ptrdiff_t>(this) & static_cast<ptrdiff_t>(3)) == 2;
} else {
// bit 0 is set
return (reinterpret_cast<ptrdiff_t>(this) & static_cast<ptrdiff_t>(1)) == 1;
}
}
bool isUnboxedFloatVal(void) const {
// bit 0 is set (and doubles fit inside pointers)
return (sizeof(double) <= sizeof(FloatLit*)) &&
(reinterpret_cast<ptrdiff_t>(this) & static_cast<ptrdiff_t>(1)) == 1;
}
ExpressionId eid(void) const {
return isUnboxedInt() ? E_INTLIT
: isUnboxedFloatVal() ? E_FLOATLIT
: static_cast<ExpressionId>(_id);
}
const Location& loc(void) const { return isUnboxedVal() ? Location::nonalloc : _loc; }
void loc(const Location& l) {
if (!isUnboxedVal()) _loc = l;
}
const Type& type(void) const {
return isUnboxedInt() ? Type::unboxedint : isUnboxedFloatVal() ? Type::unboxedfloat : _type;
}
void type(const Type& t);
size_t hash(void) const {
return isUnboxedInt() ? unboxedIntToIntVal().hash()
: isUnboxedFloatVal() ? unboxedFloatToFloatVal().hash()
: _hash;
}
protected:
/// Combination function for hash values
void cmb_hash(size_t h) { _hash ^= h + 0x9e3779b9 + (_hash << 6) + (_hash >> 2); }
/// Combination function for hash values
size_t cmb_hash(size_t seed, size_t h) {
seed ^= h + 0x9e3779b9 + (seed << 6) + (seed >> 2);
return seed;
}
/// Compute base hash value
void init_hash(void) { _hash = cmb_hash(0, _id); }
/// Check if \a e0 and \a e1 are equal
static bool equal_internal(const Expression* e0, const Expression* e1);
/// Constructor
Expression(const Location& loc, const ExpressionId& eid, const Type& t)
: ASTNode(eid), _type(t), _loc(loc) {}
public:
IntVal unboxedIntToIntVal(void) const {
assert(isUnboxedInt());
if (sizeof(double) <= sizeof(FloatVal*)) {
unsigned long long int i = reinterpret_cast<ptrdiff_t>(this) & ~static_cast<ptrdiff_t>(7);
bool pos = ((reinterpret_cast<ptrdiff_t>(this) & static_cast<ptrdiff_t>(4)) == 0);
if (pos) {
return i >> 3;
} else {
return -(static_cast<long long int>(i >> 3));
}
} else {
unsigned long long int i = reinterpret_cast<ptrdiff_t>(this) & ~static_cast<ptrdiff_t>(3);
bool pos = ((reinterpret_cast<ptrdiff_t>(this) & static_cast<ptrdiff_t>(2)) == 0);
if (pos) {
return i >> 2;
} else {
return -(static_cast<long long int>(i >> 2));
}
}
}
static IntLit* intToUnboxedInt(long long int i) {
static const unsigned int pointerBits = sizeof(IntLit*) * 8;
if (sizeof(double) <= sizeof(FloatVal*)) {
static const long long int maxUnboxedVal =
(static_cast<long long int>(1) << (pointerBits - 3)) - static_cast<long long int>(1);
if (i < -maxUnboxedVal || i > maxUnboxedVal) return NULL;
long long int j = i < 0 ? -i : i;
ptrdiff_t ubi_p = (static_cast<ptrdiff_t>(j) << 3) | static_cast<ptrdiff_t>(2);
if (i < 0) ubi_p = ubi_p | static_cast<ptrdiff_t>(4);
return reinterpret_cast<IntLit*>(ubi_p);
} else {
static const long long int maxUnboxedVal =
(static_cast<long long int>(1) << (pointerBits - 2)) - static_cast<long long int>(1);
if (i < -maxUnboxedVal || i > maxUnboxedVal) return NULL;
long long int j = i < 0 ? -i : i;
ptrdiff_t ubi_p = (static_cast<ptrdiff_t>(j) << 2) | static_cast<ptrdiff_t>(1);
if (i < 0) ubi_p = ubi_p | static_cast<ptrdiff_t>(2);
return reinterpret_cast<IntLit*>(ubi_p);
}
}
FloatVal unboxedFloatToFloatVal(void) const {
assert(isUnboxedFloatVal());
union {
double d;
uint64_t bits;
const Expression* p;
} _u;
_u.p = this;
_u.bits = _u.bits >> 1;
uint64_t exponent = (_u.bits & (static_cast<uint64_t>(0x3FF) << 52)) >> 52;
if (exponent != 0) {
exponent += 512; // reconstruct original bias of 1023
}
uint64_t sign = (_u.bits & (static_cast<uint64_t>(1) << 62) ? 1 : 0);
_u.bits = (sign << 63) | (exponent << 52) | (_u.bits & static_cast<uint64_t>(0xFFFFFFFFFFFFF));
return _u.d;
}
static FloatLit* doubleToUnboxedFloatVal(double d) {
if (sizeof(double) > sizeof(FloatLit*)) return NULL;
union {
double d;
uint64_t bits;
FloatLit* p;
} _u;
_u.d = d;
uint64_t exponent = (_u.bits & (static_cast<uint64_t>(0x7FF) << 52)) >> 52;
if (exponent != 0) {
if (exponent < 513 || exponent > 1534) return NULL; // exponent doesn't fit in 10 bits
exponent -= 512; // make exponent fit in 10 bits, with bias 511
}
bool sign = (_u.bits & (static_cast<uint64_t>(1) << 63)) != 0;
_u.bits = _u.bits &
~(static_cast<uint64_t>(0x7FF) << 52); // mask out top 11 bits (previously exponent)
_u.bits = (_u.bits << 1) | 1u; // shift by one bit and add tag for double
_u.bits =
_u.bits | (static_cast<uint64_t>(sign) << 63) | (static_cast<uint64_t>(exponent) << 53);
return _u.p;
}
bool isTagged(void) const {
// only bit 2 is set
if (isUnboxedVal()) return false;
if (sizeof(double) <= sizeof(FloatVal*))
return (reinterpret_cast<ptrdiff_t>(this) & static_cast<ptrdiff_t>(7)) == 4;
else
return (reinterpret_cast<ptrdiff_t>(this) & static_cast<ptrdiff_t>(3)) == 2;
}
Expression* tag(void) const {
assert(!isUnboxedVal());
if (sizeof(double) <= sizeof(FloatVal*))
return reinterpret_cast<Expression*>(reinterpret_cast<ptrdiff_t>(this) |
static_cast<ptrdiff_t>(4));
else
return reinterpret_cast<Expression*>(reinterpret_cast<ptrdiff_t>(this) |
static_cast<ptrdiff_t>(2));
}
Expression* untag(void) {
if (isUnboxedVal()) return this;
if (sizeof(double) <= sizeof(FloatVal*))
return reinterpret_cast<Expression*>(reinterpret_cast<ptrdiff_t>(this) &
~static_cast<ptrdiff_t>(4));
else
return reinterpret_cast<Expression*>(reinterpret_cast<ptrdiff_t>(this) &
~static_cast<ptrdiff_t>(2));
}
/// Test if expression is of type \a T
template <class T>
bool isa(void) const {
#ifdef __clang__
#pragma clang diagnostic push
#pragma clang diagnostic ignored "-Wtautological-undefined-compare"
#endif
if (nullptr == this) throw InternalError("isa: nullptr");
#ifdef __clang__
#pragma clang diagnostic pop
#endif
return isUnboxedInt() ? T::eid == E_INTLIT
: isUnboxedFloatVal() ? T::eid == E_FLOATLIT
: _id == T::eid;
}
/// Cast expression to type \a T*
template <class T>
T* cast(void) {
assert(isa<T>());
return static_cast<T*>(this);
}
/// Cast expression to type \a const T*
template <class T>
const T* cast(void) const {
assert(isa<T>());
return static_cast<const T*>(this);
}
/// Cast expression to type \a T* or NULL if types do not match
template <class T>
T* dyn_cast(void) {
return isa<T>() ? static_cast<T*>(this) : NULL;
}
/// Cast expression to type \a const T* or NULL if types do not match
template <class T>
const T* dyn_cast(void) const {
return isa<T>() ? static_cast<const T*>(this) : NULL;
}
/// Cast expression to type \a T*
template <class T>
static T* cast(Expression* e) {
return e == NULL ? NULL : e->cast<T>();
}
/// Cast expression to type \a const T*
template <class T>
static const T* cast(const Expression* e) {
return e == NULL ? NULL : e->cast<T>();
}
/// Cast expression to type \a T* or NULL if types do not match
template <class T>
static T* dyn_cast(Expression* e) {
return e == NULL ? NULL : e->dyn_cast<T>();
}
/// Cast expression to type \a const T* or NULL if types do not match
template <class T>
static const T* dyn_cast(const Expression* e) {
return e == NULL ? NULL : e->dyn_cast<T>();
}
/// Add annotation \a ann to the expression
void addAnnotation(Expression* ann);
/// Add annotation \a ann to the expression
void addAnnotations(std::vector<Expression*> ann);
const Annotation& ann(void) const { return isUnboxedVal() ? Annotation::empty : _ann; }
Annotation& ann(void) { return isUnboxedVal() ? Annotation::empty : _ann; }
/// Return hash value of \a e
static size_t hash(const Expression* e) { return e == NULL ? 0 : e->hash(); }
/// Check if \a e0 and \a e1 are equal
static bool equal(const Expression* e0, const Expression* e1);
/// Mark \a e as alive for garbage collection
static void mark(Expression* e);
};
/// \brief Integer literal expression
class IntLit : public Expression {
protected:
/// The value of this expression
IntVal _v;
/// Constructor
IntLit(const Location& loc, IntVal v);
public:
/// The identifier of this expression type
static const ExpressionId eid = E_INTLIT;
/// Access value
IntVal v(void) const { return isUnboxedInt() ? unboxedIntToIntVal() : _v; }
/// Recompute hash value
void rehash(void);
/// Allocate literal
static IntLit* a(IntVal v);
/// Allocate literal for enumerated type (only used internally for generators)
static IntLit* aEnum(IntVal v, unsigned int enumId);
};
/// \brief Float literal expression
class FloatLit : public Expression {
protected:
/// The value of this expression
FloatVal _v;
/// Constructor
FloatLit(const Location& loc, FloatVal v);
public:
/// The identifier of this expression type
static const ExpressionId eid = E_FLOATLIT;
/// Access value
FloatVal v(void) const { return isUnboxedFloatVal() ? unboxedFloatToFloatVal() : _v; }
/// Recompute hash value
void rehash(void);
/// Allocate literal
static FloatLit* a(FloatVal v);
};
/// \brief Set literal expression
class SetLit : public Expression {
protected:
/// The value of this expression
ASTExprVec<Expression> _v;
union {
/// A range-list based representation for an integer set, or NULL
IntSetVal* isv;
/// A range-list based representation for an float set, or NULL
FloatSetVal* fsv;
} _u;
public:
/// The identifier of this expression type
static const ExpressionId eid = E_SETLIT;
/// Construct set \$f\{v1,\dots,vn\}\$f
SetLit(const Location& loc, const std::vector<Expression*>& v);
/// Construct set \$f\{v1,\dots,vn\}\$f
SetLit(const Location& loc, ASTExprVec<Expression> v);
/// Construct set
SetLit(const Location& loc, IntSetVal* isv);
/// Construct set
SetLit(const Location& loc, FloatSetVal* fsv);
/// Access value
ASTExprVec<Expression> v(void) const { return _v; }
/// Set value
void v(const ASTExprVec<Expression>& val) { _v = val; }
/// Access integer set value if present
IntSetVal* isv(void) const { return type().bt() == Type::BT_INT ? _u.isv : NULL; }
/// Set integer set value
void isv(IntSetVal* val) { _u.isv = val; }
/// Access float set value if present
FloatSetVal* fsv(void) const { return type().bt() == Type::BT_FLOAT ? _u.fsv : NULL; }
/// Set integer set value
void fsv(FloatSetVal* val) { _u.fsv = val; }
/// Recompute hash value
void rehash(void);
};
/// \brief Boolean literal expression
class BoolLit : public Expression {
protected:
/// The value of this expression
bool _v;
public:
/// The identifier of this expression type
static const ExpressionId eid = E_BOOLLIT;
/// Constructor
BoolLit(const Location& loc, bool v);
/// Access value
bool v(void) const { return _v; }
/// Recompute hash value
void rehash(void);
};
/// \brief String literal expression
class StringLit : public Expression {
protected:
/// The value of this expression
ASTString _v;
public:
/// The identifier of this expression type
static const ExpressionId eid = E_STRINGLIT;
/// Constructor
StringLit(const Location& loc, const std::string& v);
/// Constructor
StringLit(const Location& loc, const ASTString& v);
/// Access value
ASTString v(void) const { return _v; }
/// Set value
void v(const ASTString& val) { _v = val; }
/// Recompute hash value
void rehash(void);
};
/// \brief Identifier expression
class Id : public Expression {
protected:
/// The string identifier
void* _v_or_idn;
/// The declaration corresponding to this identifier (may be NULL)
Expression* _decl;
public:
/// The identifier of this expression type
static const ExpressionId eid = E_ID;
/// Constructor (\a decl may be NULL)
Id(const Location& loc, const std::string& v, VarDecl* decl);
/// Constructor (\a decl may be NULL)
Id(const Location& loc, const ASTString& v, VarDecl* decl);
/// Constructor (\a decl may be NULL)
Id(const Location& loc, long long int idn, VarDecl* decl);
/// Access identifier
ASTString v(void) const;
/// Set identifier
void v(const ASTString& val) { _v_or_idn = val.aststr(); }
/// Access identifier number
long long int idn(void) const;
/// Set identifier number
void idn(long long int n) {
_v_or_idn =
reinterpret_cast<void*>((static_cast<ptrdiff_t>(n) << 1) | static_cast<ptrdiff_t>(1));
rehash();
}
/// Return identifier or X_INTRODUCED plus identifier number
ASTString str(void) const;
/// Access declaration
VarDecl* decl(void) const {
Expression* d = _decl;
while (d && d->isa<Id>()) d = d->cast<Id>()->_decl;
return Expression::cast<VarDecl>(d);
}
/// Set declaration
void decl(VarDecl* d);
/// Redirect to another Id \a id
void redirect(Id* id) {
assert(_decl == NULL || _decl->isa<VarDecl>());
_decl = id;
}
/// Recompute hash value
void rehash(void);
};
/// \brief Type-inst identifier expression
class TIId : public Expression {
protected:
/// The string identifier
ASTString _v;
public:
/// The identifier of this expression type
static const ExpressionId eid = E_TIID;
/// Constructor
TIId(const Location& loc, const std::string& v);
/// Access identifier
ASTString v(void) const { return _v; }
/// Set identifier
void v(const ASTString& val) { _v = val; }
/// Check whether it is an enum identifier (starting with two $ signs)
bool isEnum(void) const { return _v.c_str()[0] == '$'; }
/// Recompute hash value
void rehash(void);
};
/// \brief Anonymous variable expression
class AnonVar : public Expression {
public:
/// The identifier of this expression type
static const ExpressionId eid = E_ANON;
/// Constructor
AnonVar(const Location& loc);
/// Recompute hash value
void rehash(void);
};
/// \brief Array literal expression
class ArrayLit : public Expression {
friend class Expression;
protected:
/// The array
union {
/// An expression vector (if _flag_2==false)
ASTExprVecO<Expression*>* _v;
/// Another array literal (if _flag_2==true)
ArrayLit* _al;
} _u;
/// The declared array dimensions
// If _flag_2 is true, then this is an array view. In that case,
// the _dims array holds the sliced dimensions
ASTIntVec _dims;
/// Set compressed vector (initial repetitions are removed)
void compress(const std::vector<Expression*>& v, const std::vector<int>& dims);
public:
/// Index conversion from slice to original
int origIdx(int i) const;
/// Get element \a i of a sliced array
Expression* slice_get(int i) const;
/// Set element \a i of a sliced array
void slice_set(int i, Expression* e);
public:
/// The identifier of this expression type
static const ExpressionId eid = E_ARRAYLIT;
/// Constructor
ArrayLit(const Location& loc, const std::vector<Expression*>& v,
const std::vector<std::pair<int, int> >& dims);
/// Constructor (existing content)
ArrayLit(const Location& loc, ArrayLit& v, const std::vector<std::pair<int, int> >& dims);
/// Constructor (one-dimensional, existing content)
ArrayLit(const Location& loc, ArrayLit& v);
/// Constructor (one-dimensional)
ArrayLit(const Location& loc, const std::vector<Expression*>& v);
/// Constructor (two-dimensional)
ArrayLit(const Location& loc, const std::vector<std::vector<Expression*> >& v);
/// Constructor for slices
ArrayLit(const Location& loc, ArrayLit* v, const std::vector<std::pair<int, int> >& dims,
const std::vector<std::pair<int, int> >& slice);
/// Constructor (one-dimensional)
ArrayLit(const Location& loc, const std::vector<KeepAlive>& v);
/// Recompute hash value
void rehash(void);
// The following methods are only used for copying
/// Access value
ASTExprVec<Expression> getVec(void) const {
assert(!_flag_2);
return _u._v;
}
/// Set value
void setVec(const ASTExprVec<Expression>& val) {
assert(!_flag_2);
_u._v = val.vec();
}
/// Get underlying array (if this is an array slice) or NULL
ArrayLit* getSliceLiteral(void) const { return _flag_2 ? _u._al : NULL; }
/// Get underlying _dims vector
ASTIntVec dimsInternal(void) const { return _dims; }
/// Return number of dimensions
int dims(void) const;
/// Return minimum index of dimension \a i
int min(int i) const;
/// Return maximum index of dimension \a i
int max(int i) const;
/// Return the length of the array
int length(void) const;
/// Turn into 1d array (only used at the end of flattening)
void make1d(void);
/// Check if this array was produced by flattening
bool flat(void) const { return _flag_1; }
/// Set whether this array was produced by flattening
void flat(bool b) { _flag_1 = b; }
/// Return size of underlying array
unsigned int size(void) const { return (_flag_2 || _u._v->flag()) ? length() : _u._v->size(); }
/// Access element \a i
Expression* operator[](int i) const {
return (_flag_2 || _u._v->flag()) ? slice_get(i) : (*_u._v)[i];
}
/// Set element \a i
void set(int i, Expression* e) {
if (_flag_2 || _u._v->flag()) {
slice_set(i, e);
} else {
(*_u._v)[i] = e;
}
}
};
/// \brief Array access expression
class ArrayAccess : public Expression {
protected:
/// The array to access
Expression* _v;
/// The indexes (for all array dimensions)
ASTExprVec<Expression> _idx;
public:
/// The identifier of this expression type
static const ExpressionId eid = E_ARRAYACCESS;
/// Constructor
ArrayAccess(const Location& loc, Expression* v, const std::vector<Expression*>& idx);
/// Constructor
ArrayAccess(const Location& loc, Expression* v, ASTExprVec<Expression> idx);
/// Access value
Expression* v(void) const { return _v; }
/// Set value
void v(Expression* val) { _v = val; }
/// Access index sets
ASTExprVec<Expression> idx(void) const { return _idx; }
/// Set index sets
void idx(const ASTExprVec<Expression>& idx) { _idx = idx; }
/// Recompute hash value
void rehash(void);
};
/**
* \brief Generators for comprehensions
*
* A generator consists of a list of variable declarations, one for
* each generated variable, and the expression to generate. E.g.,
* the Zinc expression [ x[i,j,k] | i,j in 1..10, k in 1..5] contains
* two generators. The first one has variable declarations for i and j
* and the expression 1..10, and the second one has a variable declaration
* for k and the expression 1..5.
*
*/
class Generator {
friend class Comprehension;
protected:
/// Variable declarations
std::vector<VarDecl*> _v;
/// in-expression
Expression* _in;
/// where-expression
Expression* _where;
public:
/// Allocate
Generator(const std::vector<std::string>& v, Expression* in, Expression* where);
/// Allocate
Generator(const std::vector<ASTString>& v, Expression* in, Expression* where);
/// Allocate
Generator(const std::vector<Id*>& v, Expression* in, Expression* where);
/// Allocate
Generator(const std::vector<VarDecl*>& v, Expression* in, Expression* where);
/// Allocate single where clause (without generator) at position \a pos
Generator(int pos, Expression* where);
};
/// \brief A list of generators with one where-expression
struct Generators {
/// %Generators
std::vector<Generator> _g;
/// Constructor
Generators(void) {}
};
/// \brief An expression representing an array- or set-comprehension
class Comprehension : public Expression {
friend class Expression;
protected:
/// The expression to generate
Expression* _e;
/// A list of generator expressions
ASTExprVec<Expression> _g;
/// A list of indices where generators start
ASTIntVec _g_idx;
public:
/// The identifier of this expression type
static const ExpressionId eid = E_COMP;
/// Constructor
Comprehension(const Location& loc, Expression* e, Generators& g, bool set);
/// Recompute hash value
void rehash(void);
/// Whether comprehension is a set
bool set(void) const;
/// Return number of generators
int n_generators(void) const;
/// Return "in" expression for generator \a i
Expression* in(int i);
/// Return "in" expression for generator \a i
const Expression* in(int i) const;
/// Return number of declarations for generator \a i
int n_decls(int i) const;
/// Return declaration \a i for generator \a gen
VarDecl* decl(int gen, int i);
/// Return declaration \a i for generator \a gen
const VarDecl* decl(int gen, int i) const;
/// Return where clause for generator \a i
Expression* where(int i);
/// Return where clause for generator \a i
const Expression* where(int i) const;
/// Return generator body
Expression* e(void) const { return _e; }
/// Set generator body
void e(Expression* e0) { _e = e0; }
/// Re-construct (used for copying)
void init(Expression* e, Generators& g);
};
/// \brief If-then-else expression
class ITE : public Expression {
friend class Expression;
protected:
/// List of if-then-pairs
ASTExprVec<Expression> _e_if_then;
/// Else-expression
Expression* _e_else;
public:
/// The identifier of this expression type
static const ExpressionId eid = E_ITE;
/// Constructor
ITE(const Location& loc, const std::vector<Expression*>& e_if_then, Expression* e_else);
int size(void) const { return _e_if_then.size() / 2; }
Expression* e_if(int i) { return _e_if_then[2 * i]; }
Expression* e_then(int i) { return _e_if_then[2 * i + 1]; }
Expression* e_else(void) { return _e_else; }
const Expression* e_if(int i) const { return _e_if_then[2 * i]; }
const Expression* e_then(int i) const { return _e_if_then[2 * i + 1]; }
const Expression* e_else(void) const { return _e_else; }
void e_then(int i, Expression* e) { _e_if_then[2 * i + 1] = e; }
void e_else(Expression* e) { _e_else = e; }
/// Recompute hash value
void rehash(void);
/// Re-construct (used for copying)
void init(const std::vector<Expression*>& e_if_then, Expression* e_else);
};
/// Type of binary operators
enum BinOpType {
BOT_PLUS,
BOT_MINUS,
BOT_MULT,
BOT_DIV,
BOT_IDIV,
BOT_MOD,
BOT_POW,
BOT_LE,
BOT_LQ,
BOT_GR,
BOT_GQ,
BOT_EQ,
BOT_NQ,
BOT_IN,
BOT_SUBSET,
BOT_SUPERSET,
BOT_UNION,
BOT_DIFF,
BOT_SYMDIFF,
BOT_INTERSECT,
BOT_PLUSPLUS,
BOT_EQUIV,
BOT_IMPL,
BOT_RIMPL,
BOT_OR,
BOT_AND,
BOT_XOR,
BOT_DOTDOT
};
/// \brief Binary-operator expression
class BinOp : public Expression {
protected:
/// Left hand side expression
Expression* _e0;
/// Right hand side expression
Expression* _e1;
/// The predicate or function declaration (or NULL)
FunctionI* _decl;
public:
/// The identifier of this expression type
static const ExpressionId eid = E_BINOP;
/// Constructor
BinOp(const Location& loc, Expression* e0, BinOpType op, Expression* e1);
/// Access left hand side
Expression* lhs(void) const { return _e0; }
/// Set left hand side
void lhs(Expression* e) { _e0 = e; }
/// Access right hand side
Expression* rhs(void) const { return _e1; }
/// Set right hand side
void rhs(Expression* e) { _e1 = e; }
/// Access argument \a i
Expression* arg(int i) {
assert(i == 0 || i == 1);
return i == 0 ? _e0 : _e1;
}
/// Return number of arguments
unsigned int n_args(void) const { return 2; }
/// Access declaration
FunctionI* decl(void) const { return _decl; }
/// Set declaration
void decl(FunctionI* f) { _decl = f; }
/// Return string representation of the operator
ASTString opToString(void) const;
/// Recompute hash value
void rehash(void);
/// Return operator type
BinOpType op(void) const;
};
/// Type of unary operators
enum UnOpType { UOT_NOT, UOT_PLUS, UOT_MINUS };
/// \brief Unary-operator expressions
class UnOp : public Expression {
protected:
/// %Expression
Expression* _e0;
/// The predicate or function declaration (or NULL)
FunctionI* _decl;
public:
/// The identifier of this expression type
static const ExpressionId eid = E_UNOP;
/// Constructor
UnOp(const Location& loc, UnOpType op, Expression* e);
/// Access expression
Expression* e(void) const { return _e0; }
/// Set expression
void e(Expression* e0) { _e0 = e0; }
/// Access argument \a i
Expression* arg(int i) {
assert(i == 0);
return _e0;
}
/// Return number of arguments
unsigned int n_args(void) const { return 1; }
/// Access declaration
FunctionI* decl(void) const { return _decl; }
/// Set declaration
void decl(FunctionI* f) { _decl = f; }
ASTString opToString(void) const;
/// Recompute hash value
void rehash(void);
/// Return operator type
UnOpType op(void) const;
};
/// \brief A predicate or function call expression
class Call : public Expression {
friend class Expression;
protected:
union {
/// Identifier of called predicate or function
ASTStringO* _id;
/// The predicate or function declaration (or NULL)
FunctionI* _decl;
} _u_id;
union {
/// Single-argument call (tagged pointer)
Expression* _oneArg;
/// Arguments to the call
ASTExprVecO<Expression*>* _args;
} _u;
/// Check if _u_id contains an id or a decl
bool hasId(void) const;
public:
/// The identifier of this expression type
static const ExpressionId eid = E_CALL;
/// Constructor
Call(const Location& loc, const std::string& id, const std::vector<Expression*>& args);
/// Constructor
Call(const Location& loc, const ASTString& id, const std::vector<Expression*>& args);
/// Access identifier
ASTString id(void) const;
/// Set identifier (overwrites decl)
void id(const ASTString& i);
/// Number of arguments
unsigned int n_args(void) const {
return _u._oneArg->isUnboxedVal() || _u._oneArg->isTagged() ? 1 : _u._args->size();
}
/// Access argument \a i
Expression* arg(int i) const {
assert(i < n_args());
if (_u._oneArg->isUnboxedVal() || _u._oneArg->isTagged()) {
assert(i == 0);
return _u._oneArg->isUnboxedVal() ? _u._oneArg : _u._oneArg->untag();
} else {
return (*_u._args)[i];
}
}
/// Set argument \a i
void arg(int i, Expression* e) {
assert(i < n_args());
if (_u._oneArg->isUnboxedVal() || _u._oneArg->isTagged()) {
assert(i == 0);
_u._oneArg = e->isUnboxedVal() ? e : e->tag();
} else {
(*_u._args)[i] = e;
}
}
/// Set arguments
void args(const ASTExprVec<Expression>& a) {
if (a.size() == 1) {
_u._oneArg = a[0]->isUnboxedVal() ? a[0] : a[0]->tag();
} else {
_u._args = a.vec();
assert(!_u._oneArg->isTagged());
}
}
/// Access declaration
FunctionI* decl(void) const;
/// Set declaration (overwrites id)
void decl(FunctionI* f);
/// Recompute hash value
void rehash(void);
};
/// \brief A variable declaration expression
class VarDecl : public Expression {
protected:
/// Type-inst of the declared variable
TypeInst* _ti;
/// Identifier
Id* _id;
/// Initialisation expression (can be NULL)
Expression* _e;
/// Flattened version of the VarDecl
WeakRef _flat;
/// Integer payload
int _payload;
public:
/// The identifier of this expression type
static const ExpressionId eid = E_VARDECL;
/// Constructor
VarDecl(const Location& loc, TypeInst* ti, const std::string& id, Expression* e = NULL);
/// Constructor
VarDecl(const Location& loc, TypeInst* ti, const ASTString& id, Expression* e = NULL);
// Constructor
VarDecl(const Location& loc, TypeInst* ti, long long int idn, Expression* e = NULL);
/// Constructor
VarDecl(const Location& loc, TypeInst* ti, Id* id, Expression* e = NULL);
/// Access TypeInst
TypeInst* ti(void) const { return _ti; }
/// Set TypeInst
void ti(TypeInst* t) { _ti = t; }
/// Access identifier
Id* id(void) const { return _id; }
/// Access initialisation expression
Expression* e(void) const;
/// Set initialisation expression
void e(Expression* rhs);
/// Access flattened version
VarDecl* flat(void) { return _flat() ? _flat()->cast<VarDecl>() : NULL; }
/// Set flattened version
void flat(VarDecl* vd);
/// Recompute hash value
void rehash(void);
/// Whether variable is toplevel
bool toplevel(void) const;
/// Whether variable is toplevel
void toplevel(bool t);
/// Whether variable is introduced
bool introduced(void) const;
/// Whether variable is introduced
void introduced(bool t);
/// Whether variable has been evaluated
bool evaluated(void) const;
/// Whether variable has been evaluated
void evaluated(bool t);
/// Access payload
int payload(void) const { return _payload; }
/// Set payload
void payload(int i) { _payload = i; }
/// Put current value on trail
void trail(void);
};
class EnvI;
class CopyMap;
/// \brief %Let expression
class Let : public Expression {
friend Expression* copy(EnvI& env, CopyMap& m, Expression* e, bool followIds, bool copyFundecls,
bool isFlatModel);
friend class Expression;
protected:
/// List of local declarations
ASTExprVec<Expression> _let;
/// Copy of original local declarations
ASTExprVec<Expression> _let_orig;
/// Body of the let
Expression* _in;
public:
/// The identifier of this expression type
static const ExpressionId eid = E_LET;
/// Constructor
Let(const Location& loc, const std::vector<Expression*>& let, Expression* in);
/// Recompute hash value
void rehash(void);
/// Access local declarations
ASTExprVec<Expression> let(void) const { return _let; }
/// Access local declarations
ASTExprVec<Expression> let_orig(void) const { return _let_orig; }
/// Access body
Expression* in(void) const { return _in; }
/// Remember current let bindings
void pushbindings(void);
/// Restore previous let bindings
void popbindings(void);
};
/// \brief Type-inst expression
class TypeInst : public Expression {
protected:
/// Ranges of an array expression
ASTExprVec<TypeInst> _ranges;
/// Declared domain (or NULL)
Expression* _domain;
public:
/// The identifier of this expression type
static const ExpressionId eid = E_TI;
/// Constructor
TypeInst(const Location& loc, const Type& t, ASTExprVec<TypeInst> ranges,
Expression* domain = NULL);
/// Constructor
TypeInst(const Location& loc, const Type& t, Expression* domain = NULL);
/// Access ranges
ASTExprVec<TypeInst> ranges(void) const { return _ranges; }
/// Access domain
Expression* domain(void) const { return _domain; }
//// Set domain
void domain(Expression* d) { _domain = d; }
/// Set ranges to \a ranges
void setRanges(const std::vector<TypeInst*>& ranges);
bool isarray(void) const { return _ranges.size() > 0; }
bool hasTiVariable(void) const;
/// Recompute hash value
void rehash(void);
/// Check if domain is computed from right hand side of variable
bool computedDomain(void) const { return _flag_1; }
/// Set if domain is computed from right hand side of variable
void setComputedDomain(bool b) { _flag_1 = b; }
/// Check if this TypeInst represents an enum
bool isEnum(void) const { return _flag_2; }
/// Set if this TypeInst represents an enum
void setIsEnum(bool b) { _flag_2 = b; }
};
/**
* \brief Base-class for items
*/
class Item : public ASTNode {
protected:
/// Location of the item
Location _loc;
public:
/// Identifier of the concrete item type
enum ItemId {
II_INC = Expression::EID_END + 1,
II_VD,
II_ASN,
II_CON,
II_SOL,
II_OUT,
II_FUN,
II_END = II_FUN
};
ItemId iid(void) const { return static_cast<ItemId>(_id); }
const Location& loc(void) const { return _loc; }
protected:
/// Constructor
Item(const Location& loc, const ItemId& iid) : ASTNode(iid), _loc(loc) { _flag_1 = false; }
public:
/// Test if item is of type \a T
template <class T>
bool isa(void) const {
return _id == T::iid;
}
/// Cast item to type \a T*
template <class T>
T* cast(void) {
assert(isa<T>());
return static_cast<T*>(this);
}
/// Cast expression to type \a const T*
template <class T>
const T* cast(void) const {
assert(isa<T>());
return static_cast<const T*>(this);
}
/// Cast item to type \a T* or NULL if types do not match
template <class T>
T* dyn_cast(void) {
return isa<T>() ? static_cast<T*>(this) : NULL;
}
/// Cast item to type \a const T* or NULL if types do not match
template <class T>
const T* dyn_cast(void) const {
return isa<T>() ? static_cast<const T*>(this) : NULL;
}
/// Cast item to type \a T*
template <class T>
static T* cast(Item* i) {
return i == NULL ? NULL : i->cast<T>();
}
/// Cast item to type \a const T*
template <class T>
static const T* cast(const Item* i) {
return i == NULL ? NULL : i->cast<T>();
}
/// Cast item to type \a T* or NULL if types do not match
template <class T>
static T* dyn_cast(Item* i) {
return i == NULL ? NULL : i->dyn_cast<T>();
}
/// Cast item to type \a const T* or NULL if types do not match
template <class T>
static const T* dyn_cast(const Item* i) {
return i == NULL ? NULL : i->dyn_cast<T>();
}
/// Check if item should be removed
bool removed(void) const { return _flag_1; }
/// Set flag to remove item
void remove(void) { _flag_1 = true; }
/// Unset remove item flag (only possible if not already removed by compact())
void unremove(void) { _flag_1 = false; }
};
class Model;
/// \brief Include item
class IncludeI : public Item {
protected:
/// Filename to include
ASTString _f;
/// Model for that file
Model* _m;
public:
/// The identifier of this item type
static const ItemId iid = II_INC;
/// Constructor
IncludeI(const Location& loc, const ASTString& f);
/// Access filename
ASTString f(void) const { return _f; }
/// Set filename
void f(const ASTString& nf) { _f = nf; }
/// Access model
Model* m(void) const { return _m; }
/// Set the model
void m(Model* m0, bool own = true) {
assert(_m == NULL || m0 == NULL);
_m = m0;
_flag_2 = own;
}
bool own(void) const { return _flag_2; }
};
/// \brief Variable declaration item
class VarDeclI : public Item {
protected:
/// The declaration expression
VarDecl* _e;
public:
/// The identifier of this item type
static const ItemId iid = II_VD;
/// Constructor
VarDeclI(const Location& loc, VarDecl* e);
/// Access expression
VarDecl* e(void) const { return _e; }
/// Set expression
void e(VarDecl* vd) { _e = vd; }
/// Flag used during compilation
bool flag(void) const { return _flag_2; }
/// Set flag used during compilation
void flag(bool b) { _flag_2 = b; }
};
/// \brief Assign item
class AssignI : public Item {
protected:
/// Identifier of variable to assign to
ASTString _id;
/// Expression to assign to the variable
Expression* _e;
/// Declaration of the variable to assign to
VarDecl* _decl;
public:
/// The identifier of this item type
static const ItemId iid = II_ASN;
/// Constructor
AssignI(const Location& loc, const std::string& id, Expression* e);
/// Access identifier
ASTString id(void) const { return _id; }
/// Access expression
Expression* e(void) const { return _e; }
/// Set expression
void e(Expression* e0) { _e = e0; }
/// Access declaration
VarDecl* decl(void) const { return _decl; }
/// Set declaration
void decl(VarDecl* d) { _decl = d; }
};
/// \brief Constraint item
class ConstraintI : public Item {
protected:
/// Constraint expression
Expression* _e;
public:
/// The identifier of this item type
static const ItemId iid = II_CON;
/// Constructor
ConstraintI(const Location& loc, Expression* e);
/// Access expression
Expression* e(void) const { return _e; }
/// Set expression
void e(Expression* e0) { _e = e0; }
/// Flag used during compilation
bool flag(void) const { return _flag_2; }
/// Set flag used during compilation
void flag(bool b) { _flag_2 = b; }
};
/// \brief Solve item
class SolveI : public Item {
protected:
/// Solve item annotation
Annotation _ann;
/// Expression for minimisation/maximisation (or NULL)
Expression* _e;
/// Constructor
SolveI(const Location& loc, Expression* e);
public:
/// The identifier of this item type
static const ItemId iid = II_SOL;
/// Type of solving
enum SolveType { ST_SAT, ST_MIN, ST_MAX };
/// Allocate solve satisfy item
static SolveI* sat(const Location& loc);
/// Allocate solve minimize item
static SolveI* min(const Location& loc, Expression* e);
/// Allocate solve maximize item
static SolveI* max(const Location& loc, Expression* e);
/// Access solve annotation
const Annotation& ann(void) const { return _ann; }
/// Access solve annotation
Annotation& ann(void) { return _ann; }
/// Access expression for optimisation
Expression* e(void) const { return _e; }
/// Set expression for optimisation
void e(Expression* e0) { _e = e0; }
/// Return type of solving
SolveType st(void) const;
/// Set type of solving
void st(SolveType s);
};
/// \brief Output item
class OutputI : public Item {
protected:
/// Expression to output
Expression* _e;
public:
/// The identifier of this item type
static const ItemId iid = II_OUT;
/// Constructor
OutputI(const Location& loc, Expression* e);
/// Access expression
Expression* e(void) const { return _e; }
/// Update expression
void e(Expression* e) { _e = e; }
};
class EnvI;
/// \brief Function declaration item
class FunctionI : public Item {
protected:
/// Identifier of this function
ASTString _id;
/// Type-inst of the return value
TypeInst* _ti;
/// List of parameter declarations
ASTExprVec<VarDecl> _params;
/// Annotation
Annotation _ann;
/// Function body (or NULL)
Expression* _e;
/// Whether function is defined in the standard library
bool _from_stdlib;
public:
/// The identifier of this item type
static const ItemId iid = II_FUN;
/// Type of builtin expression-valued functions
typedef Expression* (*builtin_e)(EnvI&, Call*);
/// Type of builtin int-valued functions
typedef IntVal (*builtin_i)(EnvI&, Call*);
/// Type of builtin bool-valued functions
typedef bool (*builtin_b)(EnvI&, Call*);
/// Type of builtin float-valued functions
typedef FloatVal (*builtin_f)(EnvI&, Call*);
/// Type of builtin set-valued functions
typedef IntSetVal* (*builtin_s)(EnvI&, Call*);
/// Type of builtin string-valued functions
typedef std::string (*builtin_str)(EnvI&, Call*);
/// Builtin functions (or NULL)
struct {
builtin_e e;
builtin_i i;
builtin_f f;
builtin_b b;
builtin_s s;
builtin_str str;
} _builtins;
/// Constructor
FunctionI(const Location& loc, const std::string& id, TypeInst* ti,
const std::vector<VarDecl*>& params, Expression* e = NULL);
/// Constructor
FunctionI(const Location& loc, const ASTString& id, TypeInst* ti,
const ASTExprVec<VarDecl>& params, Expression* e = NULL);
/// Access identifier
ASTString id(void) const { return _id; }
/// Access TypeInst
TypeInst* ti(void) const { return _ti; }
/// Access parameters
ASTExprVec<VarDecl> params(void) const { return _params; }
/// Access annotation
const Annotation& ann(void) const { return _ann; }
/// Access annotation
Annotation& ann(void) { return _ann; }
/// Access body
Expression* e(void) const { return _e; }
/// Set body
void e(Expression* b) { _e = b; }
/** \brief Compute return type given argument types \a ta
*/
Type rtype(EnvI& env, const std::vector<Expression*>& ta, bool strictEnums);
/** \brief Compute return type given argument types \a ta
*/
Type rtype(EnvI& env, const std::vector<Type>& ta, bool strictEnums);
/** \brief Compute expected type of argument \a n given argument types \a ta
*/
Type argtype(EnvI& env, const std::vector<Expression*>& ta, int n);
/// Return whether function is defined in the standard library
bool from_stdlib(void) const { return _from_stdlib; };
/// Mark for GC
void mark(void) {
_gc_mark = 1;
loc().mark();
}
};
/**
* \brief Visitor for expressions
*
* This class implements no-ops for all expression types.
* Override the methods to implement custom behaviour.
*/
class EVisitor {
public:
/// Visit integer literal
void vIntLit(const IntLit&) {}
/// Visit floating point literal
void vFloatLit(const FloatLit&) {}
/// Visit Boolean literal
void vBoolLit(const BoolLit&) {}
/// Visit set literal
void vSetLit(const SetLit&) {}
/// Visit string literal
void vStringLit(const StringLit&) {}
/// Visit identifier
void vId(const Id&) {}
/// Visit anonymous variable
void vAnonVar(const AnonVar&) {}
/// Visit array literal
void vArrayLit(const ArrayLit&) {}
/// Visit array access
void vArrayAccess(const ArrayAccess&) {}
/// Visit array comprehension
void vComprehension(const Comprehension&) {}
/// Visit array comprehension (only generator \a gen_i)
void vComprehensionGenerator(const Comprehension&, int gen_i) { (void)gen_i; }
/// Visit if-then-else
void vITE(const ITE&) {}
/// Visit binary operator
void vBinOp(const BinOp&) {}
/// Visit unary operator
void vUnOp(const UnOp&) {}
/// Visit call
void vCall(const Call&) {}
/// Visit let
void vLet(const Let&) {}
/// Visit variable declaration
void vVarDecl(const VarDecl&) {}
/// Visit type inst
void vTypeInst(const TypeInst&) {}
/// Visit TIId
void vTIId(const TIId&) {}
/// Determine whether to enter node
bool enter(Expression* e) { return true; }
/// Exit node after processing has finished
void exit(Expression* e) {}
};
/// Statically allocated constants
class Constants {
private:
/// Garbage collection root set for constants
Model* m;
public:
/// Literal true
BoolLit* lit_true;
/// Variable bound to true
VarDecl* var_true;
/// Literal false
BoolLit* lit_false;
/// Variable bound to false
VarDecl* var_false;
/// Special variable to signal compiler to ignore result
VarDecl* var_ignore;
/// Infinite set
SetLit* infinity;
/// Function item used to keep track of redefined variables
FunctionI* var_redef;
/// Literal absent value
Expression* absent;
/// Identifiers for builtins
struct {
ASTString forall;
ASTString forall_reif;
ASTString exists;
ASTString clause;
ASTString bool2int;
ASTString int2float;
ASTString bool2float;
ASTString assert;
ASTString trace;
ASTString sum;
ASTString lin_exp;
ASTString element;
ASTString show;
ASTString fix;
ASTString output;
struct {
ASTString lin_eq;
ASTString lin_le;
ASTString lin_ne;
ASTString plus;
ASTString minus;
ASTString times;
ASTString div;
ASTString mod;
ASTString lt;
ASTString le;
ASTString gt;
ASTString ge;
ASTString eq;
ASTString ne;
} int_;
struct {
ASTString lin_eq;
ASTString lin_le;
ASTString lin_ne;
ASTString plus;
ASTString minus;
ASTString times;
ASTString div;
ASTString mod;
ASTString lt;
ASTString le;
ASTString gt;
ASTString ge;
ASTString eq;
ASTString ne;
} int_reif;
struct {
ASTString lin_eq;
ASTString lin_le;
ASTString lin_lt;
ASTString lin_ne;
ASTString plus;
ASTString minus;
ASTString times;
ASTString div;
ASTString mod;
ASTString lt;
ASTString le;
ASTString gt;
ASTString ge;
ASTString eq;
ASTString ne;
ASTString in;
ASTString dom;
} float_;
struct {
ASTString lin_eq;
ASTString lin_le;
ASTString lin_lt;
ASTString lin_ne;
ASTString plus;
ASTString minus;
ASTString times;
ASTString div;
ASTString mod;
ASTString lt;
ASTString le;
ASTString gt;
ASTString ge;
ASTString eq;
ASTString ne;
ASTString in;
} float_reif;
ASTString bool_eq;
ASTString bool_eq_reif;
ASTString array_bool_or;
ASTString array_bool_and;
ASTString bool_clause;
ASTString bool_clause_reif;
ASTString bool_xor;
ASTString set_eq;
ASTString set_in;
ASTString set_card;
ASTString pow;
ASTString introduced_var;
ASTString anonEnumFromStrings;
} ids;
/// Identifiers for Boolean contexts
struct {
Id* root;
Id* pos;
Id* neg;
Id* mix;
} ctx;
/// Common annotations
struct {
Id* output_var;
ASTString output_array;
Id* add_to_output;
Id* output_only;
Id* mzn_check_var;
ASTString mzn_check_enum_var;
Id* is_defined_var;
ASTString defines_var;
Id* is_reverse_map;
Id* promise_total;
Id* maybe_partial;
Id* _export;
ASTString doc_comment;
ASTString mzn_path;
ASTString is_introduced;
Id* user_cut; // MIP
Id* lazy_constraint; // MIP
Id* mzn_break_here;
Id* rhs_from_assignment;
Id* domain_change_constraint;
ASTString global_register;
} ann;
/// Command line options
struct { /// basic MiniZinc command line options
ASTString cmdlineData_str;
ASTString cmdlineData_short_str;
ASTString datafile_str;
ASTString datafile_short_str;
ASTString globalsDir_str;
ASTString globalsDir_alt_str;
ASTString globalsDir_short_str;
ASTString help_str;
ASTString help_short_str;
ASTString ignoreStdlib_str;
ASTString include_str;
ASTString inputFromStdin_str;
ASTString instanceCheckOnly_str;
ASTString no_optimize_str;
ASTString no_optimize_alt_str;
ASTString no_outputOzn_str;
ASTString no_outputOzn_short_str;
ASTString no_typecheck_str;
ASTString newfzn_str;
ASTString outputBase_str;
ASTString outputFznToStdout_str;
ASTString outputFznToStdout_alt_str;
ASTString outputOznToFile_str;
ASTString outputOznToStdout_str;
ASTString outputFznToFile_str;
ASTString outputFznToFile_alt_str;
ASTString outputFznToFile_short_str;
ASTString rangeDomainsOnly_str;
ASTString statistics_str;
ASTString statistics_short_str;
ASTString stdlib_str;
ASTString verbose_str;
ASTString verbose_short_str;
ASTString version_str;
ASTString werror_str;
struct {
ASTString all_sols_str;
ASTString fzn_solver_str;
} solver;
} cli;
/// options strings to find setting in Options map
struct {
ASTString cmdlineData;
ASTString datafile;
ASTString datafiles;
ASTString fznToStdout;
ASTString fznToFile;
ASTString globalsDir;
ASTString ignoreStdlib;
ASTString includeDir;
ASTString includePaths;
ASTString instanceCheckOnly;
ASTString inputFromStdin;
ASTString model;
ASTString newfzn;
ASTString noOznOutput;
ASTString optimize;
ASTString outputBase;
ASTString oznToFile;
ASTString oznToStdout;
ASTString rangeDomainsOnly;
ASTString statistics;
ASTString stdlib;
ASTString typecheck;
ASTString verbose;
ASTString werror;
struct {
ASTString allSols;
ASTString numSols;
ASTString threads;
ASTString fzn_solver;
ASTString fzn_flags;
ASTString fzn_flag;
ASTString fzn_time_limit_ms;
ASTString fzn_sigint;
} solver;
} opts;
/// categories of the command line interface options
struct {
ASTString general;
ASTString io;
ASTString solver;
ASTString translation;
} cli_cat;
/// Keep track of allocated integer literals
std::unordered_map<IntVal, WeakRef> integerMap;
/// Keep track of allocated float literals
std::unordered_map<FloatVal, WeakRef> floatMap;
/// Constructor
Constants(void);
/// Return shared BoolLit
BoolLit* boollit(bool b) { return b ? lit_true : lit_false; }
static const int max_array_size = std::numeric_limits<int>::max() / 2;
};
/// Return static instance
Constants& constants(void);
} // namespace MiniZinc
#include <minizinc/ast.hpp>
#endif
View Git Blame Copy Permalink