/**
* If the unary operation is not PHP specific, but something a query
* processor can handle (+ - ! ~), then rewrite the operand to something
* the query processor can evaluate (such as a query parameter reference)
* and rewrite the entire expression to use the rewritten operand.
* If the rewritten operand is the same as the original operand, just
* return the expression as is.
*/
ExpressionPtr CaptureExtractor::rewriteUnary(UnaryOpExpressionPtr ue) {
assert (ue != nullptr);
if (!ue->getFront()) return nullptr;
switch (ue->getOp()) {
case '+':
case '-':
case '!':
case '~':
break; // Could be something the query processor can handle
default:
return newQueryParamRef(ue);
}
auto expr = ue->getExpression();
auto newExpr = rewrite(expr);
if (expr == newExpr) return ue;
return std::make_shared<UnaryOpExpression>(
ue->getScope(), ue->getRange(), newExpr, ue->getOp(), true);
}
ExpressionPtr AliasManager::canonicalizeNode(ExpressionPtr e) {
e->setCanonPtr(ExpressionPtr());
e->setCanonID(0);
switch (e->getKindOf()) {
case Expression::KindOfObjectMethodExpression:
case Expression::KindOfDynamicFunctionCall:
case Expression::KindOfSimpleFunctionCall:
case Expression::KindOfNewObjectExpression:
add(m_bucketMap[0], e);
break;
case Expression::KindOfListAssignment:
add(m_bucketMap[0], e);
break;
case Expression::KindOfAssignmentExpression: {
AssignmentExpressionPtr ae = spc(AssignmentExpression,e);
if (e->getContext() & Expression::DeadStore) {
Construct::recomputeEffects();
return ae->getValue();
}
ExpressionPtr rep;
int interf = findInterf(ae->getVariable(), false, rep);
if (interf == SameAccess) {
switch (rep->getKindOf()) {
default:
break;
case Expression::KindOfAssignmentExpression:
{
AssignmentExpressionPtr a = spc(AssignmentExpression, rep);
ExpressionPtr value = a->getValue();
if (a->getValue()->getContext() & Expression::RefValue) {
break;
}
}
case Expression::KindOfUnaryOpExpression:
case Expression::KindOfBinaryOpExpression:
rep->setContext(Expression::DeadStore);
break;
}
}
add(m_bucketMap[0], e);
break;
}
case Expression::KindOfConstantExpression:
case Expression::KindOfSimpleVariable:
case Expression::KindOfDynamicVariable:
case Expression::KindOfArrayElementExpression:
case Expression::KindOfObjectPropertyExpression:
case Expression::KindOfStaticMemberExpression:
if (!(e->getContext() & (Expression::AssignmentLHS|
Expression::DeepAssignmentLHS|
Expression::OprLValue))) {
if (!(e->getContext() & (Expression::LValue|
Expression::RefValue|
Expression::RefParameter|
Expression::UnsetContext))) {
ExpressionPtr rep;
int interf = findInterf(e, true, rep);
if (interf == SameAccess) {
if (rep->getKindOf() == e->getKindOf()) {
e->setCanonID(rep->getCanonID());
e->setCanonPtr(rep);
return ExpressionPtr();
}
if (rep->getKindOf() == Expression::KindOfAssignmentExpression) {
ExpressionPtr rhs = spc(AssignmentExpression,rep)->getValue();
if (rhs->is(Expression::KindOfScalarExpression)) {
rhs = rhs->clone();
getCanonical(rhs);
return rhs;
}
e->setCanonPtr(rhs);
}
}
}
add(m_bucketMap[0], e);
} else {
getCanonical(e);
}
break;
case Expression::KindOfBinaryOpExpression: {
BinaryOpExpressionPtr bop = spc(BinaryOpExpression, e);
int rop = getOpForAssignmentOp(bop->getOp());
if (rop) {
ExpressionPtr lhs = bop->getExp1();
ExpressionPtr rep;
if (bop->getContext() & Expression::DeadStore) {
Construct::recomputeEffects();
ExpressionPtr rhs = bop->getExp2()->clone();
lhs = lhs->clone();
lhs->clearContext(Expression::LValue);
lhs->clearContext(Expression::NoLValueWrapper);
lhs->clearContext(Expression::OprLValue);
rep = ExpressionPtr
(new BinaryOpExpression(e->getLocation(),
Expression::KindOfBinaryOpExpression,
lhs, rhs, rop));
} else {
ExpressionPtr alt;
int interf = findInterf(lhs, true, alt);
if (interf == SameAccess &&
alt->is(Expression::KindOfAssignmentExpression)) {
ExpressionPtr op0 = spc(AssignmentExpression,alt)->getValue();
if (op0->is(Expression::KindOfScalarExpression)) {
ExpressionPtr op1 = bop->getExp2();
ExpressionPtr rhs
(new BinaryOpExpression(e->getLocation(),
Expression::KindOfBinaryOpExpression,
op0->clone(), op1->clone(), rop));
lhs = lhs->clone();
lhs->clearContext(Expression::OprLValue);
rep = ExpressionPtr
(new AssignmentExpression(e->getLocation(),
Expression::KindOfAssignmentExpression,
lhs, rhs, false));
}
}
}
if (rep) {
ExpressionPtr c = canonicalizeRecur(rep);
return c ? c : rep;
}
add(m_bucketMap[0], e);
} else {
getCanonical(e);
}
break;
}
case Expression::KindOfUnaryOpExpression:
{
UnaryOpExpressionPtr uop = spc(UnaryOpExpression, e);
switch (uop->getOp()) {
case T_INC:
case T_DEC:
if (uop->getContext() & Expression::DeadStore) {
Construct::recomputeEffects();
ExpressionPtr val = uop->getExpression()->clone();
val->clearContext(Expression::LValue);
val->clearContext(Expression::NoLValueWrapper);
val->clearContext(Expression::OprLValue);
if (uop->getFront()) {
ExpressionPtr inc
(new ScalarExpression(uop->getLocation(),
Expression::KindOfScalarExpression,
T_LNUMBER, string("1")));
val = ExpressionPtr
(new BinaryOpExpression(uop->getLocation(),
Expression::KindOfBinaryOpExpression,
val, inc,
uop->getOp() == T_INC ? '+' : '-'));
}
ExpressionPtr r = canonicalizeRecur(val);
return r ? r : val;
}
add(m_bucketMap[0], e);
break;
default:
getCanonical(e);
break;
}
break;
}
default:
getCanonical(e);
break;
}
return ExpressionPtr();
}
