// splitBoolExpr splits a boolean expression E into two boolean expressions RES and REM such that:
//
// - RES only has variables known to the conversion function (it is "restricted" to a particular
// set of variables)
//
// - If weaker is true, for any setting of variables x:
// E(x) = (RES(x) AND REM(x))
// This implies RES(x) <= E(x), i.e. RES is "weaker"
//
// - If weaker is false:
// E(x) = (RES(x) OR REM(x))
// This implies RES(x) => E(x), i.e. RES is "stronger"
//
// Note: the original expression is modified in-place and should not be used again.
func splitBoolExpr(expr parser.Expr, conv varConvertFunc, weaker bool) (restricted, remainder parser.Expr) {
// If the expression only contains "restricted" vars, the split is trivial.
if exprCheckVars(expr, conv) {
// An "empty" filter is always true in the weaker (normal) case (where the filter is
// equivalent to RES AND REM) and always false in the stronger (inverted) case (where the
// filter is equivalent to RES OR REM).
return exprConvertVars(expr, conv), parser.DBool(weaker)
}
switch t := expr.(type) {
case *parser.AndExpr:
if weaker {
// In the weaker (normal) case, we have
// E = (leftRes AND leftRem) AND (rightRes AND rightRem)
// We can just rearrange:
// E = (leftRes AND rightRes) AND (leftRem AND rightRem)
leftRes, leftRem := splitBoolExpr(t.Left, conv, weaker)
rightRes, rightRem := splitBoolExpr(t.Right, conv, weaker)
return makeAnd(leftRes, rightRes), makeAnd(leftRem, rightRem)
}
// In the stronger (inverted) case, we have
// E = (leftRes OR leftRem) AND (rightRes OR rightRem)
// We can't do more than:
// E = (leftRes AND rightRes) OR E
exprCopy := expr.DeepCopy()
leftRes, _ := splitBoolExpr(t.Left, conv, weaker)
rightRes, _ := splitBoolExpr(t.Right, conv, weaker)
return makeAnd(leftRes, rightRes), exprCopy
case *parser.OrExpr:
if !weaker {
// In the stronger (inverted) case, we have
// E = (leftRes OR leftRem) OR (rightRes AND rightRem)
// We can just rearrange:
// E = (leftRes OR rightRes) OR (leftRem AND rightRem)
leftRes, leftRem := splitBoolExpr(t.Left, conv, weaker)
rightRes, rightRem := splitBoolExpr(t.Right, conv, weaker)
return makeOr(leftRes, rightRes), makeOr(leftRem, rightRem)
}
// In the weaker (normal) case, we have
// E = (leftRes AND leftRem) OR (rightRes AND rightRem)
// We can't do more than:
// E = (leftRes OR rightRes) OR E
exprCopy := expr.DeepCopy()
leftRes, _ := splitBoolExpr(t.Left, conv, weaker)
rightRes, _ := splitBoolExpr(t.Right, conv, weaker)
return makeOr(leftRes, rightRes), exprCopy
case *parser.ParenExpr:
return splitBoolExpr(t.Expr, conv, weaker)
case *parser.NotExpr:
exprRes, exprRem := splitBoolExpr(t.Expr, conv, !weaker)
return makeNot(exprRes), makeNot(exprRem)
default:
// We can't split off anything (we already handled the case when expr contains only
// restricted vars above).
// For why we return DBool(weaker), see the comment above on "empty" filters.
return parser.DBool(weaker), expr
}
}
