1920 lines
55 KiB
C++
1920 lines
55 KiB
C++
/* -*- mode: C++; c-basic-offset: 2; indent-tabs-mode: nil -*- */
|
|
|
|
/*
|
|
* Main authors:
|
|
* Pierre Wilke <wilke.pierre@gmail.com>
|
|
* 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/. */
|
|
|
|
#include <minizinc/astexception.hh>
|
|
#include <minizinc/hash.hh>
|
|
#include <minizinc/iter.hh>
|
|
#include <minizinc/model.hh>
|
|
#include <minizinc/prettyprinter.hh>
|
|
|
|
#include <iomanip>
|
|
#include <limits>
|
|
#include <map>
|
|
#include <sstream>
|
|
#include <string>
|
|
#include <vector>
|
|
|
|
namespace MiniZinc {
|
|
|
|
int precedence(const Expression* e) {
|
|
if (const BinOp* bo = e->dyn_cast<BinOp>()) {
|
|
switch (bo->op()) {
|
|
case BOT_EQUIV:
|
|
return 1200;
|
|
case BOT_IMPL:
|
|
return 1100;
|
|
case BOT_RIMPL:
|
|
return 1100;
|
|
case BOT_OR:
|
|
return 1000;
|
|
case BOT_XOR:
|
|
return 1000;
|
|
case BOT_AND:
|
|
return 900;
|
|
case BOT_LE:
|
|
return 800;
|
|
case BOT_LQ:
|
|
return 800;
|
|
case BOT_GR:
|
|
return 800;
|
|
case BOT_GQ:
|
|
return 800;
|
|
case BOT_EQ:
|
|
return 800;
|
|
case BOT_NQ:
|
|
return 800;
|
|
case BOT_IN:
|
|
return 700;
|
|
case BOT_SUBSET:
|
|
return 700;
|
|
case BOT_SUPERSET:
|
|
return 700;
|
|
case BOT_UNION:
|
|
return 600;
|
|
case BOT_DIFF:
|
|
return 600;
|
|
case BOT_SYMDIFF:
|
|
return 600;
|
|
case BOT_DOTDOT:
|
|
return 500;
|
|
case BOT_PLUS:
|
|
return 400;
|
|
case BOT_MINUS:
|
|
return 400;
|
|
case BOT_MULT:
|
|
return 300;
|
|
case BOT_IDIV:
|
|
return 300;
|
|
case BOT_MOD:
|
|
return 300;
|
|
case BOT_DIV:
|
|
return 300;
|
|
case BOT_INTERSECT:
|
|
return 300;
|
|
case BOT_POW:
|
|
return 200;
|
|
case BOT_PLUSPLUS:
|
|
return 200;
|
|
default:
|
|
assert(false);
|
|
return -1;
|
|
}
|
|
|
|
} else if (e->isa<Let>()) {
|
|
return 1300;
|
|
|
|
} else {
|
|
return 0;
|
|
}
|
|
}
|
|
|
|
enum Assoc { AS_LEFT, AS_RIGHT, AS_NONE };
|
|
|
|
Assoc assoc(const BinOp* bo) {
|
|
switch (bo->op()) {
|
|
case BOT_LE:
|
|
case BOT_LQ:
|
|
case BOT_GR:
|
|
case BOT_GQ:
|
|
case BOT_NQ:
|
|
case BOT_EQ:
|
|
case BOT_IN:
|
|
case BOT_SUBSET:
|
|
case BOT_SUPERSET:
|
|
case BOT_DOTDOT:
|
|
return AS_NONE;
|
|
case BOT_PLUSPLUS:
|
|
return AS_RIGHT;
|
|
default:
|
|
return AS_LEFT;
|
|
}
|
|
}
|
|
|
|
enum Parentheses { PN_LEFT = 1, PN_RIGHT = 2 };
|
|
|
|
Parentheses needParens(const BinOp* bo, const Expression* left, const Expression* right) {
|
|
int pbo = precedence(bo);
|
|
int pl = precedence(left);
|
|
int pr = precedence(right);
|
|
int ret = (pbo < pl) || (pbo == pl && assoc(bo) != AS_LEFT);
|
|
ret += 2 * ((pbo < pr) || (pbo == pr && assoc(bo) != AS_RIGHT));
|
|
return static_cast<Parentheses>(ret);
|
|
}
|
|
|
|
std::string Printer::escapeStringLit(const ASTString& s) {
|
|
const char* sc = s.c_str();
|
|
std::ostringstream ret;
|
|
for (unsigned int i = 0; i < s.size(); i++) {
|
|
switch (sc[i]) {
|
|
case '\n':
|
|
ret << "\\n";
|
|
break;
|
|
case '\t':
|
|
ret << "\\t";
|
|
break;
|
|
case '"':
|
|
ret << "\\\"";
|
|
break;
|
|
case '\\':
|
|
ret << "\\\\";
|
|
break;
|
|
default:
|
|
ret << sc[i];
|
|
}
|
|
}
|
|
return ret.str();
|
|
}
|
|
|
|
void ppFloatVal(std::ostream& os, const FloatVal& fv, bool hexFloat) {
|
|
std::ostringstream oss;
|
|
if (fv.isFinite()) {
|
|
if (hexFloat) {
|
|
throw InternalError("disabled due to hexfloat being not supported by g++ 4.9");
|
|
// std::hexfloat(oss);
|
|
oss << fv.toDouble();
|
|
os << oss.str();
|
|
} else {
|
|
oss << std::setprecision(std::numeric_limits<double>::digits10 + 1);
|
|
oss << fv;
|
|
if (oss.str().find("e") == std::string::npos && oss.str().find(".") == std::string::npos)
|
|
oss << ".0";
|
|
os << oss.str();
|
|
}
|
|
} else {
|
|
if (fv.isPlusInfinity())
|
|
os << "infinity";
|
|
else
|
|
os << "-infinity";
|
|
}
|
|
}
|
|
|
|
class PlainPrinter {
|
|
public:
|
|
EnvI* env;
|
|
std::ostream& os;
|
|
bool _flatZinc;
|
|
PlainPrinter(std::ostream& os0, bool flatZinc, EnvI* env0)
|
|
: env(env0), os(os0), _flatZinc(flatZinc) {}
|
|
|
|
void p(const Type& type, const Expression* e) {
|
|
switch (type.ti()) {
|
|
case Type::TI_PAR:
|
|
break;
|
|
case Type::TI_VAR:
|
|
os << "var ";
|
|
break;
|
|
}
|
|
if (type.ot() == Type::OT_OPTIONAL) os << "opt ";
|
|
if (type.st() == Type::ST_SET) os << "set of ";
|
|
if (e == NULL) {
|
|
switch (type.bt()) {
|
|
case Type::BT_INT:
|
|
os << "int";
|
|
break;
|
|
case Type::BT_BOOL:
|
|
os << "bool";
|
|
break;
|
|
case Type::BT_FLOAT:
|
|
os << "float";
|
|
break;
|
|
case Type::BT_STRING:
|
|
os << "string";
|
|
break;
|
|
case Type::BT_ANN:
|
|
os << "ann";
|
|
break;
|
|
case Type::BT_BOT:
|
|
os << "bot";
|
|
break;
|
|
case Type::BT_TOP:
|
|
os << "top";
|
|
break;
|
|
case Type::BT_UNKNOWN:
|
|
os << "???";
|
|
break;
|
|
}
|
|
} else {
|
|
p(e);
|
|
}
|
|
}
|
|
|
|
void p(const Annotation& ann) {
|
|
for (ExpressionSetIter it = ann.begin(); it != ann.end(); ++it) {
|
|
os << ":: ";
|
|
p(*it);
|
|
}
|
|
}
|
|
|
|
void p(const Expression* e) {
|
|
if (e == NULL) return;
|
|
switch (e->eid()) {
|
|
case Expression::E_INTLIT:
|
|
os << e->cast<IntLit>()->v();
|
|
break;
|
|
case Expression::E_FLOATLIT: {
|
|
ppFloatVal(os, e->cast<FloatLit>()->v());
|
|
} break;
|
|
case Expression::E_SETLIT: {
|
|
const SetLit& sl = *e->cast<SetLit>();
|
|
if (sl.isv()) {
|
|
if (sl.isv()->size() == 0) {
|
|
os << (_flatZinc ? "1..0" : "{}");
|
|
} else if (sl.isv()->size() == 1) {
|
|
os << sl.isv()->min(0) << ".." << sl.isv()->max(0);
|
|
} else {
|
|
if (!sl.isv()->min(0).isFinite())
|
|
os << sl.isv()->min(0) << ".." << sl.isv()->max(0) << "++";
|
|
os << "{";
|
|
for (IntSetRanges isr(sl.isv()); isr();) {
|
|
if (isr.min().isFinite() && isr.max().isFinite()) {
|
|
for (IntVal i = isr.min(); i <= isr.max(); i++) {
|
|
os << i;
|
|
if (i < isr.max()) os << ",";
|
|
}
|
|
++isr;
|
|
if (isr()) os << ",";
|
|
}
|
|
}
|
|
os << "}";
|
|
if (!sl.isv()->max(sl.isv()->size() - 1).isFinite())
|
|
os << "++" << sl.isv()->min(sl.isv()->size() - 1) << ".."
|
|
<< sl.isv()->max(sl.isv()->size() - 1);
|
|
}
|
|
} else if (sl.fsv()) {
|
|
if (sl.fsv()->size() == 0) {
|
|
os << (_flatZinc ? "1.0..0.0" : "{}");
|
|
} else if (sl.fsv()->size() == 1) {
|
|
ppFloatVal(os, sl.fsv()->min(0));
|
|
os << "..";
|
|
ppFloatVal(os, sl.fsv()->max(0));
|
|
} else {
|
|
bool allSingleton = true;
|
|
for (FloatSetRanges isr(sl.fsv()); isr(); ++isr) {
|
|
if (isr.min() != isr.max()) {
|
|
allSingleton = false;
|
|
break;
|
|
}
|
|
}
|
|
if (allSingleton) {
|
|
os << "{";
|
|
bool first = true;
|
|
for (FloatSetRanges isr(sl.fsv()); isr(); ++isr) {
|
|
if (!first) os << ",";
|
|
first = false;
|
|
ppFloatVal(os, isr.min());
|
|
}
|
|
os << "}";
|
|
} else {
|
|
bool first = true;
|
|
for (FloatSetRanges isr(sl.fsv()); isr(); ++isr) {
|
|
if (!first) os << "++";
|
|
first = false;
|
|
ppFloatVal(os, isr.min());
|
|
os << "..";
|
|
ppFloatVal(os, isr.max());
|
|
}
|
|
}
|
|
}
|
|
} else {
|
|
os << "{";
|
|
for (unsigned int i = 0; i < sl.v().size(); i++) {
|
|
p(sl.v()[i]);
|
|
if (i < sl.v().size() - 1) os << ",";
|
|
}
|
|
os << "}";
|
|
}
|
|
} break;
|
|
case Expression::E_BOOLLIT:
|
|
os << (e->cast<BoolLit>()->v() ? "true" : "false");
|
|
break;
|
|
case Expression::E_STRINGLIT:
|
|
os << "\"" << Printer::escapeStringLit(e->cast<StringLit>()->v()) << "\"";
|
|
break;
|
|
case Expression::E_ID: {
|
|
if (e == constants().absent) {
|
|
os << "<>";
|
|
} else {
|
|
const Id* id = e->cast<Id>();
|
|
if (id->decl()) id = id->decl()->id();
|
|
if (id->idn() == -1) {
|
|
os << id->v();
|
|
} else {
|
|
os << "X_INTRODUCED_" << id->idn() << "_";
|
|
}
|
|
}
|
|
} break;
|
|
case Expression::E_TIID:
|
|
os << "$" << e->cast<TIId>()->v();
|
|
break;
|
|
case Expression::E_ANON:
|
|
os << "_";
|
|
break;
|
|
case Expression::E_ARRAYLIT: {
|
|
const ArrayLit& al = *e->cast<ArrayLit>();
|
|
int n = al.dims();
|
|
if (n == 1 && al.min(0) == 1) {
|
|
os << "[";
|
|
for (unsigned int i = 0; i < al.size(); i++) {
|
|
p(al[i]);
|
|
if (i < al.size() - 1) os << ",";
|
|
}
|
|
os << "]";
|
|
} else if (n == 2 && al.min(0) == 1 && al.min(1) == 1 && al.max(1) != 0) {
|
|
os << "[|";
|
|
for (int i = 0; i < al.max(0); i++) {
|
|
for (int j = 0; j < al.max(1); j++) {
|
|
p(al[i * al.max(1) + j]);
|
|
if (j < al.max(1) - 1) os << ",";
|
|
}
|
|
if (i < al.max(0) - 1) os << "|";
|
|
}
|
|
os << "|]";
|
|
} else {
|
|
os << "array" << n << "d(";
|
|
for (int i = 0; i < al.dims(); i++) {
|
|
os << al.min(i) << ".." << al.max(i);
|
|
os << ",";
|
|
}
|
|
os << "[";
|
|
for (unsigned int i = 0; i < al.size(); i++) {
|
|
p(al[i]);
|
|
if (i < al.size() - 1) os << ",";
|
|
}
|
|
os << "])";
|
|
}
|
|
} break;
|
|
case Expression::E_ARRAYACCESS: {
|
|
const ArrayAccess& aa = *e->cast<ArrayAccess>();
|
|
p(aa.v());
|
|
os << "[";
|
|
for (unsigned int i = 0; i < aa.idx().size(); i++) {
|
|
p(aa.idx()[i]);
|
|
if (i < aa.idx().size() - 1) os << ",";
|
|
}
|
|
os << "]";
|
|
} break;
|
|
case Expression::E_COMP: {
|
|
const Comprehension& c = *e->cast<Comprehension>();
|
|
os << (c.set() ? "{" : "[");
|
|
p(c.e());
|
|
os << " | ";
|
|
for (int i = 0; i < c.n_generators(); i++) {
|
|
for (int j = 0; j < c.n_decls(i); j++) {
|
|
os << c.decl(i, j)->id()->v();
|
|
if (j < c.n_decls(i) - 1) os << ",";
|
|
}
|
|
if (c.in(i) == NULL) {
|
|
os << " = ";
|
|
p(c.where(i));
|
|
} else {
|
|
os << " in ";
|
|
p(c.in(i));
|
|
if (c.where(i) != NULL) {
|
|
os << " where ";
|
|
p(c.where(i));
|
|
}
|
|
}
|
|
if (i < c.n_generators()) os << ", ";
|
|
}
|
|
os << (c.set() ? "}" : "]");
|
|
} break;
|
|
case Expression::E_ITE: {
|
|
const ITE& ite = *e->cast<ITE>();
|
|
for (int i = 0; i < ite.size(); i++) {
|
|
os << (i == 0 ? "if " : " elseif ");
|
|
p(ite.e_if(i));
|
|
os << " then ";
|
|
p(ite.e_then(i));
|
|
}
|
|
os << " else ";
|
|
p(ite.e_else());
|
|
os << " endif";
|
|
} break;
|
|
case Expression::E_BINOP: {
|
|
const BinOp& bo = *e->cast<BinOp>();
|
|
Parentheses ps = needParens(&bo, bo.lhs(), bo.rhs());
|
|
if (ps & PN_LEFT) os << "(";
|
|
p(bo.lhs());
|
|
if (ps & PN_LEFT) os << ")";
|
|
switch (bo.op()) {
|
|
case BOT_PLUS:
|
|
os << "+";
|
|
break;
|
|
case BOT_MINUS:
|
|
os << "-";
|
|
break;
|
|
case BOT_MULT:
|
|
os << "*";
|
|
break;
|
|
case BOT_POW:
|
|
os << "^";
|
|
break;
|
|
case BOT_DIV:
|
|
os << "/";
|
|
break;
|
|
case BOT_IDIV:
|
|
os << " div ";
|
|
break;
|
|
case BOT_MOD:
|
|
os << " mod ";
|
|
break;
|
|
case BOT_LE:
|
|
os << " < ";
|
|
break;
|
|
case BOT_LQ:
|
|
os << "<=";
|
|
break;
|
|
case BOT_GR:
|
|
os << " > ";
|
|
break;
|
|
case BOT_GQ:
|
|
os << ">=";
|
|
break;
|
|
case BOT_EQ:
|
|
os << "==";
|
|
break;
|
|
case BOT_NQ:
|
|
os << "!=";
|
|
break;
|
|
case BOT_IN:
|
|
os << " in ";
|
|
break;
|
|
case BOT_SUBSET:
|
|
os << " subset ";
|
|
break;
|
|
case BOT_SUPERSET:
|
|
os << " superset ";
|
|
break;
|
|
case BOT_UNION:
|
|
os << " union ";
|
|
break;
|
|
case BOT_DIFF:
|
|
os << " diff ";
|
|
break;
|
|
case BOT_SYMDIFF:
|
|
os << " symdiff ";
|
|
break;
|
|
case BOT_INTERSECT:
|
|
os << " intersect ";
|
|
break;
|
|
case BOT_PLUSPLUS:
|
|
os << "++";
|
|
break;
|
|
case BOT_EQUIV:
|
|
os << " <-> ";
|
|
break;
|
|
case BOT_IMPL:
|
|
os << " -> ";
|
|
break;
|
|
case BOT_RIMPL:
|
|
os << " <- ";
|
|
break;
|
|
case BOT_OR:
|
|
os << " \\/ ";
|
|
break;
|
|
case BOT_AND:
|
|
os << " /\\ ";
|
|
break;
|
|
case BOT_XOR:
|
|
os << " xor ";
|
|
break;
|
|
case BOT_DOTDOT:
|
|
os << "..";
|
|
break;
|
|
default:
|
|
assert(false);
|
|
break;
|
|
}
|
|
|
|
if (ps & PN_RIGHT) os << "(";
|
|
p(bo.rhs());
|
|
if (ps & PN_RIGHT) os << ")";
|
|
} break;
|
|
case Expression::E_UNOP: {
|
|
const UnOp& uo = *e->cast<UnOp>();
|
|
switch (uo.op()) {
|
|
case UOT_NOT:
|
|
os << "not ";
|
|
break;
|
|
case UOT_PLUS:
|
|
os << "+";
|
|
break;
|
|
case UOT_MINUS:
|
|
os << "-";
|
|
break;
|
|
default:
|
|
assert(false);
|
|
break;
|
|
}
|
|
bool needParen = (uo.e()->isa<BinOp>() || uo.e()->isa<UnOp>() || !uo.ann().isEmpty());
|
|
if (needParen) os << "(";
|
|
p(uo.e());
|
|
if (needParen) os << ")";
|
|
} break;
|
|
case Expression::E_CALL: {
|
|
const Call& c = *e->cast<Call>();
|
|
os << c.id() << "(";
|
|
for (unsigned int i = 0; i < c.n_args(); i++) {
|
|
p(c.arg(i));
|
|
if (i < c.n_args() - 1) os << ",";
|
|
}
|
|
os << ")";
|
|
} break;
|
|
case Expression::E_VARDECL: {
|
|
const VarDecl& vd = *e->cast<VarDecl>();
|
|
p(vd.ti());
|
|
if (!vd.ti()->isEnum()) {
|
|
os << ":";
|
|
}
|
|
if (vd.id()->idn() != -1) {
|
|
os << " X_INTRODUCED_" << vd.id()->idn() << "_";
|
|
} else if (vd.id()->v().size() != 0)
|
|
os << " " << vd.id()->v();
|
|
if (vd.introduced()) {
|
|
os << " ::var_is_introduced ";
|
|
}
|
|
p(vd.ann());
|
|
if (vd.e()) {
|
|
os << " = ";
|
|
p(vd.e());
|
|
}
|
|
} break;
|
|
case Expression::E_LET: {
|
|
const Let& l = *e->cast<Let>();
|
|
os << "let {";
|
|
|
|
for (unsigned int i = 0; i < l.let().size(); i++) {
|
|
const Expression* li = l.let()[i];
|
|
if (!li->isa<VarDecl>()) os << "constraint ";
|
|
p(li);
|
|
if (i < l.let().size() - 1) os << ", ";
|
|
}
|
|
os << "} in (";
|
|
p(l.in());
|
|
os << ")";
|
|
} break;
|
|
case Expression::E_TI: {
|
|
const TypeInst& ti = *e->cast<TypeInst>();
|
|
if (ti.isEnum()) {
|
|
os << "enum";
|
|
} else if (env) {
|
|
os << ti.type().toString(*env);
|
|
} else {
|
|
if (ti.isarray()) {
|
|
os << "array [";
|
|
for (unsigned int i = 0; i < ti.ranges().size(); i++) {
|
|
p(Type::parint(), ti.ranges()[i]);
|
|
if (i < ti.ranges().size() - 1) os << ",";
|
|
}
|
|
os << "] of ";
|
|
}
|
|
p(ti.type(), ti.domain());
|
|
}
|
|
}
|
|
}
|
|
if (!e->isa<VarDecl>()) {
|
|
p(e->ann());
|
|
}
|
|
}
|
|
|
|
void p(const Item* i) {
|
|
if (i == NULL) return;
|
|
if (i->removed()) os << "% ";
|
|
switch (i->iid()) {
|
|
case Item::II_INC:
|
|
os << "include \"" << i->cast<IncludeI>()->f() << "\"";
|
|
break;
|
|
case Item::II_VD:
|
|
p(i->cast<VarDeclI>()->e());
|
|
break;
|
|
case Item::II_ASN:
|
|
os << i->cast<AssignI>()->id() << " = ";
|
|
p(i->cast<AssignI>()->e());
|
|
break;
|
|
case Item::II_CON:
|
|
os << "constraint ";
|
|
p(i->cast<ConstraintI>()->e());
|
|
break;
|
|
case Item::II_SOL: {
|
|
const SolveI* si = i->cast<SolveI>();
|
|
os << "solve ";
|
|
p(si->ann());
|
|
switch (si->st()) {
|
|
case SolveI::ST_SAT:
|
|
os << " satisfy";
|
|
break;
|
|
case SolveI::ST_MIN:
|
|
os << " minimize ";
|
|
p(si->e());
|
|
break;
|
|
case SolveI::ST_MAX:
|
|
os << " maximize ";
|
|
p(si->e());
|
|
break;
|
|
}
|
|
} break;
|
|
case Item::II_OUT:
|
|
os << "output ";
|
|
p(i->cast<OutputI>()->e());
|
|
break;
|
|
case Item::II_FUN: {
|
|
const FunctionI& fi = *i->cast<FunctionI>();
|
|
if (fi.ti()->type().isann() && fi.e() == NULL) {
|
|
os << "annotation ";
|
|
} else if (fi.ti()->type() == Type::parbool()) {
|
|
os << "test ";
|
|
} else if (fi.ti()->type() == Type::varbool()) {
|
|
os << "predicate ";
|
|
} else {
|
|
os << "function ";
|
|
p(fi.ti());
|
|
os << " : ";
|
|
}
|
|
os << fi.id();
|
|
if (fi.params().size() > 0) {
|
|
os << "(";
|
|
for (unsigned int i = 0; i < fi.params().size(); i++) {
|
|
p(fi.params()[i]);
|
|
if (i < fi.params().size() - 1) os << ",";
|
|
}
|
|
os << ")";
|
|
}
|
|
p(fi.ann());
|
|
if (fi.e()) {
|
|
os << " = ";
|
|
p(fi.e());
|
|
}
|
|
} break;
|
|
}
|
|
os << ";" << std::endl;
|
|
}
|
|
};
|
|
|
|
template <class T>
|
|
class ExpressionMapper {
|
|
protected:
|
|
T& _t;
|
|
|
|
public:
|
|
ExpressionMapper(T& t) : _t(t) {}
|
|
typename T::ret map(const Expression* e) {
|
|
switch (e->eid()) {
|
|
case Expression::E_INTLIT:
|
|
return _t.mapIntLit(*e->cast<IntLit>());
|
|
case Expression::E_FLOATLIT:
|
|
return _t.mapFloatLit(*e->cast<FloatLit>());
|
|
case Expression::E_SETLIT:
|
|
return _t.mapSetLit(*e->cast<SetLit>());
|
|
case Expression::E_BOOLLIT:
|
|
return _t.mapBoolLit(*e->cast<BoolLit>());
|
|
case Expression::E_STRINGLIT:
|
|
return _t.mapStringLit(*e->cast<StringLit>());
|
|
case Expression::E_ID:
|
|
return _t.mapId(*e->cast<Id>());
|
|
case Expression::E_ANON:
|
|
return _t.mapAnonVar(*e->cast<AnonVar>());
|
|
case Expression::E_ARRAYLIT:
|
|
return _t.mapArrayLit(*e->cast<ArrayLit>());
|
|
case Expression::E_ARRAYACCESS:
|
|
return _t.mapArrayAccess(*e->cast<ArrayAccess>());
|
|
case Expression::E_COMP:
|
|
return _t.mapComprehension(*e->cast<Comprehension>());
|
|
case Expression::E_ITE:
|
|
return _t.mapITE(*e->cast<ITE>());
|
|
case Expression::E_BINOP:
|
|
return _t.mapBinOp(*e->cast<BinOp>());
|
|
case Expression::E_UNOP:
|
|
return _t.mapUnOp(*e->cast<UnOp>());
|
|
case Expression::E_CALL:
|
|
return _t.mapCall(*e->cast<Call>());
|
|
case Expression::E_VARDECL:
|
|
return _t.mapVarDecl(*e->cast<VarDecl>());
|
|
case Expression::E_LET:
|
|
return _t.mapLet(*e->cast<Let>());
|
|
case Expression::E_TI:
|
|
return _t.mapTypeInst(*e->cast<TypeInst>());
|
|
case Expression::E_TIID:
|
|
return _t.mapTIId(*e->cast<TIId>());
|
|
default:
|
|
assert(false);
|
|
return typename T::ret();
|
|
break;
|
|
}
|
|
}
|
|
};
|
|
|
|
class Document {
|
|
private:
|
|
int level;
|
|
|
|
public:
|
|
Document() : level(0) {}
|
|
virtual ~Document() {}
|
|
int getLevel() { return level; }
|
|
// Make this object a child of "d".
|
|
virtual void setParent(Document* d) { level = d->level + 1; }
|
|
};
|
|
|
|
class BreakPoint : public Document {
|
|
private:
|
|
bool dontSimplify;
|
|
|
|
public:
|
|
BreakPoint() { dontSimplify = false; }
|
|
BreakPoint(bool ds) { dontSimplify = ds; }
|
|
virtual ~BreakPoint() {}
|
|
void setDontSimplify(bool b) { dontSimplify = b; }
|
|
bool getDontSimplify() { return dontSimplify; }
|
|
};
|
|
|
|
class StringDocument : public Document {
|
|
private:
|
|
std::string stringDocument;
|
|
|
|
public:
|
|
StringDocument() {}
|
|
virtual ~StringDocument() {}
|
|
|
|
StringDocument(std::string s) : stringDocument(s) {}
|
|
|
|
std::string getString() { return stringDocument; }
|
|
void setString(std::string s) { stringDocument = s; }
|
|
};
|
|
|
|
class DocumentList : public Document {
|
|
private:
|
|
std::vector<Document*> docs;
|
|
std::string beginToken;
|
|
std::string separator;
|
|
std::string endToken;
|
|
bool unbreakable;
|
|
bool alignment;
|
|
|
|
public:
|
|
virtual ~DocumentList() {
|
|
std::vector<Document*>::iterator it;
|
|
for (it = docs.begin(); it != docs.end(); it++) {
|
|
delete *it;
|
|
}
|
|
}
|
|
DocumentList(std::string _beginToken = "", std::string _separator = "",
|
|
std::string _endToken = "", bool _alignment = true);
|
|
|
|
void addDocumentToList(Document* d) {
|
|
docs.push_back(d);
|
|
d->setParent(this);
|
|
}
|
|
|
|
void setParent(Document* d) {
|
|
Document::setParent(d);
|
|
std::vector<Document*>::iterator it;
|
|
for (it = docs.begin(); it != docs.end(); it++) {
|
|
(*it)->setParent(this);
|
|
}
|
|
}
|
|
|
|
void addStringToList(std::string s) { addDocumentToList(new StringDocument(s)); }
|
|
|
|
void addBreakPoint(bool b = false) { addDocumentToList(new BreakPoint(b)); }
|
|
|
|
std::vector<Document*> getDocs() { return docs; }
|
|
|
|
void setList(std::vector<Document*> ld) { docs = ld; }
|
|
|
|
std::string getBeginToken() { return beginToken; }
|
|
|
|
std::string getEndToken() { return endToken; }
|
|
|
|
std::string getSeparator() { return separator; }
|
|
|
|
bool getUnbreakable() { return unbreakable; }
|
|
|
|
void setUnbreakable(bool b) { unbreakable = b; }
|
|
|
|
bool getAlignment() { return alignment; }
|
|
};
|
|
|
|
DocumentList::DocumentList(std::string _beginToken, std::string _separator, std::string _endToken,
|
|
bool _alignment) {
|
|
beginToken = _beginToken;
|
|
separator = _separator;
|
|
endToken = _endToken;
|
|
alignment = _alignment;
|
|
unbreakable = false;
|
|
}
|
|
|
|
class Line {
|
|
private:
|
|
int indentation;
|
|
int lineLength;
|
|
std::vector<std::string> text;
|
|
|
|
public:
|
|
Line() : indentation(0), lineLength(0), text(0) {}
|
|
Line(const Line& l) : indentation(l.indentation), lineLength(l.lineLength), text(l.text) {}
|
|
Line(const int indent) : indentation(indent), lineLength(0), text(0) {}
|
|
bool operator==(const Line& l) { return &l == this; }
|
|
|
|
void setIndentation(int i) { indentation = i; }
|
|
|
|
int getLength() const { return lineLength; }
|
|
int getIndentation() const { return indentation; }
|
|
int getSpaceLeft(int maxwidth);
|
|
void addString(const std::string& s);
|
|
void concatenateLines(Line& l);
|
|
|
|
void print(std::ostream& os) const {
|
|
for (int i = 0; i < getIndentation(); i++) {
|
|
os << " ";
|
|
}
|
|
std::vector<std::string>::const_iterator it;
|
|
for (it = text.begin(); it != text.end(); it++) {
|
|
os << (*it);
|
|
}
|
|
os << "\n";
|
|
}
|
|
};
|
|
|
|
int Line::getSpaceLeft(int maxwidth) { return maxwidth - lineLength - indentation; }
|
|
void Line::addString(const std::string& s) {
|
|
lineLength += static_cast<int>(s.size());
|
|
text.push_back(s);
|
|
}
|
|
void Line::concatenateLines(Line& l) {
|
|
text.insert(text.end(), l.text.begin(), l.text.end());
|
|
lineLength += l.lineLength;
|
|
}
|
|
|
|
class LinesToSimplify {
|
|
private:
|
|
std::map<int, std::vector<int> > lines;
|
|
|
|
// (i,j) in parent <=> j can only be simplified if i is simplified
|
|
std::vector<std::pair<int, int> > parent;
|
|
/*
|
|
* if i can't simplify, remove j and his parents
|
|
*/
|
|
// mostRecentlyAdded[level] = line of the most recently added
|
|
std::map<int, int> mostRecentlyAdded;
|
|
|
|
public:
|
|
std::vector<int>* getLinesForPriority(int p) {
|
|
std::map<int, std::vector<int> >::iterator it;
|
|
for (it = lines.begin(); it != lines.end(); it++) {
|
|
if (it->first == p) return &(it->second);
|
|
}
|
|
return NULL;
|
|
}
|
|
void addLine(int p, int l, int par = -1) {
|
|
if (par == -1) {
|
|
for (int i = p - 1; i >= 0; i--) {
|
|
std::map<int, int>::iterator it = mostRecentlyAdded.find(i);
|
|
if (it != mostRecentlyAdded.end()) {
|
|
par = it->second;
|
|
break;
|
|
}
|
|
}
|
|
}
|
|
if (par != -1) parent.push_back(std::pair<int, int>(l, par));
|
|
mostRecentlyAdded.insert(std::pair<int, int>(p, l));
|
|
std::map<int, std::vector<int> >::iterator it;
|
|
for (it = lines.begin(); it != lines.end(); it++) {
|
|
if (it->first == p) {
|
|
it->second.push_back(l);
|
|
return;
|
|
}
|
|
}
|
|
std::vector<int> v;
|
|
v.push_back(l);
|
|
lines.insert(std::pair<int, std::vector<int> >(p, v));
|
|
}
|
|
void decrementLine(std::vector<int>* vec, int l) {
|
|
std::vector<int>::iterator vit;
|
|
if (vec != NULL) {
|
|
for (vit = vec->begin(); vit != vec->end(); vit++) {
|
|
if (*vit >= l) *vit = *vit - 1;
|
|
}
|
|
}
|
|
// Now the map
|
|
std::map<int, std::vector<int> >::iterator it;
|
|
for (it = lines.begin(); it != lines.end(); it++) {
|
|
for (vit = it->second.begin(); vit != it->second.end(); vit++) {
|
|
if (*vit >= l) *vit = *vit - 1;
|
|
}
|
|
}
|
|
// And the parent table
|
|
std::vector<std::pair<int, int> >::iterator vpit;
|
|
for (vpit = parent.begin(); vpit != parent.end(); vpit++) {
|
|
if (vpit->first >= l) vpit->first--;
|
|
if (vpit->second >= l) vpit->second--;
|
|
}
|
|
}
|
|
void remove(LinesToSimplify& lts) {
|
|
std::map<int, std::vector<int> >::iterator it;
|
|
for (it = lts.lines.begin(); it != lts.lines.end(); it++) {
|
|
std::vector<int>::iterator vit;
|
|
for (vit = it->second.begin(); vit != it->second.end(); vit++) {
|
|
remove(NULL, *vit, false);
|
|
}
|
|
}
|
|
}
|
|
void remove(std::vector<int>* v, int i, bool success = true) {
|
|
if (v != NULL) {
|
|
v->erase(std::remove(v->begin(), v->end(), i), v->end());
|
|
}
|
|
std::map<int, std::vector<int> >::iterator it;
|
|
for (it = lines.begin(); it != lines.end(); it++) {
|
|
std::vector<int>* v = &(it->second);
|
|
v->erase(std::remove(v->begin(), v->end(), i), v->end());
|
|
}
|
|
// Call on its parent
|
|
if (!success) {
|
|
std::vector<std::pair<int, int> >::iterator vpit;
|
|
for (vpit = parent.begin(); vpit != parent.end(); vpit++) {
|
|
if (vpit->first == i && vpit->second != i && vpit->second != -1) {
|
|
remove(v, vpit->second, false);
|
|
}
|
|
}
|
|
}
|
|
}
|
|
std::vector<int>* getLinesToSimplify() {
|
|
std::vector<int>* vec = new std::vector<int>();
|
|
std::map<int, std::vector<int> >::iterator it;
|
|
for (it = lines.begin(); it != lines.end(); it++) {
|
|
std::vector<int>& svec = it->second;
|
|
vec->insert(vec->begin(), svec.begin(), svec.end());
|
|
}
|
|
return vec;
|
|
}
|
|
};
|
|
|
|
Document* expressionToDocument(const Expression* e);
|
|
Document* annotationToDocument(const Annotation& ann);
|
|
Document* tiexpressionToDocument(const Type& type, const Expression* e) {
|
|
DocumentList* dl = new DocumentList("", "", "", false);
|
|
switch (type.ti()) {
|
|
case Type::TI_PAR:
|
|
break;
|
|
case Type::TI_VAR:
|
|
dl->addStringToList("var ");
|
|
break;
|
|
}
|
|
if (type.ot() == Type::OT_OPTIONAL) dl->addStringToList("opt ");
|
|
if (type.st() == Type::ST_SET) dl->addStringToList("set of ");
|
|
if (e == NULL) {
|
|
switch (type.bt()) {
|
|
case Type::BT_INT:
|
|
dl->addStringToList("int");
|
|
break;
|
|
case Type::BT_BOOL:
|
|
dl->addStringToList("bool");
|
|
break;
|
|
case Type::BT_FLOAT:
|
|
dl->addStringToList("float");
|
|
break;
|
|
case Type::BT_STRING:
|
|
dl->addStringToList("string");
|
|
break;
|
|
case Type::BT_ANN:
|
|
dl->addStringToList("ann");
|
|
break;
|
|
case Type::BT_BOT:
|
|
dl->addStringToList("bot");
|
|
break;
|
|
case Type::BT_TOP:
|
|
dl->addStringToList("top");
|
|
break;
|
|
case Type::BT_UNKNOWN:
|
|
dl->addStringToList("???");
|
|
break;
|
|
}
|
|
} else {
|
|
dl->addDocumentToList(expressionToDocument(e));
|
|
}
|
|
return dl;
|
|
}
|
|
|
|
class ExpressionDocumentMapper {
|
|
public:
|
|
typedef Document* ret;
|
|
ret mapIntLit(const IntLit& il) {
|
|
std::ostringstream oss;
|
|
oss << il.v();
|
|
return new StringDocument(oss.str());
|
|
}
|
|
ret mapFloatLit(const FloatLit& fl) {
|
|
std::ostringstream oss;
|
|
ppFloatVal(oss, fl.v());
|
|
return new StringDocument(oss.str());
|
|
}
|
|
ret mapSetLit(const SetLit& sl) {
|
|
DocumentList* dl;
|
|
if (sl.isv()) {
|
|
if (sl.isv()->size() == 0) {
|
|
dl = new DocumentList("1..0", "", "");
|
|
} else if (sl.isv()->size() == 1) {
|
|
dl = new DocumentList("", "..", "");
|
|
{
|
|
std::ostringstream oss;
|
|
oss << sl.isv()->min(0);
|
|
dl->addDocumentToList(new StringDocument(oss.str()));
|
|
}
|
|
{
|
|
std::ostringstream oss;
|
|
oss << sl.isv()->max(0);
|
|
dl->addDocumentToList(new StringDocument(oss.str()));
|
|
}
|
|
} else {
|
|
dl = new DocumentList("{", ", ", "}", true);
|
|
IntSetRanges isr(sl.isv());
|
|
for (Ranges::ToValues<IntSetRanges> isv(isr); isv(); ++isv) {
|
|
std::ostringstream oss;
|
|
oss << isv.val();
|
|
dl->addDocumentToList(new StringDocument(oss.str()));
|
|
}
|
|
}
|
|
} else if (sl.fsv()) {
|
|
if (sl.fsv()->size() == 0) {
|
|
dl = new DocumentList("1.0..0.0", "", "");
|
|
} else if (sl.fsv()->size() == 1) {
|
|
dl = new DocumentList("", "..", "");
|
|
{
|
|
std::ostringstream oss;
|
|
ppFloatVal(oss, sl.fsv()->min(0));
|
|
dl->addDocumentToList(new StringDocument(oss.str()));
|
|
}
|
|
{
|
|
std::ostringstream oss;
|
|
ppFloatVal(oss, sl.fsv()->max(0));
|
|
dl->addDocumentToList(new StringDocument(oss.str()));
|
|
}
|
|
} else {
|
|
dl = new DocumentList("", "++", "", true);
|
|
FloatSetRanges fsr(sl.fsv());
|
|
for (; fsr(); ++fsr) {
|
|
std::ostringstream oss;
|
|
ppFloatVal(oss, fsr.min());
|
|
oss << "..";
|
|
ppFloatVal(oss, fsr.max());
|
|
dl->addDocumentToList(new StringDocument(oss.str()));
|
|
}
|
|
}
|
|
|
|
} else {
|
|
dl = new DocumentList("{", ", ", "}", true);
|
|
for (unsigned int i = 0; i < sl.v().size(); i++) {
|
|
dl->addDocumentToList(expressionToDocument((sl.v()[i])));
|
|
}
|
|
}
|
|
return dl;
|
|
}
|
|
ret mapBoolLit(const BoolLit& bl) {
|
|
return new StringDocument(std::string(bl.v() ? "true" : "false"));
|
|
}
|
|
ret mapStringLit(const StringLit& sl) {
|
|
std::ostringstream oss;
|
|
oss << "\"" << Printer::escapeStringLit(sl.v()) << "\"";
|
|
return new StringDocument(oss.str());
|
|
}
|
|
ret mapId(const Id& id) {
|
|
if (&id == constants().absent) return new StringDocument("<>");
|
|
if (id.idn() == -1)
|
|
return new StringDocument(id.v().str());
|
|
else {
|
|
std::ostringstream oss;
|
|
oss << "X_INTRODUCED_" << id.idn() << "_";
|
|
return new StringDocument(oss.str());
|
|
}
|
|
}
|
|
ret mapTIId(const TIId& id) { return new StringDocument("$" + id.v().str()); }
|
|
ret mapAnonVar(const AnonVar&) { return new StringDocument("_"); }
|
|
ret mapArrayLit(const ArrayLit& al) {
|
|
/// TODO: test multi-dimensional arrays handling
|
|
DocumentList* dl;
|
|
int n = al.dims();
|
|
if (n == 1 && al.min(0) == 1) {
|
|
dl = new DocumentList("[", ", ", "]");
|
|
for (unsigned int i = 0; i < al.size(); i++)
|
|
dl->addDocumentToList(expressionToDocument(al[i]));
|
|
} else if (n == 2 && al.min(0) == 1 && al.min(1) == 1) {
|
|
dl = new DocumentList("[| ", " | ", " |]");
|
|
for (int i = 0; i < al.max(0); i++) {
|
|
DocumentList* row = new DocumentList("", ", ", "");
|
|
for (int j = 0; j < al.max(1); j++) {
|
|
row->addDocumentToList(expressionToDocument(al[i * al.max(1) + j]));
|
|
}
|
|
dl->addDocumentToList(row);
|
|
if (i != al.max(0) - 1) dl->addBreakPoint(true); // dont simplify
|
|
}
|
|
} else {
|
|
dl = new DocumentList("", "", "");
|
|
std::stringstream oss;
|
|
oss << "array" << n << "d";
|
|
dl->addStringToList(oss.str());
|
|
DocumentList* args = new DocumentList("(", ", ", ")");
|
|
|
|
for (int i = 0; i < al.dims(); i++) {
|
|
oss.str("");
|
|
oss << al.min(i) << ".." << al.max(i);
|
|
args->addStringToList(oss.str());
|
|
}
|
|
DocumentList* array = new DocumentList("[", ", ", "]");
|
|
for (unsigned int i = 0; i < al.size(); i++)
|
|
array->addDocumentToList(expressionToDocument(al[i]));
|
|
args->addDocumentToList(array);
|
|
dl->addDocumentToList(args);
|
|
}
|
|
return dl;
|
|
}
|
|
ret mapArrayAccess(const ArrayAccess& aa) {
|
|
DocumentList* dl = new DocumentList("", "", "");
|
|
|
|
dl->addDocumentToList(expressionToDocument(aa.v()));
|
|
DocumentList* args = new DocumentList("[", ", ", "]");
|
|
for (unsigned int i = 0; i < aa.idx().size(); i++) {
|
|
args->addDocumentToList(expressionToDocument(aa.idx()[i]));
|
|
}
|
|
dl->addDocumentToList(args);
|
|
return dl;
|
|
}
|
|
ret mapComprehension(const Comprehension& c) {
|
|
std::ostringstream oss;
|
|
DocumentList* dl;
|
|
if (c.set())
|
|
dl = new DocumentList("{ ", " | ", " }");
|
|
else
|
|
dl = new DocumentList("[ ", " | ", " ]");
|
|
dl->addDocumentToList(expressionToDocument(c.e()));
|
|
DocumentList* head = new DocumentList("", " ", "");
|
|
DocumentList* generators = new DocumentList("", ", ", "");
|
|
for (int i = 0; i < c.n_generators(); i++) {
|
|
DocumentList* gen = new DocumentList("", "", "");
|
|
DocumentList* idents = new DocumentList("", ", ", "");
|
|
for (int j = 0; j < c.n_decls(i); j++) {
|
|
idents->addStringToList(c.decl(i, j)->id()->v().str());
|
|
}
|
|
gen->addDocumentToList(idents);
|
|
if (c.in(i) == NULL) {
|
|
gen->addStringToList(" = ");
|
|
gen->addDocumentToList(expressionToDocument(c.where(i)));
|
|
} else {
|
|
gen->addStringToList(" in ");
|
|
gen->addDocumentToList(expressionToDocument(c.in(i)));
|
|
if (c.where(i) != NULL) {
|
|
gen->addStringToList(" where ");
|
|
gen->addDocumentToList(expressionToDocument(c.where(i)));
|
|
}
|
|
}
|
|
generators->addDocumentToList(gen);
|
|
}
|
|
head->addDocumentToList(generators);
|
|
dl->addDocumentToList(head);
|
|
|
|
return dl;
|
|
}
|
|
ret mapITE(const ITE& ite) {
|
|
DocumentList* dl = new DocumentList("", "", "");
|
|
for (int i = 0; i < ite.size(); i++) {
|
|
std::string beg = (i == 0 ? "if " : " elseif ");
|
|
dl->addStringToList(beg);
|
|
dl->addDocumentToList(expressionToDocument(ite.e_if(i)));
|
|
dl->addStringToList(" then ");
|
|
|
|
DocumentList* ifdoc = new DocumentList("", "", "", false);
|
|
ifdoc->addBreakPoint();
|
|
ifdoc->addDocumentToList(expressionToDocument(ite.e_then(i)));
|
|
dl->addDocumentToList(ifdoc);
|
|
dl->addStringToList(" ");
|
|
}
|
|
dl->addBreakPoint();
|
|
dl->addStringToList("else ");
|
|
|
|
DocumentList* elsedoc = new DocumentList("", "", "", false);
|
|
elsedoc->addBreakPoint();
|
|
elsedoc->addDocumentToList(expressionToDocument(ite.e_else()));
|
|
dl->addDocumentToList(elsedoc);
|
|
dl->addStringToList(" ");
|
|
dl->addBreakPoint();
|
|
dl->addStringToList("endif");
|
|
|
|
return dl;
|
|
}
|
|
ret mapBinOp(const BinOp& bo) {
|
|
Parentheses ps = needParens(&bo, bo.lhs(), bo.rhs());
|
|
DocumentList* opLeft;
|
|
DocumentList* dl;
|
|
DocumentList* opRight;
|
|
bool linebreak = false;
|
|
if (ps & PN_LEFT)
|
|
opLeft = new DocumentList("(", " ", ")");
|
|
else
|
|
opLeft = new DocumentList("", " ", "");
|
|
opLeft->addDocumentToList(expressionToDocument(bo.lhs()));
|
|
std::string op;
|
|
switch (bo.op()) {
|
|
case BOT_PLUS:
|
|
op = "+";
|
|
break;
|
|
case BOT_MINUS:
|
|
op = "-";
|
|
break;
|
|
case BOT_MULT:
|
|
op = "*";
|
|
break;
|
|
case BOT_POW:
|
|
op = "^";
|
|
break;
|
|
case BOT_DIV:
|
|
op = "/";
|
|
break;
|
|
case BOT_IDIV:
|
|
op = " div ";
|
|
break;
|
|
case BOT_MOD:
|
|
op = " mod ";
|
|
break;
|
|
case BOT_LE:
|
|
op = " < ";
|
|
break;
|
|
case BOT_LQ:
|
|
op = "<=";
|
|
break;
|
|
case BOT_GR:
|
|
op = " > ";
|
|
break;
|
|
case BOT_GQ:
|
|
op = ">=";
|
|
break;
|
|
case BOT_EQ:
|
|
op = "==";
|
|
break;
|
|
case BOT_NQ:
|
|
op = "!=";
|
|
break;
|
|
case BOT_IN:
|
|
op = " in ";
|
|
break;
|
|
case BOT_SUBSET:
|
|
op = " subset ";
|
|
break;
|
|
case BOT_SUPERSET:
|
|
op = " superset ";
|
|
break;
|
|
case BOT_UNION:
|
|
op = " union ";
|
|
break;
|
|
case BOT_DIFF:
|
|
op = " diff ";
|
|
break;
|
|
case BOT_SYMDIFF:
|
|
op = " symdiff ";
|
|
break;
|
|
case BOT_INTERSECT:
|
|
op = " intersect ";
|
|
break;
|
|
case BOT_PLUSPLUS:
|
|
op = "++";
|
|
linebreak = true;
|
|
break;
|
|
case BOT_EQUIV:
|
|
op = " <-> ";
|
|
break;
|
|
case BOT_IMPL:
|
|
op = " -> ";
|
|
break;
|
|
case BOT_RIMPL:
|
|
op = " <- ";
|
|
break;
|
|
case BOT_OR:
|
|
op = " \\/ ";
|
|
linebreak = true;
|
|
break;
|
|
case BOT_AND:
|
|
op = " /\\ ";
|
|
linebreak = true;
|
|
break;
|
|
case BOT_XOR:
|
|
op = " xor ";
|
|
break;
|
|
case BOT_DOTDOT:
|
|
op = "..";
|
|
break;
|
|
default:
|
|
assert(false);
|
|
break;
|
|
}
|
|
dl = new DocumentList("", op, "");
|
|
|
|
if (ps & PN_RIGHT)
|
|
opRight = new DocumentList("(", " ", ")");
|
|
else
|
|
opRight = new DocumentList("", "", "");
|
|
opRight->addDocumentToList(expressionToDocument(bo.rhs()));
|
|
dl->addDocumentToList(opLeft);
|
|
if (linebreak) dl->addBreakPoint();
|
|
dl->addDocumentToList(opRight);
|
|
|
|
return dl;
|
|
}
|
|
ret mapUnOp(const UnOp& uo) {
|
|
DocumentList* dl = new DocumentList("", "", "");
|
|
std::string op;
|
|
switch (uo.op()) {
|
|
case UOT_NOT:
|
|
op = "not ";
|
|
break;
|
|
case UOT_PLUS:
|
|
op = "+";
|
|
break;
|
|
case UOT_MINUS:
|
|
op = "-";
|
|
break;
|
|
default:
|
|
assert(false);
|
|
break;
|
|
}
|
|
dl->addStringToList(op);
|
|
DocumentList* unop;
|
|
bool needParen = (uo.e()->isa<BinOp>() || uo.e()->isa<UnOp>());
|
|
if (needParen)
|
|
unop = new DocumentList("(", " ", ")");
|
|
else
|
|
unop = new DocumentList("", " ", "");
|
|
|
|
unop->addDocumentToList(expressionToDocument(uo.e()));
|
|
dl->addDocumentToList(unop);
|
|
return dl;
|
|
}
|
|
ret mapCall(const Call& c) {
|
|
if (c.n_args() == 1) {
|
|
/*
|
|
* if we have only one argument, and this is an array comprehension,
|
|
* we convert it into the following syntax
|
|
* forall (f(i,j) | i in 1..10)
|
|
* -->
|
|
* forall (i in 1..10) (f(i,j))
|
|
*/
|
|
|
|
const Expression* e = c.arg(0);
|
|
if (e->isa<Comprehension>()) {
|
|
const Comprehension* com = e->cast<Comprehension>();
|
|
if (!com->set()) {
|
|
DocumentList* dl = new DocumentList("", " ", "");
|
|
dl->addStringToList(c.id().str());
|
|
DocumentList* args = new DocumentList("", " ", "", false);
|
|
DocumentList* generators = new DocumentList("", ", ", "");
|
|
|
|
for (int i = 0; i < com->n_generators(); i++) {
|
|
DocumentList* gen = new DocumentList("", "", "");
|
|
DocumentList* idents = new DocumentList("", ", ", "");
|
|
for (int j = 0; j < com->n_decls(i); j++) {
|
|
idents->addStringToList(com->decl(i, j)->id()->v().str());
|
|
}
|
|
gen->addDocumentToList(idents);
|
|
if (com->in(i) == NULL) {
|
|
gen->addStringToList(" = ");
|
|
gen->addDocumentToList(expressionToDocument(com->where(i)));
|
|
} else {
|
|
gen->addStringToList(" in ");
|
|
gen->addDocumentToList(expressionToDocument(com->in(i)));
|
|
if (com->where(i) != NULL) {
|
|
gen->addStringToList(" where ");
|
|
gen->addDocumentToList(expressionToDocument(com->where(i)));
|
|
}
|
|
}
|
|
generators->addDocumentToList(gen);
|
|
}
|
|
|
|
args->addStringToList("(");
|
|
args->addDocumentToList(generators);
|
|
args->addStringToList(")");
|
|
|
|
args->addStringToList("(");
|
|
args->addBreakPoint();
|
|
args->addDocumentToList(expressionToDocument(com->e()));
|
|
|
|
dl->addDocumentToList(args);
|
|
dl->addBreakPoint();
|
|
dl->addStringToList(")");
|
|
|
|
return dl;
|
|
}
|
|
}
|
|
}
|
|
std::string beg = c.id().str() + "(";
|
|
DocumentList* dl = new DocumentList(beg, ", ", ")");
|
|
for (unsigned int i = 0; i < c.n_args(); i++) {
|
|
dl->addDocumentToList(expressionToDocument(c.arg(i)));
|
|
}
|
|
return dl;
|
|
}
|
|
ret mapVarDecl(const VarDecl& vd) {
|
|
std::ostringstream oss;
|
|
DocumentList* dl = new DocumentList("", "", "");
|
|
dl->addDocumentToList(expressionToDocument(vd.ti()));
|
|
dl->addStringToList(": ");
|
|
if (vd.id()->idn() == -1) {
|
|
dl->addStringToList(vd.id()->v().str());
|
|
} else {
|
|
std::ostringstream oss;
|
|
oss << "X_INTRODUCED_" << vd.id()->idn() << "_";
|
|
dl->addStringToList(oss.str());
|
|
}
|
|
|
|
if (vd.introduced()) {
|
|
dl->addStringToList(" ::var_is_introduced ");
|
|
}
|
|
if (!vd.ann().isEmpty()) {
|
|
dl->addDocumentToList(annotationToDocument(vd.ann()));
|
|
}
|
|
if (vd.e()) {
|
|
dl->addStringToList(" = ");
|
|
dl->addDocumentToList(expressionToDocument(vd.e()));
|
|
}
|
|
return dl;
|
|
}
|
|
ret mapLet(const Let& l) {
|
|
DocumentList* letin = new DocumentList("", "", "", false);
|
|
DocumentList* lets = new DocumentList("", " ", "", true);
|
|
DocumentList* inexpr = new DocumentList("", "", "");
|
|
bool ds = l.let().size() > 1;
|
|
|
|
for (unsigned int i = 0; i < l.let().size(); i++) {
|
|
if (i != 0) lets->addBreakPoint(ds);
|
|
DocumentList* exp = new DocumentList("", " ", ",");
|
|
const Expression* li = l.let()[i];
|
|
if (!li->isa<VarDecl>()) exp->addStringToList("constraint");
|
|
exp->addDocumentToList(expressionToDocument(li));
|
|
lets->addDocumentToList(exp);
|
|
}
|
|
|
|
inexpr->addDocumentToList(expressionToDocument(l.in()));
|
|
letin->addBreakPoint(ds);
|
|
letin->addDocumentToList(lets);
|
|
|
|
DocumentList* letin2 = new DocumentList("", "", "", false);
|
|
|
|
letin2->addBreakPoint();
|
|
letin2->addDocumentToList(inexpr);
|
|
|
|
DocumentList* dl = new DocumentList("", "", "");
|
|
dl->addStringToList("let {");
|
|
dl->addDocumentToList(letin);
|
|
dl->addBreakPoint(ds);
|
|
dl->addStringToList("} in (");
|
|
dl->addDocumentToList(letin2);
|
|
// dl->addBreakPoint();
|
|
dl->addStringToList(")");
|
|
return dl;
|
|
}
|
|
ret mapTypeInst(const TypeInst& ti) {
|
|
DocumentList* dl = new DocumentList("", "", "");
|
|
if (ti.isarray()) {
|
|
dl->addStringToList("array [");
|
|
DocumentList* ran = new DocumentList("", ", ", "");
|
|
for (unsigned int i = 0; i < ti.ranges().size(); i++) {
|
|
ran->addDocumentToList(tiexpressionToDocument(Type::parint(), ti.ranges()[i]));
|
|
}
|
|
dl->addDocumentToList(ran);
|
|
dl->addStringToList("] of ");
|
|
}
|
|
dl->addDocumentToList(tiexpressionToDocument(ti.type(), ti.domain()));
|
|
return dl;
|
|
}
|
|
};
|
|
|
|
Document* annotationToDocument(const Annotation& ann) {
|
|
DocumentList* dl = new DocumentList(" :: ", " :: ", "");
|
|
for (ExpressionSetIter it = ann.begin(); it != ann.end(); ++it) {
|
|
dl->addDocumentToList(expressionToDocument(*it));
|
|
}
|
|
return dl;
|
|
}
|
|
|
|
Document* expressionToDocument(const Expression* e) {
|
|
if (e == NULL) return new StringDocument("NULL");
|
|
ExpressionDocumentMapper esm;
|
|
ExpressionMapper<ExpressionDocumentMapper> em(esm);
|
|
DocumentList* dl = new DocumentList("", "", "");
|
|
Document* s = em.map(e);
|
|
dl->addDocumentToList(s);
|
|
if (!e->isa<VarDecl>() && !e->ann().isEmpty()) {
|
|
dl->addDocumentToList(annotationToDocument(e->ann()));
|
|
}
|
|
return dl;
|
|
}
|
|
|
|
class ItemDocumentMapper {
|
|
public:
|
|
typedef Document* ret;
|
|
ret mapIncludeI(const IncludeI& ii) {
|
|
std::ostringstream oss;
|
|
oss << "include \"" << ii.f() << "\";";
|
|
return new StringDocument(oss.str());
|
|
}
|
|
ret mapVarDeclI(const VarDeclI& vi) {
|
|
DocumentList* dl = new DocumentList("", " ", ";");
|
|
dl->addDocumentToList(expressionToDocument(vi.e()));
|
|
return dl;
|
|
}
|
|
ret mapAssignI(const AssignI& ai) {
|
|
DocumentList* dl = new DocumentList("", " = ", ";");
|
|
dl->addStringToList(ai.id().str());
|
|
dl->addDocumentToList(expressionToDocument(ai.e()));
|
|
return dl;
|
|
}
|
|
ret mapConstraintI(const ConstraintI& ci) {
|
|
DocumentList* dl = new DocumentList("constraint ", " ", ";");
|
|
dl->addDocumentToList(expressionToDocument(ci.e()));
|
|
return dl;
|
|
}
|
|
ret mapSolveI(const SolveI& si) {
|
|
DocumentList* dl = new DocumentList("", "", ";");
|
|
dl->addStringToList("solve");
|
|
if (!si.ann().isEmpty()) dl->addDocumentToList(annotationToDocument(si.ann()));
|
|
switch (si.st()) {
|
|
case SolveI::ST_SAT:
|
|
dl->addStringToList(" satisfy");
|
|
break;
|
|
case SolveI::ST_MIN:
|
|
dl->addStringToList(" minimize ");
|
|
dl->addDocumentToList(expressionToDocument(si.e()));
|
|
break;
|
|
case SolveI::ST_MAX:
|
|
dl->addStringToList(" maximize ");
|
|
dl->addDocumentToList(expressionToDocument(si.e()));
|
|
break;
|
|
}
|
|
return dl;
|
|
}
|
|
ret mapOutputI(const OutputI& oi) {
|
|
DocumentList* dl = new DocumentList("output ", " ", ";");
|
|
dl->addDocumentToList(expressionToDocument(oi.e()));
|
|
return dl;
|
|
}
|
|
ret mapFunctionI(const FunctionI& fi) {
|
|
DocumentList* dl;
|
|
if (fi.ti()->type().isann() && fi.e() == NULL) {
|
|
dl = new DocumentList("annotation ", " ", ";", false);
|
|
} else if (fi.ti()->type() == Type::parbool()) {
|
|
dl = new DocumentList("test ", "", ";", false);
|
|
} else if (fi.ti()->type() == Type::varbool()) {
|
|
dl = new DocumentList("predicate ", "", ";", false);
|
|
} else {
|
|
dl = new DocumentList("function ", "", ";", false);
|
|
dl->addDocumentToList(expressionToDocument(fi.ti()));
|
|
dl->addStringToList(": ");
|
|
}
|
|
dl->addStringToList(fi.id().str());
|
|
if (fi.params().size() > 0) {
|
|
DocumentList* params = new DocumentList("(", ", ", ")");
|
|
for (unsigned int i = 0; i < fi.params().size(); i++) {
|
|
DocumentList* par = new DocumentList("", "", "");
|
|
par->setUnbreakable(true);
|
|
par->addDocumentToList(expressionToDocument(fi.params()[i]));
|
|
params->addDocumentToList(par);
|
|
}
|
|
dl->addDocumentToList(params);
|
|
}
|
|
if (!fi.ann().isEmpty()) {
|
|
dl->addDocumentToList(annotationToDocument(fi.ann()));
|
|
}
|
|
if (fi.e()) {
|
|
dl->addStringToList(" = ");
|
|
dl->addBreakPoint();
|
|
dl->addDocumentToList(expressionToDocument(fi.e()));
|
|
}
|
|
|
|
return dl;
|
|
}
|
|
};
|
|
|
|
class PrettyPrinter {
|
|
public:
|
|
/*
|
|
* \brief Constructor for class Pretty Printer
|
|
* \param maxwidth (default 80) : number of rows
|
|
* \param indentationBase : spaces that represent the atomic number of spaces
|
|
* \param sim : whether we want to simplify the result
|
|
* \param deepSimp : whether we want to simplify at each breakpoint or not
|
|
*/
|
|
PrettyPrinter(int _maxwidth = 80, int _indentationBase = 4, bool sim = false,
|
|
bool deepSimp = false);
|
|
|
|
void print(Document* d);
|
|
void print(std::ostream& os) const;
|
|
|
|
private:
|
|
int maxwidth;
|
|
int indentationBase;
|
|
int currentLine;
|
|
int currentItem;
|
|
std::vector<std::vector<Line> > items;
|
|
std::vector<LinesToSimplify> linesToSimplify;
|
|
std::vector<LinesToSimplify> linesNotToSimplify;
|
|
bool simp;
|
|
bool deeplySimp;
|
|
|
|
void addItem();
|
|
|
|
void addLine(int indentation, bool bp = false, bool ds = false, int level = 0);
|
|
static std::string printSpaces(int n);
|
|
const std::vector<Line>& getCurrentItemLines() const;
|
|
|
|
void printDocument(Document* d, bool alignment, int startColAlignment,
|
|
const std::string& before = "", const std::string& after = "");
|
|
void printDocList(DocumentList* d, int startColAlignment, const std::string& before = "",
|
|
const std::string& after = "");
|
|
void printStringDoc(StringDocument* d, bool alignment, int startColAlignment,
|
|
const std::string& before = "", const std::string& after = "");
|
|
void printString(const std::string& s, bool alignment, int startColAlignment);
|
|
bool simplify(int item, int line, std::vector<int>* vec);
|
|
void simplifyItem(int item);
|
|
};
|
|
|
|
void PrettyPrinter::print(Document* d) {
|
|
addItem();
|
|
addLine(0);
|
|
printDocument(d, true, 0);
|
|
if (simp) simplifyItem(currentItem);
|
|
}
|
|
|
|
PrettyPrinter::PrettyPrinter(int _maxwidth, int _indentationBase, bool sim, bool deepsim) {
|
|
maxwidth = _maxwidth;
|
|
indentationBase = _indentationBase;
|
|
currentLine = -1;
|
|
currentItem = -1;
|
|
|
|
simp = sim;
|
|
deeplySimp = deepsim;
|
|
}
|
|
const std::vector<Line>& PrettyPrinter::getCurrentItemLines() const { return items[currentItem]; }
|
|
|
|
void PrettyPrinter::addLine(int indentation, bool bp, bool simpl, int level) {
|
|
items[currentItem].push_back(Line(indentation));
|
|
currentLine++;
|
|
if (bp && deeplySimp) {
|
|
linesToSimplify[currentItem].addLine(level, currentLine);
|
|
if (!simpl) linesNotToSimplify[currentItem].addLine(0, currentLine);
|
|
}
|
|
}
|
|
void PrettyPrinter::addItem() {
|
|
items.push_back(std::vector<Line>());
|
|
linesToSimplify.push_back(LinesToSimplify());
|
|
linesNotToSimplify.push_back(LinesToSimplify());
|
|
currentItem++;
|
|
currentLine = -1;
|
|
}
|
|
|
|
void PrettyPrinter::print(std::ostream& os) const {
|
|
std::vector<Line>::const_iterator it;
|
|
int nItems = static_cast<int>(items.size());
|
|
for (int item = 0; item < nItems; item++) {
|
|
for (it = items[item].begin(); it != items[item].end(); it++) {
|
|
it->print(os);
|
|
}
|
|
// os << std::endl;
|
|
}
|
|
}
|
|
std::string PrettyPrinter::printSpaces(int n) {
|
|
std::string result;
|
|
for (int i = 0; i < n; i++) {
|
|
result += " ";
|
|
}
|
|
return result;
|
|
}
|
|
|
|
void PrettyPrinter::printDocument(Document* d, bool alignment, int alignmentCol,
|
|
const std::string& before, const std::string& after) {
|
|
if (DocumentList* dl = dynamic_cast<DocumentList*>(d)) {
|
|
printDocList(dl, alignmentCol, before, after);
|
|
} else if (StringDocument* sd = dynamic_cast<StringDocument*>(d)) {
|
|
printStringDoc(sd, alignment, alignmentCol, before, after);
|
|
} else if (BreakPoint* bp = dynamic_cast<BreakPoint*>(d)) {
|
|
printString(before, alignment, alignmentCol);
|
|
addLine(alignmentCol, deeplySimp, !bp->getDontSimplify(), d->getLevel());
|
|
printString(after, alignment, alignmentCol);
|
|
} else {
|
|
throw InternalError("PrettyPrinter::print : Wrong type of document");
|
|
}
|
|
}
|
|
|
|
void PrettyPrinter::printStringDoc(StringDocument* d, bool alignment, int alignmentCol,
|
|
const std::string& before, const std::string& after) {
|
|
std::string s;
|
|
if (d != NULL) s = d->getString();
|
|
s = before + s + after;
|
|
printString(s, alignment, alignmentCol);
|
|
}
|
|
|
|
void PrettyPrinter::printString(const std::string& s, bool alignment, int alignmentCol) {
|
|
Line& l = items[currentItem][currentLine];
|
|
int size = static_cast<int>(s.size());
|
|
if (size <= l.getSpaceLeft(maxwidth)) {
|
|
l.addString(s);
|
|
} else {
|
|
int col = alignment && maxwidth - alignmentCol >= size ? alignmentCol : indentationBase;
|
|
addLine(col);
|
|
items[currentItem][currentLine].addString(s);
|
|
}
|
|
}
|
|
|
|
void PrettyPrinter::printDocList(DocumentList* d, int alignmentCol, const std::string& super_before,
|
|
const std::string& super_after) {
|
|
std::vector<Document*> ld = d->getDocs();
|
|
std::string beginToken = d->getBeginToken();
|
|
std::string separator = d->getSeparator();
|
|
std::string endToken = d->getEndToken();
|
|
bool _alignment = d->getAlignment();
|
|
if (d->getUnbreakable()) {
|
|
addLine(alignmentCol);
|
|
}
|
|
int currentCol = items[currentItem][currentLine].getIndentation() +
|
|
items[currentItem][currentLine].getLength();
|
|
int newAlignmentCol =
|
|
_alignment ? currentCol + static_cast<int>(beginToken.size()) : alignmentCol;
|
|
int vectorSize = static_cast<int>(ld.size());
|
|
int lastVisibleElementIndex;
|
|
for (int i = 0; i < vectorSize; i++) {
|
|
if (!dynamic_cast<BreakPoint*>(ld[i])) lastVisibleElementIndex = i;
|
|
}
|
|
if (vectorSize == 0) {
|
|
printStringDoc(NULL, true, newAlignmentCol, super_before + beginToken, endToken + super_after);
|
|
}
|
|
for (int i = 0; i < vectorSize; i++) {
|
|
Document* subdoc = ld[i];
|
|
bool bp = false;
|
|
if (dynamic_cast<BreakPoint*>(subdoc)) {
|
|
if (!_alignment) newAlignmentCol += indentationBase;
|
|
bp = true;
|
|
}
|
|
std::string af, be;
|
|
if (i != vectorSize - 1) {
|
|
if (bp || lastVisibleElementIndex <= i)
|
|
af = "";
|
|
else
|
|
af = separator;
|
|
} else {
|
|
af = endToken + super_after;
|
|
}
|
|
if (i == 0) {
|
|
be = super_before + beginToken;
|
|
} else {
|
|
be = "";
|
|
}
|
|
printDocument(subdoc, _alignment, newAlignmentCol, be, af);
|
|
}
|
|
if (d->getUnbreakable()) {
|
|
simplify(currentItem, currentLine, NULL);
|
|
}
|
|
}
|
|
void PrettyPrinter::simplifyItem(int item) {
|
|
linesToSimplify[item].remove(linesNotToSimplify[item]);
|
|
std::vector<int>* vec = (linesToSimplify[item].getLinesToSimplify());
|
|
while (!vec->empty()) {
|
|
if (!simplify(item, (*vec)[0], vec)) break;
|
|
}
|
|
delete vec;
|
|
}
|
|
|
|
bool PrettyPrinter::simplify(int item, int line, std::vector<int>* vec) {
|
|
if (line == 0) {
|
|
linesToSimplify[item].remove(vec, line, false);
|
|
return false;
|
|
}
|
|
if (items[item][line].getLength() > items[item][line - 1].getSpaceLeft(maxwidth)) {
|
|
linesToSimplify[item].remove(vec, line, false);
|
|
return false;
|
|
} else {
|
|
linesToSimplify[item].remove(vec, line, true);
|
|
items[item][line - 1].concatenateLines(items[item][line]);
|
|
items[item].erase(items[item].begin() + line);
|
|
|
|
linesToSimplify[item].decrementLine(vec, line);
|
|
currentLine--;
|
|
}
|
|
|
|
return true;
|
|
}
|
|
|
|
Printer::Printer(std::ostream& os, int width, bool flatZinc, EnvI* env0)
|
|
: env(env0), ism(NULL), printer(NULL), _os(os), _width(width), _flatZinc(flatZinc) {}
|
|
void Printer::init(void) {
|
|
if (ism == NULL) {
|
|
ism = new ItemDocumentMapper();
|
|
printer = new PrettyPrinter(_width, 4, true, true);
|
|
}
|
|
}
|
|
Printer::~Printer(void) {
|
|
delete printer;
|
|
delete ism;
|
|
}
|
|
|
|
void Printer::p(Document* d) {
|
|
printer->print(d);
|
|
printer->print(_os);
|
|
delete printer;
|
|
printer = new PrettyPrinter(_width, 4, true, true);
|
|
}
|
|
void Printer::p(const Item* i) {
|
|
Document* d;
|
|
switch (i->iid()) {
|
|
case Item::II_INC:
|
|
d = ism->mapIncludeI(*i->cast<IncludeI>());
|
|
break;
|
|
case Item::II_VD:
|
|
d = ism->mapVarDeclI(*i->cast<VarDeclI>());
|
|
break;
|
|
case Item::II_ASN:
|
|
d = ism->mapAssignI(*i->cast<AssignI>());
|
|
break;
|
|
case Item::II_CON:
|
|
d = ism->mapConstraintI(*i->cast<ConstraintI>());
|
|
break;
|
|
case Item::II_SOL:
|
|
d = ism->mapSolveI(*i->cast<SolveI>());
|
|
break;
|
|
case Item::II_OUT:
|
|
d = ism->mapOutputI(*i->cast<OutputI>());
|
|
break;
|
|
case Item::II_FUN:
|
|
d = ism->mapFunctionI(*i->cast<FunctionI>());
|
|
break;
|
|
}
|
|
p(d);
|
|
delete d;
|
|
}
|
|
|
|
void Printer::print(const Expression* e) {
|
|
if (_width == 0) {
|
|
PlainPrinter p(_os, _flatZinc, env);
|
|
p.p(e);
|
|
} else {
|
|
init();
|
|
Document* d = expressionToDocument(e);
|
|
p(d);
|
|
delete d;
|
|
}
|
|
}
|
|
void Printer::print(const Item* i) {
|
|
if (_width == 0) {
|
|
PlainPrinter p(_os, _flatZinc, env);
|
|
p.p(i);
|
|
} else {
|
|
init();
|
|
p(i);
|
|
}
|
|
}
|
|
void Printer::print(const Model* m) {
|
|
if (_width == 0) {
|
|
PlainPrinter p(_os, _flatZinc, env);
|
|
for (unsigned int i = 0; i < m->size(); i++) {
|
|
p.p((*m)[i]);
|
|
}
|
|
} else {
|
|
init();
|
|
for (unsigned int i = 0; i < m->size(); i++) {
|
|
p((*m)[i]);
|
|
}
|
|
}
|
|
}
|
|
|
|
} // namespace MiniZinc
|
|
|
|
void debugprint(MiniZinc::Expression* e) { std::cerr << *e << "\n"; }
|
|
void debugprint(MiniZinc::Item* i) { std::cerr << *i; }
|
|
void debugprint(MiniZinc::Model* m) {
|
|
MiniZinc::Printer p(std::cerr, 0);
|
|
p.print(m);
|
|
}
|
|
void debugprint(const MiniZinc::Location& loc) { std::cerr << loc << std::endl; }
|