void SimpleFunctionCall::onParse(AnalysisResultPtr ar) { if (m_class) return; FileScopePtr fs = ar->getFileScope(); ConstructPtr self = shared_from_this(); if (m_className.empty()) { CodeErrorPtr codeError = ar->getCodeError(); switch (m_type) { case CreateFunction: if (m_params->getCount() == 2 && (*m_params)[0]->isLiteralString() && (*m_params)[1]->isLiteralString()) { FunctionScopePtr func = ar->getFunctionScope(); if (func) func->disableInline(); string params = (*m_params)[0]->getLiteralString(); string body = (*m_params)[1]->getLiteralString(); m_lambda = CodeGenerator::GetNewLambda(); string code = "function " + m_lambda + "(" + params + ") " "{" + body + "}"; ar->appendExtraCode(code); } break; case VariableArgumentFunction: ar->getFileScope()->setAttribute(FileScope::VariableArgument); break; case ExtractFunction: ar->getCodeError()->record(self, CodeError::UseExtract, self); ar->getFileScope()->setAttribute(FileScope::ContainsLDynamicVariable); ar->getFileScope()->setAttribute(FileScope::ContainsExtract); break; case CompactFunction: ar->getFileScope()->setAttribute(FileScope::ContainsDynamicVariable); ar->getFileScope()->setAttribute(FileScope::ContainsCompact); break; case ShellExecFunction: ar->getCodeError()->record(self, CodeError::UseShellExec, self); break; case GetDefinedVarsFunction: ar->getFileScope()->setAttribute(FileScope::ContainsGetDefinedVars); ar->getFileScope()->setAttribute(FileScope::ContainsCompact); break; default: CHECK_HOOK(onSimpleFunctionCallFuncType); break; } } string call = getText(); string name = m_name; if (!m_className.empty()) { name = m_className + "::" + name; } ar->getDependencyGraph()->add(DependencyGraph::KindOfFunctionCall, call, shared_from_this(), name); }
void ListAssignment::analyzeProgram(AnalysisResultPtr ar) { if (m_variables) m_variables->analyzeProgram(ar); if (m_array) m_array->analyzeProgram(ar); FunctionScopePtr func = getFunctionScope(); if (func) func->disableInline(); if (ar->getPhase() == AnalysisResult::AnalyzeFinal) { if (m_variables) { for (int i = 0; i < m_variables->getCount(); i++) { ExpressionPtr exp = (*m_variables)[i]; if (exp) { if (!exp->is(Expression::KindOfListAssignment)) { CheckNeeded(exp, ExpressionPtr()); } } } } } }
void ListAssignment::analyzeProgram(AnalysisResultPtr ar) { if (m_variables) m_variables->analyzeProgram(ar); if (m_array) m_array->analyzeProgram(ar); FunctionScopePtr func = ar->getFunctionScope(); if (func) func->disableInline(); }
FunctionScopePtr MethodStatement::onParseImpl(AnalysisResultPtr ar) { int minParam, maxParam; ConstructPtr self = shared_from_this(); minParam = maxParam = 0; bool hasRef = false; if (m_params) { set<string> names; int i = 0; maxParam = m_params->getCount(); for (; i < maxParam; i++) { ParameterExpressionPtr param = dynamic_pointer_cast<ParameterExpression>((*m_params)[i]); if (param->isRef()) hasRef = true; if (param->isOptional()) break; minParam++; } for (i++; i < maxParam; i++) { ParameterExpressionPtr param = dynamic_pointer_cast<ParameterExpression>((*m_params)[i]); if (param->isRef()) hasRef = true; if (!param->isOptional()) { ar->getCodeError()->record(self, CodeError::RequiredAfterOptionalParam, param); param->defaultToNull(ar); } } if (ar->isFirstPass()) { for (i = 0; i < maxParam; i++) { ParameterExpressionPtr param = dynamic_pointer_cast<ParameterExpression>((*m_params)[i]); if (names.find(param->getName()) == names.end()) { names.insert(param->getName()); } else { ar->getCodeError()->record(self, CodeError::RedundantParameter, param); for (int j = 0; j < 1000; j++) { string name = param->getName() + lexical_cast<string>(j); if (names.find(name) == names.end()) { param->rename(name); break; } } } } } } if (hasRef || m_ref) { m_attribute |= FileScope::ContainsReference; } StatementPtr stmt = dynamic_pointer_cast<Statement>(shared_from_this()); FunctionScopePtr funcScope (new FunctionScope(ar, m_method, m_name, stmt, m_ref, minParam, maxParam, m_modifiers, m_attribute, m_docComment, ar->getFileScope())); if (!m_stmt) { funcScope->setVirtual(); } m_funcScope = funcScope; // TODO: this may have to expand to a concept of "virtual" functions... if (ar->getClassScope()) { funcScope->disableInline(); if (m_name.length() > 2 && m_name.substr(0,2) == "__") { bool magic = true; int paramCount = 0; if (m_name == "__destruct") { funcScope->setOverriding(Type::Variant); } else if (m_name == "__call") { funcScope->setOverriding(Type::Variant, Type::String, Type::Array); paramCount = 2; } else if (m_name == "__set") { funcScope->setOverriding(Type::Variant, Type::String, Type::Variant); paramCount = 2; } else if (m_name == "__get") { funcScope->setOverriding(Type::Variant, Type::String); paramCount = 1; } else if (m_name == "__isset") { funcScope->setOverriding(Type::Boolean, Type::String); paramCount = 1; } else if (m_name == "__unset") { funcScope->setOverriding(Type::Variant, Type::String); paramCount = 1; } else if (m_name == "__sleep") { funcScope->setOverriding(Type::Variant); } else if (m_name == "__wakeup") { funcScope->setOverriding(Type::Variant); } else if (m_name == "__set_state") { funcScope->setOverriding(Type::Variant, Type::Variant); paramCount = 1; } else if (m_name == "__tostring") { funcScope->setOverriding(Type::String); } else if (m_name == "__clone") { funcScope->setOverriding(Type::Variant); } else { paramCount = -1; if (m_name != "__construct") { ar->getCodeError()->record(self, CodeError::UnknownMagicMethod, self); magic = false; } } if (paramCount >= 0 && (paramCount != minParam || paramCount != maxParam)) { ar->getCodeError()->record(self, CodeError::InvalidMagicMethod, self); magic = false; } if (magic) funcScope->setMagicMethod(); } // ArrayAccess methods else if (m_name.length() > 6 && m_name.substr(0, 6) == "offset") { if (m_name == "offsetexists") { funcScope->setOverriding(Type::Boolean, Type::Variant); } else if (m_name == "offsetget") { funcScope->setOverriding(Type::Variant, Type::Variant); } else if (m_name == "offsetset") { funcScope->setOverriding(Type::Variant, Type::Variant, Type::Variant); } else if (m_name == "offsetunset") { funcScope->setOverriding(Type::Variant, Type::Variant); } } } return funcScope; }