ExpressionPtr Option::GetValue(VariableTablePtr variables,
const char *varName) {
ConstructPtr decl = variables->getDeclaration(varName);
if (!decl) {
return ExpressionPtr();
}
AssignmentExpressionPtr assignment =
dynamic_pointer_cast<AssignmentExpression>(decl);
if (!assignment) {
Logger::Error("Line %d: Ignored option %s", decl->getLocation()->line1,
varName);
return ExpressionPtr();
}
return assignment->getValue();
}
/**
* ArrayElementExpression comes from:
*
* reference_variable[|expr]
* ->object_dim_list[|expr]
* encaps T_VARIABLE[expr]
* encaps ${T_STRING[expr]}
*/
TypePtr ArrayElementExpression::inferTypes(AnalysisResultPtr ar,
TypePtr type, bool coerce) {
ConstructPtr self = shared_from_this();
// handling $GLOBALS[...]
if (m_variable->is(Expression::KindOfSimpleVariable)) {
SimpleVariablePtr var =
dynamic_pointer_cast<SimpleVariable>(m_variable);
if (var->getName() == "GLOBALS") {
clearEffect(AccessorEffect);
m_global = true;
m_dynamicGlobal = true;
ar->getScope()->getVariables()->
setAttribute(VariableTable::NeedGlobalPointer);
VariableTablePtr vars = ar->getVariables();
if (m_offset && m_offset->is(Expression::KindOfScalarExpression)) {
ScalarExpressionPtr offset =
dynamic_pointer_cast<ScalarExpression>(m_offset);
if (offset->isLiteralString()) {
m_globalName = offset->getIdentifier();
if (!m_globalName.empty()) {
m_dynamicGlobal = false;
ar->getScope()->getVariables()->
setAttribute(VariableTable::NeedGlobalPointer);
TypePtr ret;
ConstructPtr decl = vars->getDeclaration(m_globalName);
if (decl) {
ar->getDependencyGraph()->
add(DependencyGraph::KindOfGlobalVariable,
ar->getName(),
m_globalName, self, m_globalName, decl);
}
if (coerce) {
ret = vars->add(m_globalName, type, true, ar, self,
ModifierExpressionPtr());
} else {
int p;
ret =
vars->checkVariable(m_globalName, type, coerce, ar, self, p);
}
ar->getScope()->getVariables()->addSuperGlobal(m_globalName);
return ret;
}
}
} else {
vars->setAttribute(VariableTable::ContainsDynamicVariable);
}
if (hasContext(LValue) || hasContext(RefValue)) {
if (ar->isFirstPass()) {
ar->getCodeError()->record(self, CodeError::UseLDynamicVariable,
self);
}
ar->getVariables()->forceVariants(ar);
ar->getVariables()->
setAttribute(VariableTable::ContainsLDynamicVariable);
} else {
if (ar->isFirstPass()) {
ar->getCodeError()->record(self, CodeError::UseRDynamicVariable,
self);
}
}
if (m_offset) {
m_offset->inferAndCheck(ar, NEW_TYPE(Primitive), false);
}
return m_implementedType = Type::Variant; // so not to lose values
}
}
if ((hasContext(LValue) || hasContext(RefValue)) &&
!hasContext(UnsetContext)) {
m_variable->setContext(LValue);
}
TypePtr varType;
if (m_offset) {
varType = m_variable->inferAndCheck(ar, NEW_TYPE(Sequence), false);
m_offset->inferAndCheck(ar, NEW_TYPE(Some), false);
} else {
if (hasContext(ExistContext) || hasContext(UnsetContext)) {
if (ar->isFirstPass()) {
ar->getCodeError()->record(self, CodeError::InvalidArrayElement,
self);
}
}
m_variable->inferAndCheck(ar, Type::Array, true);
}
if (varType && Type::SameType(varType, Type::String)) {
clearEffect(AccessorEffect);
m_implementedType.reset();
return Type::String;
}
if (varType && Type::SameType(varType, Type::Array)) {
clearEffect(AccessorEffect);
}
if (hasContext(LValue) || hasContext(RefValue)) setEffect(CreateEffect);
TypePtr ret = propagateTypes(ar, Type::Variant);
m_implementedType = Type::Variant;
return ret; // so not to lose values
}
