internal MonaPredDecl(Token name, Cons<MonaParam> parameters, Dictionary<string,MonaParam> pmap, MonaExpr formula, bool isMacro = false)
: base(isMacro ? MonaDeclKind.macro : MonaDeclKind.pred)
{
this.pmap = (pmap == null ? new Dictionary<string,MonaParam>() : pmap);
this.isMacro = isMacro;
this.name = name;
this.parameters = (parameters == null ? Cons<MonaParam>.Empty : parameters);
this.formula = formula;
}
public MonaMinOrMax(Token minormax, MonaExpr set)
: base(minormax, MonaExprType.INT, new MonaExpr[]{set})
{
}
internal MonaNegatedFormula(Token token, MonaExpr formula)
: base(token, MonaExprType.BOOL, new MonaExpr[]{formula})
{
}
internal MonaInt(Token val)
: base(val, MonaExprType.INT, null)
{
if (!val.TryGetInt(out i))
throw new MonaParseException(MonaParseExceptionKind.InvalidIntegerFormat, val.Location);
}
public MonaIsEmpty(Token token, MonaExpr term)
: base(token, MonaExprType.BOOL, new MonaExpr[]{term})
{
}
internal MonaBooleanConstant(Token token)
: base(token, MonaExprType.BOOL, null)
{
}
internal MonaDefaultWhereDecl(bool isSecondOrder, Token param, MonaExpr formula)
: base(isSecondOrder ? MonaDeclKind.defaultwhere2 : MonaDeclKind.defaultwhere1)
{
this.isSecondOrder = isSecondOrder;
this.param = param;
this.formula = formula;
}
internal MonaSet(Token set, Cons<MonaExpr> elems)
: base(set, MonaExprType.SET, elems.ToArray())
{
this.elems = elems;
}
internal MonaSetOp(Token op, MonaExpr arg1, MonaExpr arg2)
: base(op, MonaExprType.SET, new MonaExpr[]{arg1, arg2})
{
}
internal MonaRange(Token dots, MonaExpr from, MonaExpr to)
: base(dots, MonaExprType.SET, new MonaExpr[]{from, to})
{
}
internal MonaRestrict(Token token, MonaExpr formula)
: base(token, MonaExprType.BOOL, new MonaExpr[]{formula})
{
}
internal MonaQFormula(Token quantifier, Cons<MonaVarWhere> vars, MonaExpr formula, Cons<Token> universes, Dictionary<string, MonaParam> varmap)
: base(quantifier, MonaExprType.BOOL, new MonaExpr[] { formula })
{
this.varmap = varmap;
this.universes = universes;
this.vars = vars;
}
internal MonaQBFormula(Token quantifier, Cons<Token> vars, MonaExpr formula, Dictionary<string, MonaParam> varmap)
: base(quantifier, MonaExprType.BOOL, new MonaExpr[]{formula})
{
this.varmap = varmap;
this.vars = vars;
}
internal MonaProgram(Token token, Cons<MonaDecl> declarations, Dictionary<string, MonaDecl> globals,
List<MonaVar0Decl> vars0, List<MonaVarDecl> vars1, List<MonaVarDecl> vars2, List<MonaVarDecl> varsT)
{
this.token = token;
this.declarations = declarations;
this.globals = globals;
this.vars0 = vars0;
this.vars1 = vars1;
this.vars2 = vars2;
this.varsT = varsT;
}
internal MonaBinaryAtom(Token token, MonaExpr term1, MonaExpr term2)
: base(token, MonaExprType.BOOL, new MonaExpr[]{term1, term2})
{
}
internal MonaUnivArg(Token token)
{
this.token = token;
}
internal MonaBinaryBooleanFormula(Token token, MonaExpr formula1, MonaExpr formula2)
: base(token, MonaExprType.BOOL, new MonaExpr[]{formula1, formula2})
{
}
internal MonaUnivArgWithSucc(Token token, string succ)
: base(token)
{
this.succ = succ;
}
internal MonaConstDecl(Token name, MonaExpr def)
: base(MonaDeclKind.constant)
{
this.name = name;
this.def = def;
}
internal MonaUnivArgWithType(Token token, Token E)
: base(token)
{
this.E = E;
}
internal MonaExpr(Token token, MonaExprType type, MonaExpr[] subexprs)
{
this.token = token;
this.type = type;
this.subexprs = subexprs;
}
internal MonaUniverseParam(Token name)
: base(MonaParamKind.universe)
{
this.name = name;
}
internal MonaAllposDecl(Token v)
: base(MonaDeclKind.allpos)
{
this.v = v;
}
internal MonaVar0Decl(Token var)
: base(MonaDeclKind.var0)
{
this.var = var;
}
internal MonaLet(Token letkind, Cons<Tuple<Token, MonaExpr>> lets, MonaExpr formula, Dictionary<string, MonaParam> let_vars)
: base(letkind, MonaExprType.BOOL, new MonaExpr[]{formula})
{
this.lets = lets;
this.let_vars = let_vars;
}
internal MonaVar0Param(Token name)
: base(MonaParamKind.var0)
{
this.name = name;
}
internal MonaName(Token token, MonaExprType type)
: base(token, type, null)
{
}
internal MonaVarWhere(Token token, MonaExpr where)
{
this.token = token;
this.where = where;
}
internal MonaArithmFuncApp(Token func, MonaExpr arg1, MonaExpr arg2)
: base(func, MonaExprType.INT, new MonaExpr[]{arg1, arg2})
{
}
internal MonaPredApp(Token token, Cons<MonaExpr> expressions)
: base(token, MonaExprType.BOOL, expressions.ToArray())
{
this.expressions = expressions;
}
