ExpressionPtr Expression::unneededHelper() {
ExpressionListPtr elist = ExpressionListPtr
(new ExpressionList(getScope(), getRange(),
ExpressionList::ListKindWrapped));
bool change = false;
for (int i=0, n = getKidCount(); i < n; i++) {
ExpressionPtr kid = getNthExpr(i);
if (kid && kid->getContainedEffects()) {
ExpressionPtr rep = kid->unneeded();
if (rep != kid) change = true;
if (rep->is(Expression::KindOfExpressionList)) {
for (int j=0, m = rep->getKidCount(); j < m; j++) {
elist->addElement(rep->getNthExpr(j));
}
} else {
elist->addElement(rep);
}
}
}
if (change) {
getScope()->addUpdates(BlockScope::UseKindCaller);
}
int n = elist->getCount();
assert(n);
if (n == 1) {
return elist->getNthExpr(0);
} else {
return elist;
}
}
void InterfaceStatement::checkArgumentsToPromote(
FileScopeRawPtr scope, ExpressionListPtr promotedParams, int type) {
if (!m_stmt) {
return;
}
for (int i = 0; i < m_stmt->getCount(); i++) {
MethodStatementPtr meth =
dynamic_pointer_cast<MethodStatement>((*m_stmt)[i]);
if (meth && meth->isNamed("__construct")) {
ExpressionListPtr params = meth->getParams();
if (params) {
for (int i = 0; i < params->getCount(); i++) {
ParameterExpressionPtr param =
dynamic_pointer_cast<ParameterExpression>((*params)[i]);
if (param->getModifier() != 0) {
if (type == T_TRAIT || type == T_INTERFACE) {
param->parseTimeFatal(scope,
Compiler::InvalidAttribute,
"Constructor parameter promotion "
"not allowed on traits or interfaces");
}
if (promotedParams) {
promotedParams->addElement(param);
}
}
}
}
return; // nothing else to look at
}
}
}
void Parser::onEcho(Token *out, Token *expr, bool html) {
if (html) {
LocationPtr loc = getLocation();
if (loc->line1 == 2 && loc->char1 == 0 && expr->text()[0] == '#') {
// skipping linux interpreter declaration
out->stmt = NEW_STMT0(StatementList);
} else {
ExpressionPtr exp = NEW_EXP(ScalarExpression, T_STRING, expr->text(),
true);
ExpressionListPtr expList = NEW_EXP(ExpressionList);
expList->addElement(exp);
out->stmt = NEW_STMT(EchoStatement, expList);
}
} else {
out->stmt = NEW_STMT(EchoStatement,
dynamic_pointer_cast<ExpressionList>(expr->exp));
}
}
void Parser::addEncap(Token *out, Token *list, Token *expr, int type) {
ExpressionListPtr expList;
if (list->exp) {
expList = dynamic_pointer_cast<ExpressionList>(list->exp);
} else {
expList = NEW_EXP0(ExpressionList);
}
ExpressionPtr exp;
if (type == -1) {
exp = expr->exp;
} else {
ScalarExpressionPtr scalar =
NEW_EXP(ScalarExpression, T_ENCAPSED_AND_WHITESPACE, expr->text(), true);
scalar->onParse(m_ar);
exp = scalar;
}
expList->addElement(exp);
out->exp = expList;
}
ExpressionPtr StatementList::getEffectiveImpl(AnalysisResultConstPtr ar) const {
ExpressionListPtr rep;
for (unsigned int i = 0; i < m_stmts.size(); i++) {
StatementPtr s = m_stmts[i];
if (s->is(KindOfReturnStatement)) {
ExpressionPtr e = static_pointer_cast<ReturnStatement>(s)->getRetExp();
if (!e) {
e = CONSTANT("null");
} else if (!e->isScalar()) {
break;
}
if (!rep) return e;
rep->addElement(e);
return rep;
}
if (s->hasImpl()) {
break;
}
}
return ExpressionPtr();
}
