mwilliams
e300bc8cce
Setup for parameters was skipped by some cleanup of the use of the WholeProgram flag. Re-enable it.
2600 linhas
89 KiB
C++
2600 linhas
89 KiB
C++
/*
|
|
+----------------------------------------------------------------------+
|
|
| HipHop for PHP |
|
|
+----------------------------------------------------------------------+
|
|
| Copyright (c) 2010- Facebook, Inc. (http://www.facebook.com) |
|
|
+----------------------------------------------------------------------+
|
|
| This source file is subject to version 3.01 of the PHP license, |
|
|
| that is bundled with this package in the file LICENSE, and is |
|
|
| available through the world-wide-web at the following url: |
|
|
| http://www.php.net/license/3_01.txt |
|
|
| If you did not receive a copy of the PHP license and are unable to |
|
|
| obtain it through the world-wide-web, please send a note to |
|
|
| license@php.net so we can mail you a copy immediately. |
|
|
+----------------------------------------------------------------------+
|
|
*/
|
|
|
|
#include <compiler/analysis/function_scope.h>
|
|
#include <compiler/analysis/analysis_result.h>
|
|
#include <compiler/expression/constant_expression.h>
|
|
#include <compiler/expression/modifier_expression.h>
|
|
#include <compiler/expression/expression_list.h>
|
|
#include <compiler/expression/function_call.h>
|
|
#include <compiler/analysis/code_error.h>
|
|
#include <compiler/statement/statement_list.h>
|
|
#include <compiler/analysis/file_scope.h>
|
|
#include <compiler/analysis/variable_table.h>
|
|
#include <compiler/parser/parser.h>
|
|
#include <util/logger.h>
|
|
#include <compiler/option.h>
|
|
#include <compiler/statement/method_statement.h>
|
|
#include <compiler/statement/exp_statement.h>
|
|
#include <compiler/expression/parameter_expression.h>
|
|
#include <compiler/analysis/class_scope.h>
|
|
#include <util/atomic.h>
|
|
#include <util/util.h>
|
|
#include <runtime/base/class_info.h>
|
|
#include <runtime/base/type_conversions.h>
|
|
#include <runtime/base/builtin_functions.h>
|
|
#include <util/parser/hphp.tab.hpp>
|
|
#include <runtime/base/variable_serializer.h>
|
|
#include <runtime/base/zend/zend_string.h>
|
|
|
|
using namespace HPHP;
|
|
|
|
///////////////////////////////////////////////////////////////////////////////
|
|
|
|
FunctionScope::FunctionScope(AnalysisResultConstPtr ar, bool method,
|
|
const std::string &name, StatementPtr stmt,
|
|
bool reference, int minParam, int maxParam,
|
|
ModifierExpressionPtr modifiers,
|
|
int attribute, const std::string &docComment,
|
|
FileScopePtr file,
|
|
const std::vector<UserAttributePtr> &attrs,
|
|
bool inPseudoMain /* = false */)
|
|
: BlockScope(name, docComment, stmt, BlockScope::FunctionScope),
|
|
m_minParam(minParam), m_maxParam(maxParam), m_attribute(attribute),
|
|
m_modifiers(modifiers), m_hasVoid(false),
|
|
m_method(method), m_refReturn(reference), m_virtual(false),
|
|
m_hasOverride(false), m_perfectVirtual(false), m_overriding(false),
|
|
m_volatile(false), m_persistent(false), m_pseudoMain(inPseudoMain),
|
|
m_magicMethod(false), m_system(false), m_inlineable(false), m_sep(false),
|
|
m_containsThis(false), m_containsBareThis(0), m_nrvoFix(true),
|
|
m_inlineAsExpr(false), m_inlineSameContext(false),
|
|
m_contextSensitive(false),
|
|
m_directInvoke(false), m_needsRefTemp(false),
|
|
m_needsObjTemp(false), m_needsCheckMem(false),
|
|
m_closureGenerator(false), m_noLSB(false), m_nextLSB(false),
|
|
m_hasTry(false), m_hasGoto(false), m_localRedeclaring(false),
|
|
m_redeclaring(-1), m_inlineIndex(0), m_optFunction(0), m_nextID(0) {
|
|
init(ar);
|
|
for (unsigned i = 0; i < attrs.size(); ++i) {
|
|
if (m_userAttributes.find(attrs[i]->getName()) != m_userAttributes.end()) {
|
|
attrs[i]->parseTimeFatal(Compiler::DeclaredAttributeTwice,
|
|
"Redeclared attribute %s",
|
|
attrs[i]->getName().c_str());
|
|
}
|
|
m_userAttributes[attrs[i]->getName()] = attrs[i]->getExp();
|
|
}
|
|
}
|
|
|
|
FunctionScope::FunctionScope(FunctionScopePtr orig,
|
|
AnalysisResultConstPtr ar,
|
|
const string &name,
|
|
const string &originalName,
|
|
StatementPtr stmt,
|
|
ModifierExpressionPtr modifiers)
|
|
: BlockScope(name, orig->m_docComment, stmt,
|
|
BlockScope::FunctionScope),
|
|
m_minParam(orig->m_minParam), m_maxParam(orig->m_maxParam),
|
|
m_attribute(orig->m_attribute), m_modifiers(modifiers),
|
|
m_userAttributes(orig->m_userAttributes), m_hasVoid(orig->m_hasVoid),
|
|
m_method(orig->m_method), m_refReturn(orig->m_refReturn),
|
|
m_virtual(orig->m_virtual), m_hasOverride(orig->m_hasOverride),
|
|
m_perfectVirtual(orig->m_perfectVirtual),
|
|
m_overriding(orig->m_overriding), m_volatile(orig->m_volatile),
|
|
m_persistent(orig->m_persistent),
|
|
m_pseudoMain(orig->m_pseudoMain), m_magicMethod(orig->m_magicMethod),
|
|
m_system(orig->m_system), m_inlineable(orig->m_inlineable),
|
|
m_sep(orig->m_sep), m_containsThis(orig->m_containsThis),
|
|
m_containsBareThis(orig->m_containsBareThis), m_nrvoFix(orig->m_nrvoFix),
|
|
m_inlineAsExpr(orig->m_inlineAsExpr),
|
|
m_inlineSameContext(orig->m_inlineSameContext),
|
|
m_contextSensitive(orig->m_contextSensitive),
|
|
m_directInvoke(orig->m_directInvoke),
|
|
m_needsRefTemp(orig->m_needsRefTemp),
|
|
m_needsObjTemp(orig->m_needsObjTemp),
|
|
m_needsCheckMem(orig->m_needsCheckMem),
|
|
m_closureGenerator(orig->m_closureGenerator), m_noLSB(orig->m_noLSB),
|
|
m_nextLSB(orig->m_nextLSB), m_hasTry(orig->m_hasTry),
|
|
m_hasGoto(orig->m_hasGoto), m_localRedeclaring(orig->m_localRedeclaring),
|
|
m_redeclaring(orig->m_redeclaring),
|
|
m_inlineIndex(orig->m_inlineIndex), m_optFunction(orig->m_optFunction),
|
|
m_nextID(0) {
|
|
init(ar);
|
|
m_originalName = originalName;
|
|
setParamCounts(ar, m_minParam, m_maxParam);
|
|
}
|
|
|
|
void FunctionScope::init(AnalysisResultConstPtr ar) {
|
|
m_dynamicInvoke = false;
|
|
bool canInline = true;
|
|
if (m_pseudoMain) {
|
|
canInline = false;
|
|
m_variables->forceVariants(ar, VariableTable::AnyVars);
|
|
setReturnType(ar, Type::Variant);
|
|
}
|
|
|
|
if (m_refReturn) {
|
|
m_returnType = Type::Variant;
|
|
}
|
|
|
|
if (!strcasecmp(m_name.c_str(), "__autoload")) {
|
|
setVolatile();
|
|
}
|
|
|
|
// FileScope's flags are from parser, but VariableTable has more flags
|
|
// coming from type inference phase. So we are tranferring these flags
|
|
// just for better modularization between FileScope and VariableTable.
|
|
if (m_attribute & FileScope::ContainsDynamicVariable) {
|
|
m_variables->setAttribute(VariableTable::ContainsDynamicVariable);
|
|
}
|
|
if (m_attribute & FileScope::ContainsLDynamicVariable) {
|
|
m_variables->setAttribute(VariableTable::ContainsLDynamicVariable);
|
|
}
|
|
if (m_attribute & FileScope::ContainsExtract) {
|
|
m_variables->setAttribute(VariableTable::ContainsExtract);
|
|
}
|
|
if (m_attribute & FileScope::ContainsCompact) {
|
|
m_variables->setAttribute(VariableTable::ContainsCompact);
|
|
}
|
|
if (m_attribute & FileScope::ContainsUnset) {
|
|
m_variables->setAttribute(VariableTable::ContainsUnset);
|
|
}
|
|
if (m_attribute & FileScope::ContainsGetDefinedVars) {
|
|
m_variables->setAttribute(VariableTable::ContainsGetDefinedVars);
|
|
}
|
|
|
|
if (m_stmt && Option::AllVolatile && !m_pseudoMain && !m_method) {
|
|
m_volatile = true;
|
|
}
|
|
|
|
m_dynamic = Option::IsDynamicFunction(m_method, m_name) ||
|
|
Option::EnableEval == Option::FullEval || Option::AllDynamic;
|
|
if (!m_method && Option::DynamicInvokeFunctions.find(m_name) !=
|
|
Option::DynamicInvokeFunctions.end()) {
|
|
setDynamicInvoke();
|
|
}
|
|
if (m_modifiers) {
|
|
m_virtual = m_modifiers->isAbstract();
|
|
}
|
|
|
|
if (m_stmt) {
|
|
MethodStatementPtr stmt = dynamic_pointer_cast<MethodStatement>(m_stmt);
|
|
StatementListPtr stmts = stmt->getStmts();
|
|
if (stmts) {
|
|
if (stmts->getRecursiveCount() > Option::InlineFunctionThreshold)
|
|
canInline = false;
|
|
for (int i = 0; i < stmts->getCount(); i++) {
|
|
StatementPtr stmt = (*stmts)[i];
|
|
stmt->setFileLevel();
|
|
if (stmt->is(Statement::KindOfExpStatement)) {
|
|
ExpStatementPtr expStmt = dynamic_pointer_cast<ExpStatement>(stmt);
|
|
ExpressionPtr exp = expStmt->getExpression();
|
|
exp->setTopLevel();
|
|
}
|
|
}
|
|
}
|
|
} else {
|
|
canInline = false;
|
|
}
|
|
m_inlineable = canInline;
|
|
}
|
|
|
|
FunctionScope::FunctionScope(bool method, const std::string &name,
|
|
bool reference)
|
|
: BlockScope(name, "", StatementPtr(), BlockScope::FunctionScope),
|
|
m_minParam(0), m_maxParam(0), m_attribute(0),
|
|
m_modifiers(ModifierExpressionPtr()), m_hasVoid(false),
|
|
m_method(method), m_refReturn(reference), m_virtual(false),
|
|
m_hasOverride(false), m_perfectVirtual(false), m_overriding(false),
|
|
m_volatile(false), m_persistent(false), m_pseudoMain(false),
|
|
m_magicMethod(false), m_system(true), m_inlineable(false), m_sep(false),
|
|
m_containsThis(false), m_containsBareThis(0), m_nrvoFix(true),
|
|
m_inlineAsExpr(false), m_inlineSameContext(false),
|
|
m_contextSensitive(false),
|
|
m_directInvoke(false), m_needsRefTemp(false), m_needsObjTemp(false),
|
|
m_closureGenerator(false), m_noLSB(false), m_nextLSB(false),
|
|
m_hasTry(false), m_hasGoto(false), m_localRedeclaring(false),
|
|
m_redeclaring(-1), m_inlineIndex(0),
|
|
m_optFunction(0) {
|
|
m_dynamic = Option::IsDynamicFunction(method, m_name) ||
|
|
Option::EnableEval == Option::FullEval || Option::AllDynamic;
|
|
m_dynamicInvoke = false;
|
|
if (!method && Option::DynamicInvokeFunctions.find(m_name) !=
|
|
Option::DynamicInvokeFunctions.end()) {
|
|
setDynamicInvoke();
|
|
}
|
|
}
|
|
|
|
void FunctionScope::setDynamicInvoke() {
|
|
m_returnType = Type::Variant;
|
|
m_dynamicInvoke = true;
|
|
}
|
|
|
|
void FunctionScope::setParamCounts(AnalysisResultConstPtr ar, int minParam,
|
|
int maxParam) {
|
|
if (minParam >= 0) {
|
|
m_minParam = minParam;
|
|
m_maxParam = maxParam;
|
|
} else {
|
|
assert(maxParam == minParam);
|
|
}
|
|
assert(m_minParam >= 0 && m_maxParam >= m_minParam);
|
|
if (m_maxParam > 0) {
|
|
m_paramNames.resize(m_maxParam);
|
|
m_paramTypes.resize(m_maxParam);
|
|
m_paramTypeSpecs.resize(m_maxParam);
|
|
m_paramDefaults.resize(m_maxParam);
|
|
m_paramDefaultTexts.resize(m_maxParam);
|
|
m_refs.resize(m_maxParam);
|
|
|
|
if (m_stmt) {
|
|
MethodStatementPtr stmt = dynamic_pointer_cast<MethodStatement>(m_stmt);
|
|
ExpressionListPtr params = stmt->getParams();
|
|
|
|
for (int i = 0; i < m_maxParam; i++) {
|
|
if (stmt->isRef(i)) m_refs[i] = true;
|
|
|
|
ParameterExpressionPtr param =
|
|
dynamic_pointer_cast<ParameterExpression>((*params)[i]);
|
|
m_paramNames[i] = param->getName();
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
void FunctionScope::setParamSpecs(AnalysisResultPtr ar) {
|
|
if (m_maxParam > 0 && m_stmt) {
|
|
MethodStatementPtr stmt = dynamic_pointer_cast<MethodStatement>(m_stmt);
|
|
ExpressionListPtr params = stmt->getParams();
|
|
|
|
for (int i = 0; i < m_maxParam; i++) {
|
|
ParameterExpressionPtr param =
|
|
dynamic_pointer_cast<ParameterExpression>((*params)[i]);
|
|
TypePtr specType = param->getTypeSpec(ar, false);
|
|
if (specType &&
|
|
!specType->is(Type::KindOfSome) &&
|
|
!specType->is(Type::KindOfVariant)) {
|
|
m_paramTypeSpecs[i] = specType;
|
|
}
|
|
ExpressionPtr exp = param->defaultValue();
|
|
if (exp) {
|
|
m_paramDefaults[i] = exp->getText(false, false, ar);
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
bool FunctionScope::isPublic() const {
|
|
return m_modifiers && m_modifiers->isPublic();
|
|
}
|
|
|
|
bool FunctionScope::isProtected() const {
|
|
return m_modifiers && m_modifiers->isProtected();
|
|
}
|
|
|
|
bool FunctionScope::isPrivate() const {
|
|
return m_modifiers && m_modifiers->isPrivate();
|
|
}
|
|
|
|
bool FunctionScope::isStatic() const {
|
|
return m_modifiers && m_modifiers->isStatic();
|
|
}
|
|
|
|
bool FunctionScope::isAbstract() const {
|
|
return m_modifiers && m_modifiers->isAbstract();
|
|
}
|
|
|
|
bool FunctionScope::isFinal() const {
|
|
return m_modifiers && m_modifiers->isFinal();
|
|
}
|
|
|
|
bool FunctionScope::isVariableArgument() const {
|
|
bool res = (m_attribute & FileScope::VariableArgument) && !m_overriding;
|
|
return res;
|
|
}
|
|
|
|
bool FunctionScope::ignoreRedefinition() const {
|
|
return m_attribute & FileScope::IgnoreRedefinition;
|
|
}
|
|
|
|
bool FunctionScope::isReferenceVariableArgument() const {
|
|
bool res = (m_attribute & FileScope::ReferenceVariableArgument) &&
|
|
!m_overriding;
|
|
// If this method returns true, then isVariableArgument() must also
|
|
// return true.
|
|
assert(!res || isVariableArgument());
|
|
return res;
|
|
}
|
|
|
|
bool FunctionScope::isMixedVariableArgument() const {
|
|
bool res = (m_attribute & FileScope::MixedVariableArgument) && !m_overriding;
|
|
// If this method returns true, then isReferenceVariableArgument()
|
|
// must also return true.
|
|
assert(!res || isReferenceVariableArgument());
|
|
return res;
|
|
}
|
|
|
|
bool FunctionScope::needsActRec() const {
|
|
bool res = (m_attribute & FileScope::NeedsActRec);
|
|
return res;
|
|
}
|
|
|
|
bool FunctionScope::isClosure() const {
|
|
return ParserBase::IsClosureName(name());
|
|
}
|
|
|
|
bool FunctionScope::isGenerator() const {
|
|
assert(!getOrigGenStmt() ||
|
|
(ParserBase::IsContinuationName(name()) &&
|
|
m_paramNames.size() == 1 &&
|
|
m_paramNames[0] == CONTINUATION_OBJECT_NAME));
|
|
return getOrigGenStmt();
|
|
}
|
|
|
|
bool FunctionScope::hasGeneratorAsBody() const {
|
|
MethodStatementPtr stmt = dynamic_pointer_cast<MethodStatement>(getStmt());
|
|
return stmt ? stmt->getGeneratorFunc() : false;
|
|
}
|
|
|
|
bool FunctionScope::isGeneratorFromClosure() const {
|
|
bool res = isGenerator() && getOrigGenFS()->isClosure();
|
|
assert(!res || getOrigGenFS()->isClosureGenerator());
|
|
return res;
|
|
}
|
|
|
|
MethodStatementRawPtr FunctionScope::getOrigGenStmt() const {
|
|
if (!getStmt()) return MethodStatementRawPtr();
|
|
MethodStatementPtr m =
|
|
dynamic_pointer_cast<MethodStatement>(getStmt());
|
|
return m ? m->getOrigGeneratorFunc() : MethodStatementRawPtr();
|
|
}
|
|
|
|
FunctionScopeRawPtr FunctionScope::getOrigGenFS() const {
|
|
MethodStatementRawPtr origStmt = getOrigGenStmt();
|
|
return origStmt ? origStmt->getFunctionScope() : FunctionScopeRawPtr();
|
|
}
|
|
|
|
void FunctionScope::setVariableArgument(int reference) {
|
|
m_attribute |= FileScope::VariableArgument;
|
|
if (reference) {
|
|
m_attribute |= FileScope::ReferenceVariableArgument;
|
|
if (reference < 0) {
|
|
m_attribute |= FileScope::MixedVariableArgument;
|
|
}
|
|
}
|
|
}
|
|
|
|
void FunctionScope::setIgnoreRedefinition() {
|
|
m_attribute |= FileScope::IgnoreRedefinition;
|
|
}
|
|
|
|
bool FunctionScope::hasEffect() const {
|
|
return (m_attribute & FileScope::NoEffect) == 0;
|
|
}
|
|
|
|
void FunctionScope::setNoEffect() {
|
|
if (!(m_attribute & FileScope::NoEffect)) {
|
|
m_attribute |= FileScope::NoEffect;
|
|
}
|
|
}
|
|
|
|
bool FunctionScope::isFoldable() const {
|
|
return m_attribute & FileScope::IsFoldable;
|
|
}
|
|
|
|
void FunctionScope::setIsFoldable() {
|
|
m_attribute |= FileScope::IsFoldable;
|
|
}
|
|
|
|
void FunctionScope::setNeedsActRec() {
|
|
m_attribute |= FileScope::NeedsActRec;
|
|
}
|
|
|
|
void FunctionScope::setHelperFunction() {
|
|
m_attribute |= FileScope::HelperFunction;
|
|
}
|
|
|
|
bool FunctionScope::containsReference() const {
|
|
return m_attribute & FileScope::ContainsReference;
|
|
}
|
|
|
|
bool FunctionScope::hasImpl() const {
|
|
if (!isUserFunction()) {
|
|
return !isAbstract();
|
|
}
|
|
if (m_stmt) {
|
|
MethodStatementPtr stmt = dynamic_pointer_cast<MethodStatement>(m_stmt);
|
|
return stmt->getStmts();
|
|
}
|
|
return false;
|
|
}
|
|
|
|
bool FunctionScope::isConstructor(ClassScopePtr cls) const {
|
|
return m_stmt && cls
|
|
&& (getName() == "__construct"
|
|
|| (cls->classNameCtor() && getName() == cls->getName()));
|
|
}
|
|
|
|
bool FunctionScope::isMagic() const {
|
|
return m_name.size() >= 2 && m_name[0] == '_' && m_name[1] == '_';
|
|
}
|
|
|
|
bool FunctionScope::needsLocalThis() const {
|
|
return containsBareThis() &&
|
|
(inPseudoMain() ||
|
|
containsRefThis() ||
|
|
isStatic() ||
|
|
getVariables()->getAttribute(
|
|
VariableTable::ContainsDynamicVariable));
|
|
}
|
|
|
|
static std::string s_empty;
|
|
const string &FunctionScope::getOriginalName() const {
|
|
if (m_pseudoMain) return s_empty;
|
|
if (m_stmt) {
|
|
MethodStatementPtr stmt = dynamic_pointer_cast<MethodStatement>(m_stmt);
|
|
return stmt->getOriginalName();
|
|
}
|
|
return m_originalName;
|
|
}
|
|
|
|
string FunctionScope::getFullName() const {
|
|
if (m_stmt) {
|
|
MethodStatementPtr stmt = dynamic_pointer_cast<MethodStatement>(m_stmt);
|
|
return stmt->getFullName();
|
|
}
|
|
return m_name;
|
|
}
|
|
|
|
string FunctionScope::getOriginalFullName() const {
|
|
if (m_stmt) {
|
|
MethodStatementPtr stmt = dynamic_pointer_cast<MethodStatement>(m_stmt);
|
|
return stmt->getOriginalFullName();
|
|
}
|
|
return m_name;
|
|
}
|
|
|
|
///////////////////////////////////////////////////////////////////////////////
|
|
|
|
void FunctionScope::addCaller(BlockScopePtr caller,
|
|
bool careAboutReturn /* = true */) {
|
|
addUse(caller, UseKindCaller);
|
|
}
|
|
|
|
void FunctionScope::addNewObjCaller(BlockScopePtr caller) {
|
|
addUse(caller, UseKindCaller & ~UseKindCallerReturn);
|
|
}
|
|
|
|
bool FunctionScope::mayUseVV() const {
|
|
VariableTableConstPtr variables = getVariables();
|
|
return (inPseudoMain() ||
|
|
isVariableArgument() ||
|
|
isGenerator() ||
|
|
variables->getAttribute(VariableTable::ContainsDynamicVariable) ||
|
|
variables->getAttribute(VariableTable::ContainsExtract) ||
|
|
variables->getAttribute(VariableTable::ContainsCompact) ||
|
|
variables->getAttribute(VariableTable::ContainsGetDefinedVars) ||
|
|
variables->getAttribute(VariableTable::ContainsDynamicFunctionCall));
|
|
}
|
|
|
|
bool FunctionScope::matchParams(FunctionScopePtr func) {
|
|
// leaving them alone for now
|
|
if (m_overriding || func->m_overriding) return false;
|
|
if (isStatic() || func->isStatic()) return false;
|
|
|
|
// conservative here, as we could normalize them into same counts.
|
|
if (m_minParam != func->m_minParam || m_maxParam != func->m_maxParam) {
|
|
return false;
|
|
}
|
|
if (isVariableArgument() != func->isVariableArgument() ||
|
|
isReferenceVariableArgument() != func->isReferenceVariableArgument() ||
|
|
isMixedVariableArgument() != func->isMixedVariableArgument()) {
|
|
return false;
|
|
}
|
|
|
|
// needs perfect match for ref, hint and defaults
|
|
for (int i = 0; i < m_maxParam; i++) {
|
|
if (m_refs[i] != func->m_refs[i]) return false;
|
|
|
|
TypePtr type1 = m_paramTypeSpecs[i];
|
|
TypePtr type2 = func->m_paramTypeSpecs[i];
|
|
if ((type1 && !type2) || (!type1 && type2) ||
|
|
(type1 && type2 && !Type::SameType(type1, type2))) return false;
|
|
|
|
if (m_paramDefaults[i] != func->m_paramDefaults[i]) return false;
|
|
}
|
|
|
|
return true;
|
|
}
|
|
|
|
void FunctionScope::setPerfectVirtual() {
|
|
m_virtual = true;
|
|
m_perfectVirtual = true;
|
|
|
|
// conservative here, as we could still try to infer types THEN only
|
|
// force variants on non-matching parameters
|
|
m_returnType = Type::Variant;
|
|
for (unsigned int i = 0; i < m_paramTypes.size(); i++) {
|
|
m_paramTypes[i] = Type::Variant;
|
|
m_variables->addLvalParam(m_paramNames[i]);
|
|
}
|
|
}
|
|
|
|
bool FunctionScope::needsTypeCheckWrapper() const {
|
|
for (int i = 0; i < m_maxParam; i++) {
|
|
if (isRefParam(i)) continue;
|
|
if (TypePtr spec = m_paramTypeSpecs[i]) {
|
|
if (Type::SameType(spec, m_paramTypes[i])) {
|
|
return true;
|
|
}
|
|
}
|
|
}
|
|
return false;
|
|
}
|
|
|
|
bool FunctionScope::needsClassParam() {
|
|
if (!isStatic()) return false;
|
|
ClassScopeRawPtr cls = getContainingClass();
|
|
if (!ClassScope::NeedStaticArray(cls, FunctionScopeRawPtr(this))) {
|
|
return false;
|
|
}
|
|
return getVariables()->hasStatic();
|
|
}
|
|
|
|
const char *FunctionScope::getPrefix(AnalysisResultPtr ar, ExpressionListPtr params) {
|
|
bool isMethod = getContainingClass();
|
|
bool callInner = false;
|
|
if (Option::HardTypeHints && !Option::SystemGen &&
|
|
!m_system && !m_sep && params) {
|
|
int count = params->getCount();
|
|
if (count >= m_minParam) {
|
|
for (int i = 0; i < count; i++) {
|
|
if (i == m_maxParam) break;
|
|
if (isRefParam(i)) continue;
|
|
if (TypePtr spec = m_paramTypeSpecs[i]) {
|
|
if (Type::SameType(spec, m_paramTypes[i])) {
|
|
ExpressionPtr p = (*params)[i];
|
|
TypePtr at = p->getActualType();
|
|
if (!Type::SubType(ar, at, spec)) {
|
|
callInner = false;
|
|
break;
|
|
}
|
|
callInner = true;
|
|
}
|
|
}
|
|
}
|
|
}
|
|
}
|
|
if (callInner) {
|
|
return isMethod ? Option::TypedMethodPrefix : Option::TypedFunctionPrefix;
|
|
}
|
|
|
|
return isMethod ? Option::MethodPrefix : Option::FunctionPrefix;
|
|
}
|
|
|
|
int FunctionScope::inferParamTypes(AnalysisResultPtr ar, ConstructPtr exp,
|
|
ExpressionListPtr params, bool &valid) {
|
|
if (!params) {
|
|
if (m_minParam > 0) {
|
|
if (exp->getScope()->isFirstPass()) {
|
|
Compiler::Error(Compiler::TooFewArgument, exp, m_stmt);
|
|
}
|
|
valid = false;
|
|
if (!Option::AllDynamic) setDynamic();
|
|
}
|
|
return 0;
|
|
}
|
|
|
|
int ret = 0;
|
|
if (params->getCount() < m_minParam) {
|
|
if (exp->getScope()->isFirstPass()) {
|
|
Compiler::Error(Compiler::TooFewArgument, exp, m_stmt);
|
|
}
|
|
valid = false;
|
|
if (!Option::AllDynamic) setDynamic();
|
|
}
|
|
if (params->getCount() > m_maxParam) {
|
|
if (isVariableArgument()) {
|
|
ret = params->getCount() - m_maxParam;
|
|
} else {
|
|
if (exp->getScope()->isFirstPass()) {
|
|
Compiler::Error(Compiler::TooManyArgument, exp, m_stmt);
|
|
}
|
|
valid = false;
|
|
if (!Option::AllDynamic) setDynamic();
|
|
}
|
|
}
|
|
|
|
bool canSetParamType = isUserFunction() && !m_overriding && !m_perfectVirtual;
|
|
for (int i = 0; i < params->getCount(); i++) {
|
|
ExpressionPtr param = (*params)[i];
|
|
if (i < m_maxParam && param->hasContext(Expression::RefParameter)) {
|
|
/**
|
|
* This should be very un-likely, since call time pass by ref is a
|
|
* deprecated, not very widely used (at least in FB codebase) feature.
|
|
*/
|
|
TRY_LOCK_THIS();
|
|
Symbol *sym = getVariables()->addSymbol(m_paramNames[i]);
|
|
sym->setLvalParam();
|
|
sym->setCallTimeRef();
|
|
}
|
|
if (valid && param->hasContext(Expression::InvokeArgument)) {
|
|
param->clearContext(Expression::InvokeArgument);
|
|
param->clearContext(Expression::RefValue);
|
|
param->clearContext(Expression::NoRefWrapper);
|
|
}
|
|
bool isRefVararg = (i >= m_maxParam && isReferenceVariableArgument());
|
|
if ((i < m_maxParam && isRefParam(i)) || isRefVararg) {
|
|
param->setContext(Expression::LValue);
|
|
param->setContext(Expression::RefValue);
|
|
param->inferAndCheck(ar, Type::Variant, true);
|
|
} else if (!(param->getContext() & Expression::RefParameter)) {
|
|
param->clearContext(Expression::LValue);
|
|
param->clearContext(Expression::RefValue);
|
|
param->clearContext(Expression::InvokeArgument);
|
|
param->clearContext(Expression::NoRefWrapper);
|
|
}
|
|
TypePtr expType;
|
|
/**
|
|
* Duplicate the logic of getParamType(i), w/o the mutation
|
|
*/
|
|
TypePtr paramType(i < m_maxParam ? m_paramTypes[i] : TypePtr());
|
|
if (!paramType) paramType = Type::Some;
|
|
if (valid && !canSetParamType && i < m_maxParam &&
|
|
(!Option::HardTypeHints || !m_paramTypeSpecs[i])) {
|
|
/**
|
|
* What is this magic, you might ask?
|
|
*
|
|
* Here, we take advantage of implicit conversion from every type to
|
|
* Variant. Essentially, we don't really care what type comes out of this
|
|
* expression since it'll just get converted anyways. Doing it this way
|
|
* allows us to generate less temporaries along the way.
|
|
*/
|
|
TypePtr optParamType(
|
|
paramType->is(Type::KindOfVariant) ? Type::Some : paramType);
|
|
expType = param->inferAndCheck(ar, optParamType, false);
|
|
} else {
|
|
expType = param->inferAndCheck(ar, Type::Some, false);
|
|
}
|
|
if (i < m_maxParam) {
|
|
if (!Option::HardTypeHints || !m_paramTypeSpecs[i]) {
|
|
if (canSetParamType) {
|
|
if (!Type::SameType(paramType, expType) &&
|
|
!paramType->is(Type::KindOfVariant)) {
|
|
TRY_LOCK_THIS();
|
|
paramType = setParamType(ar, i, expType);
|
|
} else {
|
|
// do nothing - how is this safe? well, if we ever observe
|
|
// paramType == expType, then this means at some point in the past,
|
|
// somebody called setParamType() with expType. thus, by calling
|
|
// setParamType() again with expType, we contribute no "new"
|
|
// information. this argument also still applies in the face of
|
|
// concurrency
|
|
}
|
|
}
|
|
// See note above. If we have an implemented type, however, we
|
|
// should set the paramType to the implemented type to avoid an
|
|
// un-necessary cast
|
|
if (paramType->is(Type::KindOfVariant)) {
|
|
TypePtr it(param->getImplementedType());
|
|
paramType = it ? it : expType;
|
|
}
|
|
if (valid) {
|
|
if (!Type::IsLegalCast(ar, expType, paramType) &&
|
|
paramType->isNonConvertibleType()) {
|
|
param->inferAndCheck(ar, paramType, true);
|
|
}
|
|
param->setExpectedType(paramType);
|
|
}
|
|
}
|
|
}
|
|
// we do a best-effort check for bad pass-by-reference and do not report
|
|
// error for some vararg case (e.g., array_multisort can have either ref
|
|
// or value for the same vararg).
|
|
if (!isRefVararg || !isMixedVariableArgument()) {
|
|
Expression::CheckPassByReference(ar, param);
|
|
}
|
|
}
|
|
return ret;
|
|
}
|
|
|
|
TypePtr FunctionScope::setParamType(AnalysisResultConstPtr ar, int index,
|
|
TypePtr type) {
|
|
assert(index >= 0 && index < (int)m_paramTypes.size());
|
|
TypePtr paramType = m_paramTypes[index];
|
|
|
|
if (!paramType) paramType = Type::Some;
|
|
type = Type::Coerce(ar, paramType, type);
|
|
if (type && !Type::SameType(paramType, type)) {
|
|
addUpdates(UseKindCallerParam);
|
|
if (!isFirstPass()) {
|
|
Logger::Verbose("Corrected type of parameter %d of %s: %s -> %s",
|
|
index, m_name.c_str(),
|
|
paramType->toString().c_str(), type->toString().c_str());
|
|
}
|
|
}
|
|
m_paramTypes[index] = type;
|
|
return type;
|
|
}
|
|
|
|
TypePtr FunctionScope::getParamType(int index) {
|
|
assert(index >= 0 && index < (int)m_paramTypes.size());
|
|
TypePtr paramType = m_paramTypes[index];
|
|
if (!paramType) {
|
|
paramType = Type::Some;
|
|
m_paramTypes[index] = paramType;
|
|
}
|
|
return paramType;
|
|
}
|
|
|
|
bool FunctionScope::isRefParam(int index) const {
|
|
assert(index >= 0 && index < (int)m_refs.size());
|
|
return m_refs[index];
|
|
}
|
|
|
|
void FunctionScope::setRefParam(int index) {
|
|
assert(index >= 0 && index < (int)m_refs.size());
|
|
m_refs[index] = true;
|
|
}
|
|
|
|
bool FunctionScope::hasRefParam(int max) const {
|
|
assert(max >= 0 && max < (int)m_refs.size());
|
|
for (int i = 0; i < max; i++) {
|
|
if (m_refs[i]) return true;
|
|
}
|
|
return false;
|
|
}
|
|
|
|
const std::string &FunctionScope::getParamName(int index) const {
|
|
assert(index >= 0 && index < (int)m_paramNames.size());
|
|
return m_paramNames[index];
|
|
}
|
|
|
|
void FunctionScope::setParamName(int index, const std::string &name) {
|
|
assert(index >= 0 && index < (int)m_paramNames.size());
|
|
m_paramNames[index] = name;
|
|
}
|
|
|
|
void FunctionScope::setParamDefault(int index, const char* value, int64_t len,
|
|
const std::string &text) {
|
|
assert(index >= 0 && index < (int)m_paramNames.size());
|
|
StringData* sd = new StringData(value, len, AttachLiteral);
|
|
sd->setStatic();
|
|
m_paramDefaults[index] = String(sd);
|
|
m_paramDefaultTexts[index] = text;
|
|
}
|
|
|
|
CStrRef FunctionScope::getParamDefault(int index) {
|
|
return m_paramDefaults[index];
|
|
}
|
|
|
|
void FunctionScope::addModifier(int mod) {
|
|
if (!m_modifiers) {
|
|
m_modifiers =
|
|
ModifierExpressionPtr(new ModifierExpression(
|
|
shared_from_this(), LocationPtr()));
|
|
}
|
|
m_modifiers->add(mod);
|
|
}
|
|
|
|
void FunctionScope::setReturnType(AnalysisResultConstPtr ar, TypePtr type) {
|
|
if (inTypeInference()) {
|
|
getInferTypesMutex().assertOwnedBySelf();
|
|
}
|
|
// no change can be made to virtual function's prototype
|
|
if (m_overriding || m_dynamicInvoke) return;
|
|
|
|
if (!type) {
|
|
m_hasVoid = true;
|
|
if (!m_returnType) return;
|
|
}
|
|
|
|
if (m_hasVoid) {
|
|
type = Type::Variant;
|
|
} else if (m_returnType) {
|
|
type = Type::Coerce(ar, m_returnType, type);
|
|
}
|
|
m_returnType = type;
|
|
assert(m_returnType);
|
|
}
|
|
|
|
void FunctionScope::pushReturnType() {
|
|
getInferTypesMutex().assertOwnedBySelf();
|
|
m_prevReturn = m_returnType;
|
|
m_hasVoid = false;
|
|
if (m_overriding || m_dynamicInvoke || m_perfectVirtual || m_pseudoMain) {
|
|
return;
|
|
}
|
|
m_returnType.reset();
|
|
}
|
|
|
|
bool FunctionScope::popReturnType() {
|
|
getInferTypesMutex().assertOwnedBySelf();
|
|
if (m_overriding || m_dynamicInvoke || m_perfectVirtual || m_pseudoMain) {
|
|
return false;
|
|
}
|
|
|
|
if (m_returnType) {
|
|
if (m_prevReturn) {
|
|
if (Type::SameType(m_returnType, m_prevReturn)) {
|
|
m_prevReturn.reset();
|
|
return false;
|
|
}
|
|
if (!isFirstPass()) {
|
|
Logger::Verbose("Corrected function return type %s -> %s",
|
|
m_prevReturn->toString().c_str(),
|
|
m_returnType->toString().c_str());
|
|
}
|
|
}
|
|
} else if (!m_prevReturn) {
|
|
return false;
|
|
}
|
|
|
|
m_prevReturn.reset();
|
|
addUpdates(UseKindCallerReturn);
|
|
#ifdef HPHP_INSTRUMENT_TYPE_INF
|
|
atomic_inc(RescheduleException::s_NumRetTypesChanged);
|
|
#endif /* HPHP_INSTRUMENT_TYPE_INF */
|
|
return true;
|
|
}
|
|
|
|
void FunctionScope::resetReturnType() {
|
|
getInferTypesMutex().assertOwnedBySelf();
|
|
if (m_overriding || m_dynamicInvoke || m_perfectVirtual || m_pseudoMain) {
|
|
return;
|
|
}
|
|
m_returnType = m_prevReturn;
|
|
m_prevReturn.reset();
|
|
}
|
|
|
|
void FunctionScope::addRetExprToFix(ExpressionPtr e) {
|
|
m_retExprsToFix.push_back(e);
|
|
}
|
|
|
|
void FunctionScope::clearRetExprs() {
|
|
m_retExprsToFix.clear();
|
|
}
|
|
|
|
void FunctionScope::fixRetExprs() {
|
|
for (ExpressionPtrVec::iterator it = m_retExprsToFix.begin(),
|
|
end = m_retExprsToFix.end(); it != end; ++it) {
|
|
(*it)->setExpectedType(m_returnType);
|
|
}
|
|
m_retExprsToFix.clear();
|
|
}
|
|
|
|
void FunctionScope::setOverriding(TypePtr returnType,
|
|
TypePtr param1 /* = TypePtr() */,
|
|
TypePtr param2 /* = TypePtr() */) {
|
|
m_returnType = returnType;
|
|
m_overriding = true;
|
|
|
|
if (param1 && m_paramTypes.size() >= 1) m_paramTypes[0] = param1;
|
|
if (param2 && m_paramTypes.size() >= 2) m_paramTypes[1] = param2;
|
|
|
|
// TODO: remove this block and replace with stronger typing
|
|
// Right now, we have to avoid a situation where a parameter is assigned
|
|
// with different values, making them a Variant.
|
|
for (unsigned int i = 0; i < m_paramTypes.size(); i++) {
|
|
m_paramTypes[i] = Type::Variant;
|
|
}
|
|
}
|
|
|
|
std::string FunctionScope::getId() const {
|
|
string name = CodeGenerator::FormatLabel(getOriginalName());
|
|
if (m_redeclaring < 0) {
|
|
return name;
|
|
}
|
|
return name + Option::IdPrefix +
|
|
boost::lexical_cast<std::string>(m_redeclaring);
|
|
}
|
|
|
|
std::string FunctionScope::getDocName() const {
|
|
string name = getOriginalName();
|
|
if (m_redeclaring < 0) {
|
|
return name;
|
|
}
|
|
return name + Option::IdPrefix +
|
|
boost::lexical_cast<std::string>(m_redeclaring);
|
|
}
|
|
|
|
std::string FunctionScope::getDocFullName() const {
|
|
FunctionScope *self = const_cast<FunctionScope*>(this);
|
|
const string &docName = getDocName();
|
|
if (ClassScopeRawPtr cls = self->getContainingClass()) {
|
|
return cls->getDocName() + string("::") + docName;
|
|
}
|
|
return docName;
|
|
}
|
|
|
|
std::string FunctionScope::getInjectionId() const {
|
|
string injectionName = CodeGenerator::FormatLabel(getOriginalName());
|
|
MethodStatementPtr stmt =
|
|
dynamic_pointer_cast<MethodStatement>(getStmt());
|
|
assert(stmt);
|
|
if (stmt->getGeneratorFunc()) {
|
|
injectionName = isClosureGenerator() ?
|
|
injectionName :
|
|
injectionName + "{continuation}";
|
|
} else if (stmt->getOrigGeneratorFunc() &&
|
|
!getOrigGenFS()->isClosure()) {
|
|
injectionName = CodeGenerator::FormatLabel(
|
|
stmt->getOrigGeneratorFunc()->getOriginalName());
|
|
}
|
|
if (m_redeclaring < 0) {
|
|
return injectionName;
|
|
}
|
|
const string &redecSuffix = string(Option::IdPrefix) +
|
|
boost::lexical_cast<std::string>(m_redeclaring);
|
|
return injectionName + redecSuffix;
|
|
}
|
|
|
|
///////////////////////////////////////////////////////////////////////////////
|
|
|
|
void FunctionScope::outputPHP(CodeGenerator &cg, AnalysisResultPtr ar) {
|
|
if (Option::GenerateInferredTypes && m_returnType) {
|
|
cg_printf("// @return %s\n", m_returnType->toString().c_str());
|
|
}
|
|
|
|
BlockScope::outputPHP(cg, ar);
|
|
}
|
|
|
|
void FunctionScope::outputCPPDef(CodeGenerator &cg) {
|
|
if (isVolatile()) {
|
|
string name = CodeGenerator::FormatLabel(m_name);
|
|
if (isRedeclaring()) {
|
|
cg_printf("extern const %sCallInfo %s%s;\n",
|
|
isRedeclaring() ? "Redeclared" : "",
|
|
Option::CallInfoPrefix, getId().c_str());
|
|
cg_printf("g->GCI(%s) = &%s%s;\n",
|
|
name.c_str(),
|
|
Option::CallInfoPrefix,
|
|
getId().c_str());
|
|
}
|
|
cg_printf("g->FVF(%s) = true;\n", name.c_str());
|
|
}
|
|
}
|
|
|
|
void FunctionScope::outputCPP(CodeGenerator &cg, AnalysisResultPtr ar) {
|
|
ExpressionListPtr params =
|
|
dynamic_pointer_cast<MethodStatement>(getStmt())->getParams();
|
|
|
|
int inTypedWrapper = Option::HardTypeHints ?
|
|
cg.getContext() == CodeGenerator::CppTypedParamsWrapperImpl : -1;
|
|
|
|
string funcName = CodeGenerator::EscapeLabel(getOriginalName());
|
|
if (ClassScopePtr cls = getContainingClass()) {
|
|
funcName = CodeGenerator::EscapeLabel(cls->getOriginalName()) + "::" +
|
|
funcName;
|
|
}
|
|
funcName += "()";
|
|
|
|
/* Typecheck parameters */
|
|
for (int i = 0; i < m_maxParam; i++) {
|
|
if (inTypedWrapper <= 0 && isRefParam(i)) {
|
|
const string &name = getParamName(i);
|
|
string vname = Option::VariablePrefix + CodeGenerator::FormatLabel(name);
|
|
cg_printf("Variant &%s ATTRIBUTE_UNUSED = r%s;\n",
|
|
vname.c_str(), vname.c_str());
|
|
}
|
|
TypePtr specType = m_paramTypeSpecs[i];
|
|
if (!specType) continue;
|
|
|
|
ParameterExpressionPtr param =
|
|
dynamic_pointer_cast<ParameterExpression>((*params)[i]);
|
|
|
|
ConstantExpressionPtr constPtr;
|
|
bool isDefaultNull =
|
|
param->defaultValue() &&
|
|
(constPtr = dynamic_pointer_cast<ConstantExpression>(
|
|
param->defaultValue())) &&
|
|
constPtr->isNull();
|
|
TypePtr infType = m_paramTypes[i];
|
|
|
|
if (inTypedWrapper >= 0) {
|
|
bool typed = !isRefParam(i) &&
|
|
(Type::SameType(specType, infType) ||
|
|
(infType && infType->isStandardObject() && isDefaultNull));
|
|
// if the infType is a standard object +
|
|
// we have a default null parameter, then we need to
|
|
// do some special runtime checks
|
|
if (!typed == inTypedWrapper) continue;
|
|
}
|
|
|
|
/* Insert runtime checks. */
|
|
if (infType && infType->isStandardObject() && isDefaultNull) {
|
|
cg_indentBegin("if(!%s%s.isNull() && !%s%s.isObject()) {\n",
|
|
Option::VariablePrefix, param->getName().c_str(),
|
|
Option::VariablePrefix, param->getName().c_str());
|
|
cg_printf("throw_unexpected_argument_type(%d,\"%s\",\"%s\",%s%s);\n",
|
|
i + 1, funcName.c_str(), specType->getName().c_str(),
|
|
Option::VariablePrefix, param->getName().c_str());
|
|
if (Option::HardTypeHints) {
|
|
cg_printf("return%s;\n", getReturnType() ? " null" : "");
|
|
}
|
|
cg_indentEnd("}\n");
|
|
} else if (specType->is(Type::KindOfObject)) {
|
|
cg_printf("if(");
|
|
if (!m_paramDefaults[i].empty()) {
|
|
cg_printf("!f_is_null(%s%s) && ",
|
|
Option::VariablePrefix, param->getName().c_str());
|
|
}
|
|
cg_printf("!%s%s.instanceof(", Option::VariablePrefix,
|
|
param->getName().c_str());
|
|
cg_printString(specType->getName(), ar, shared_from_this());
|
|
cg_indentBegin(")) {\n");
|
|
cg_printf("throw_unexpected_argument_type(%d,\"%s\",\"%s\",%s%s);\n",
|
|
i + 1, funcName.c_str(), specType->getName().c_str(),
|
|
Option::VariablePrefix, param->getName().c_str());
|
|
if (Option::HardTypeHints) {
|
|
cg_printf("return%s;\n", getReturnType() ? " null" : "");
|
|
}
|
|
cg_indentEnd("}\n");
|
|
} else {
|
|
cg_printf("if(");
|
|
if (!m_paramDefaults[i].empty() &&
|
|
(isRefParam(i) || isDefaultNull)) {
|
|
cg_printf("!f_is_null(%s%s) && ",
|
|
Option::VariablePrefix, param->getName().c_str());
|
|
}
|
|
const char *p = 0;
|
|
switch (specType->getKindOf()) {
|
|
case Type::KindOfArray: p = "Array"; break;
|
|
case Type::KindOfBoolean: p = "Boolean"; break;
|
|
case Type::KindOfInt64: p = "Integer"; break;
|
|
case Type::KindOfDouble: p = "Double"; break;
|
|
case Type::KindOfString: p = "String"; break;
|
|
default: not_reached();
|
|
}
|
|
cg_indentBegin("!%s%s.is%s()) {\n",
|
|
Option::VariablePrefix, param->getName().c_str(), p);
|
|
cg_printf("throw_unexpected_argument_type"
|
|
"(%d,\"%s\",\"%s\",%s%s);\n",
|
|
i + 1, funcName.c_str(), p,
|
|
Option::VariablePrefix, param->getName().c_str());
|
|
if (Option::HardTypeHints) {
|
|
cg_printf("return%s;\n", getReturnType() ? " null" : "");
|
|
}
|
|
cg_indentEnd("}\n");
|
|
}
|
|
}
|
|
|
|
if (inTypedWrapper <= 0) {
|
|
BlockScope::outputCPP(cg, ar);
|
|
|
|
if (isVariableArgument()) {
|
|
VariableTablePtr variables = getVariables();
|
|
for (int i = 0; i < m_maxParam; i++) {
|
|
const string &name = getParamName(i);
|
|
Symbol *sym = variables->getSymbol(name);
|
|
bool ref = isRefParam(i);
|
|
if (ref ? sym->isReseated() : sym->isLvalParam()) {
|
|
sym->setStashedVal();
|
|
TypePtr paramType = getParamType(i);
|
|
paramType->outputCPPDecl(cg, ar, shared_from_this());
|
|
string vname = Option::VariablePrefix +
|
|
CodeGenerator::FormatLabel(name);
|
|
if (!ref || paramType->isExactType()) {
|
|
cg_printf(" v%s = %s;\n", vname.c_str(), vname.c_str());
|
|
} else {
|
|
cg_printf(" v%s = strongBind(%s);\n",
|
|
vname.c_str(), vname.c_str());
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
ParameterExpressionPtrVec useVars;
|
|
if (needsAnonClosureClass(useVars)) {
|
|
if (!m_closureGenerator) {
|
|
VariableTablePtr variables = getVariables();
|
|
BOOST_FOREACH(ParameterExpressionPtr param, useVars) {
|
|
const string &name = param->getName();
|
|
Symbol *sym = variables->getSymbol(name);
|
|
assert(sym->isUsed());
|
|
TypePtr t(sym->getFinalType());
|
|
assert(!param->isRef() || t->is(Type::KindOfVariant));
|
|
if (t->is(Type::KindOfVariant)) {
|
|
const char *s = param->isRef() ? "Ref" : "Val";
|
|
cg_printf("%s%s.assign%s(closure->%s%s);\n",
|
|
Option::VariablePrefix, name.c_str(), s,
|
|
Option::VariablePrefix, name.c_str());
|
|
} else {
|
|
cg_printf("%s%s = closure->%s%s;\n",
|
|
Option::VariablePrefix, name.c_str(),
|
|
Option::VariablePrefix, name.c_str());
|
|
}
|
|
}
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
void FunctionScope::outputCPPParamsDecl(CodeGenerator &cg,
|
|
AnalysisResultPtr ar,
|
|
ExpressionListPtr params,
|
|
bool showDefault) {
|
|
if (isVariableArgument()) {
|
|
if (m_name[0] == '0' && !m_method) {
|
|
cg_printf("void *extra, ");
|
|
}
|
|
cg_printf("int num_args, ");
|
|
if (params) {
|
|
cg.setInExpression(true);
|
|
params->outputCPP(cg, ar);
|
|
cg.setInExpression(false);
|
|
cg_printf(", ");
|
|
}
|
|
if (showDefault) {
|
|
cg_printf("Array args = Array()");
|
|
} else {
|
|
cg_printf("Array args /* = Array() */");
|
|
}
|
|
} else if (m_pseudoMain) {
|
|
cg_printf("bool incOnce, LVariableTable* variables, Globals *globals");
|
|
} else if (params) {
|
|
if (m_name[0] == '0' && !m_method) {
|
|
cg_printf("void *extra, ");
|
|
}
|
|
cg.setInExpression(true);
|
|
params->outputCPP(cg, ar);
|
|
cg.setInExpression(false);
|
|
} else if (m_name[0] == '0' && !m_method) {
|
|
cg_printf("void *extra");
|
|
}
|
|
}
|
|
|
|
|
|
void FunctionScope::outputCPPParamsImpl(CodeGenerator &cg,
|
|
AnalysisResultPtr ar) {
|
|
int paramcount = getMaxParamCount();
|
|
if (isUserFunction()) {
|
|
MethodStatementPtr m = dynamic_pointer_cast<MethodStatement>(getStmt());
|
|
outputCPPParamsDecl(cg, ar, m->getParams(), false);
|
|
return;
|
|
}
|
|
bool first = true;
|
|
if (isVariableArgument()) {
|
|
cg_printf("int num_args");
|
|
first = false;
|
|
}
|
|
|
|
for (int i = 0; i < paramcount; i++) {
|
|
if (first) {
|
|
first = false;
|
|
} else {
|
|
cg_printf(", ");
|
|
}
|
|
if (isRefParam(i)) {
|
|
cg_printf("VRefParam");
|
|
} else {
|
|
TypePtr type = getParamType(i);
|
|
type->outputCPPDecl(cg, ar, BlockScopeRawPtr(this));
|
|
}
|
|
cg_printf(" a%d", i);
|
|
}
|
|
|
|
if (isVariableArgument()) {
|
|
cg_printf(", Array args /* = Array() */");
|
|
}
|
|
}
|
|
|
|
bool FunctionScope::outputCPPArrayCreate(CodeGenerator &cg,
|
|
AnalysisResultPtr ar,
|
|
int m_maxParam) {
|
|
assert(m_maxParam >= 0);
|
|
assert(m_attribute & FileScope::VariableArgument);
|
|
if (!Option::GenArrayCreate ||
|
|
cg.getOutput() == CodeGenerator::SystemCPP ||
|
|
m_maxParam == 0) {
|
|
return false;
|
|
}
|
|
if (isUserFunction()) {
|
|
MethodStatementPtr stmt;
|
|
stmt = dynamic_pointer_cast<MethodStatement>(m_stmt);
|
|
if (stmt->hasRefParam()) return false;
|
|
cg_printf("Array(");
|
|
stmt->outputParamArrayCreate(cg, false);
|
|
} else if (hasRefParam(m_maxParam)) {
|
|
assert(false);
|
|
return false;
|
|
} else {
|
|
assert(false);
|
|
cg_printf("Array(");
|
|
for (int i = 0; i < m_maxParam; i++) {
|
|
cg_printf("%d, a%d", i, i);
|
|
if (i < m_maxParam - 1) {
|
|
cg_printf(", ");
|
|
} else {
|
|
cg_printf(")");
|
|
}
|
|
}
|
|
}
|
|
cg_printf(")");
|
|
cg_printf(isVariableArgument() ? ",args" : ",Array()");
|
|
return true;
|
|
}
|
|
|
|
void FunctionScope::outputCPPParamsCall(CodeGenerator &cg,
|
|
AnalysisResultPtr ar,
|
|
bool aggregateParams) {
|
|
if (isVariableArgument()) {
|
|
cg_printf("num_args, ");
|
|
} else if (aggregateParams) {
|
|
cg_printf("%d, ", m_maxParam);
|
|
}
|
|
if (aggregateParams && outputCPPArrayCreate(cg, ar, m_maxParam)) {
|
|
return;
|
|
}
|
|
bool userFunc = isUserFunction();
|
|
CodeGenerator::Context context = cg.getContext();
|
|
bool isWrapper = !aggregateParams &&
|
|
(context == CodeGenerator::CppTypedParamsWrapperImpl ||
|
|
context == CodeGenerator::CppTypedParamsWrapperDecl ||
|
|
context == CodeGenerator::CppFunctionWrapperImpl ||
|
|
context == CodeGenerator::CppFunctionWrapperDecl);
|
|
|
|
MethodStatementPtr stmt;
|
|
ExpressionListPtr params;
|
|
if (userFunc) {
|
|
stmt = dynamic_pointer_cast<MethodStatement>(m_stmt);
|
|
params = stmt->getParams();
|
|
}
|
|
|
|
VariableTablePtr variables = getVariables();
|
|
if (aggregateParams) {
|
|
cg_printf("Array(");
|
|
if (m_maxParam) {
|
|
// param arrays are always vectors
|
|
cg_printf("ArrayInit(%d, ArrayInit::vectorInit).", m_maxParam);
|
|
}
|
|
}
|
|
for (int i = 0; i < m_maxParam; i++) {
|
|
if (i > 0) cg_printf(aggregateParams ? "." : ", ");
|
|
bool isRef;
|
|
if (userFunc) {
|
|
ParameterExpressionPtr param =
|
|
dynamic_pointer_cast<ParameterExpression>((*params)[i]);
|
|
isRef = !isWrapper && param->isRef();
|
|
if (aggregateParams) {
|
|
cg_printf("set(%s%s%s",
|
|
variables->getSymbol(param->getName())->isStashedVal() ?
|
|
"v" : "",
|
|
Option::VariablePrefix, param->getName().c_str());
|
|
} else {
|
|
cg_printf("%s%s%s%s",
|
|
isRef ? "ref(" : "",
|
|
Option::VariablePrefix, param->getName().c_str(),
|
|
isRef ? ")" : "");
|
|
}
|
|
} else {
|
|
isRef = !isWrapper && isRefParam(i);
|
|
if (aggregateParams) {
|
|
assert(false);
|
|
cg_printf("set(a%d", i);
|
|
} else {
|
|
cg_printf("%sa%d%s",
|
|
isRef ? "ref(" : "", i, isRef ? ")" : "");
|
|
}
|
|
}
|
|
if (aggregateParams) cg_printf(")");
|
|
}
|
|
if (aggregateParams) {
|
|
if (m_maxParam) cg_printf(".create()");
|
|
cg_printf(")");
|
|
}
|
|
if (isVariableArgument()) {
|
|
if (aggregateParams || m_maxParam > 0) cg_printf(",");
|
|
cg_printf("args");
|
|
} else if (aggregateParams) {
|
|
cg_printf(", Array()");
|
|
}
|
|
}
|
|
|
|
void FunctionScope::OutputCPPArguments(ExpressionListPtr params,
|
|
FunctionScopePtr func,
|
|
CodeGenerator &cg,
|
|
AnalysisResultPtr ar, int extraArg,
|
|
bool variableArgument,
|
|
int extraArgArrayId /* = -1 */,
|
|
int extraArgArrayHash /* = -1 */,
|
|
int extraArgArrayIndex /* = -1 */,
|
|
bool ignoreFuncParamTypes /* = false */)
|
|
{
|
|
int paramCount = params ? params->getOutputCount() : 0;
|
|
assert(extraArg <= paramCount);
|
|
int iMax = paramCount - extraArg;
|
|
bool extra = false;
|
|
bool callUserFuncFewArgs = false;
|
|
|
|
if (variableArgument) {
|
|
callUserFuncFewArgs =
|
|
Option::UseCallUserFuncFewArgs &&
|
|
func->getName() == "call_user_func" &&
|
|
(paramCount <= CALL_USER_FUNC_FEW_ARGS_COUNT + 1) &&
|
|
extraArgArrayId == -1;
|
|
|
|
if (!callUserFuncFewArgs) {
|
|
if (paramCount == 0) {
|
|
cg_printf("0");
|
|
} else {
|
|
cg_printf("%d, ", paramCount);
|
|
}
|
|
}
|
|
}
|
|
for (int i = 0; i < paramCount; i++) {
|
|
ExpressionPtr param = (*params)[i];
|
|
if (i > 0) cg_printf(extra && !callUserFuncFewArgs ? "." : ", ");
|
|
if (!extra && (i == iMax || extraArg < 0)) {
|
|
if (extraArgArrayId != -1) {
|
|
always_assert(extraArgArrayHash != -1 && extraArgArrayIndex != -1);
|
|
ar->outputCPPScalarArrayId(cg, extraArgArrayId, extraArgArrayHash,
|
|
extraArgArrayIndex);
|
|
break;
|
|
}
|
|
extra = true;
|
|
if (!callUserFuncFewArgs) {
|
|
// Parameter arrays are always vectors.
|
|
if (Option::GenArrayCreate &&
|
|
cg.getOutput() != CodeGenerator::SystemCPP) {
|
|
if (!params->hasNonArrayCreateValue(false, i)) {
|
|
always_assert(!callUserFuncFewArgs);
|
|
if (ar->m_arrayIntegerKeyMaxSize < paramCount - i) {
|
|
ar->m_arrayIntegerKeyMaxSize = paramCount - i;
|
|
}
|
|
cg_printf("Array(");
|
|
params->outputCPPUniqLitKeyArrayInit(cg, ar, false,
|
|
paramCount - i, false, i);
|
|
cg_printf(")");
|
|
return;
|
|
}
|
|
}
|
|
cg_printf("Array(ArrayInit(%d, ArrayInit::vectorInit).",
|
|
paramCount - i);
|
|
}
|
|
}
|
|
if (extra) {
|
|
bool needRef = param->hasContext(Expression::RefValue) &&
|
|
!param->hasContext(Expression::NoRefWrapper) &&
|
|
param->isRefable();
|
|
if (!callUserFuncFewArgs) {
|
|
cg_printf("set%s(", needRef ? "Ref" : "");
|
|
}
|
|
if (needRef) {
|
|
// The parameter itself shouldn't be wrapped with ref() any more.
|
|
param->setContext(Expression::NoRefWrapper);
|
|
}
|
|
param->outputCPP(cg, ar);
|
|
if (!callUserFuncFewArgs) cg_printf(")");
|
|
} else {
|
|
// If the implemented type is ref-counted and expected type is variant,
|
|
// use VarNR to avoid unnecessary ref-counting because we know
|
|
// the actual argument will always has a ref in the callee.
|
|
bool wrap = false, wrapv = false;
|
|
bool scalar = param->isScalar();
|
|
bool isValidFuncIdx = func && i < func->getMaxParamCount();
|
|
TypePtr expType(
|
|
isValidFuncIdx && !ignoreFuncParamTypes ?
|
|
// the common case, where we read the param type from the function
|
|
// scope
|
|
func->getParamType(i) :
|
|
|
|
// the uncommon case
|
|
!func && !ignoreFuncParamTypes ?
|
|
|
|
// if we don't have a function, then we can assume its param type
|
|
// is Variant. however, we only want to do this if we aren't
|
|
// ignoring function param types
|
|
Type::Variant :
|
|
|
|
// in this case, just use the expected type from the parameter
|
|
// ast node (that's the default behavior of CheckVarNR)
|
|
TypePtr());
|
|
if (Expression::CheckVarNR(param, expType)) {
|
|
if (scalar) {
|
|
assert(!cg.hasScalarVariant());
|
|
cg.setScalarVariant();
|
|
}
|
|
if (!scalar ||
|
|
(!Option::UseScalarVariant && !param->isLiteralNull())) {
|
|
wrap = true;
|
|
}
|
|
if (isValidFuncIdx) {
|
|
VariableTablePtr variables = func->getVariables();
|
|
if (variables->isLvalParam(func->getParamName(i))) {
|
|
// Callee expects a Variant instead of CVarRef
|
|
wrap = false;
|
|
if (scalar) cg.clearScalarVariant();
|
|
}
|
|
}
|
|
} else if (isValidFuncIdx &&
|
|
!param->hasCPPTemp() &&
|
|
func->getVariables()->isLvalParam(func->getParamName(i)) &&
|
|
!param->hasAnyContext(Expression::RefValue|
|
|
Expression::RefParameter|
|
|
Expression::InvokeArgument)) {
|
|
FunctionCallPtr f = dynamic_pointer_cast<FunctionCall>(param);
|
|
if (f) {
|
|
if (f->getFuncScope()) {
|
|
wrapv = f->getFuncScope()->isRefReturn();
|
|
} else if (!f->getName().empty()) {
|
|
FunctionInfoPtr info = GetFunctionInfo(f->getName());
|
|
wrapv = info && info->getMaybeRefReturn();
|
|
} else {
|
|
wrapv = true;
|
|
}
|
|
if (wrapv) cg_printf("wrap_variant(");
|
|
}
|
|
}
|
|
if (wrap) cg_printf("VarNR(");
|
|
param->outputCPP(cg, ar);
|
|
if (scalar) cg.clearScalarVariant();
|
|
assert(!cg.hasScalarVariant());
|
|
if (wrap || wrapv) {
|
|
cg_printf(")");
|
|
}
|
|
}
|
|
}
|
|
if (extra) {
|
|
if (!callUserFuncFewArgs) cg_printf(".create())");
|
|
}
|
|
}
|
|
|
|
void FunctionScope::OutputCPPEffectiveArguments(ExpressionListPtr params,
|
|
CodeGenerator &cg,
|
|
AnalysisResultPtr ar) {
|
|
int paramCount = params ? params->getCount() : 0;
|
|
for (int i = 0; i < paramCount; i++) {
|
|
ExpressionPtr param = (*params)[i];
|
|
if (param->hasEffect()) {
|
|
param->outputCPP(cg, ar);
|
|
cg_printf(", ");
|
|
}
|
|
}
|
|
}
|
|
|
|
void FunctionScope::OutputCPPDynamicInvokeCount(CodeGenerator &cg) {
|
|
cg_printf("int count ATTRIBUTE_UNUSED = params.size();\n");
|
|
}
|
|
|
|
int FunctionScope::outputCPPInvokeArgCountCheck(
|
|
CodeGenerator &cg, AnalysisResultPtr ar,
|
|
bool ret, bool constructor, int maxCount) {
|
|
bool variable = isVariableArgument();
|
|
// system function has different handling of argument counts
|
|
bool system = (m_system || m_sep ||
|
|
cg.getOutput() == CodeGenerator::SystemCPP);
|
|
if (!system) {
|
|
ClassScopePtr scope = getContainingClass();
|
|
if (scope) system = (!scope->isUserClass() || scope->isExtensionClass() ||
|
|
scope->isSepExtension());
|
|
}
|
|
|
|
bool checkMissing = (m_minParam > 0);
|
|
bool checkTooMany = (!variable && (system ||
|
|
RuntimeOption::ThrowTooManyArguments));
|
|
const char *sysret = (system && ret) ? "return " : "";
|
|
const char *level = (system ? (constructor ? ", 2" : ", 1") : "");
|
|
int guarded = system && (ret || constructor) ? m_minParam : 0;
|
|
string fullname = CodeGenerator::EscapeLabel(getOriginalFullName());
|
|
if (checkMissing) {
|
|
bool fullGuard = ret && (system || Option::HardTypeHints);
|
|
for (int i = 0; i < m_minParam; i++) {
|
|
if (TypePtr t = m_paramTypeSpecs[i]) {
|
|
if (m_paramDefaults[i].empty()) {
|
|
if (i < maxCount) cg_printf("if (UNLIKELY(count < %d)) ", i + 1);
|
|
cg_printf("%sthrow_missing_typed_argument(\"%s\", ",
|
|
fullGuard ? "return " : "", fullname.c_str());
|
|
cg_printf(t->is(Type::KindOfArray) ?
|
|
"0" : "\"%s\"",
|
|
CodeGenerator::EscapeLabel(t->getName()).c_str());
|
|
cg_printf(", %d);\n", i + 1);
|
|
if (fullGuard) {
|
|
if (i >= maxCount) return m_minParam;
|
|
if (guarded <= i) guarded = i + 1;
|
|
if (i + 1 == m_minParam) {
|
|
checkMissing = false;
|
|
}
|
|
}
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
if (checkMissing && checkTooMany) {
|
|
if (!variable && m_minParam == m_maxParam) {
|
|
if (maxCount >= m_minParam) {
|
|
cg_printf("if (UNLIKELY(count != %d))", m_minParam);
|
|
}
|
|
cg_printf(" %sthrow_wrong_arguments(\"%s\", count, %d, %d%s);\n",
|
|
sysret, fullname.c_str(), m_minParam, m_maxParam, level);
|
|
} else {
|
|
if (maxCount >= m_minParam) {
|
|
if (maxCount <= m_maxParam) {
|
|
cg_printf("if (UNLIKELY(count < %d))", m_minParam);
|
|
} else {
|
|
cg_printf("if (UNLIKELY(count < %d || count > %d))",
|
|
m_minParam, m_maxParam);
|
|
}
|
|
}
|
|
cg_printf(" %sthrow_wrong_arguments(\"%s\", count, %d, %d%s);\n",
|
|
sysret, fullname.c_str(),
|
|
m_minParam, variable ? -1 : m_maxParam, level);
|
|
}
|
|
} else if (checkMissing) {
|
|
if (maxCount >= m_minParam) {
|
|
cg_printf("if (UNLIKELY(count < %d))", m_minParam);
|
|
}
|
|
cg_printf(" %sthrow_missing_arguments(\"%s\", count+1%s);\n",
|
|
sysret, fullname.c_str(), level);
|
|
} else if (checkTooMany && maxCount > m_maxParam) {
|
|
cg_printf("if (UNLIKELY(count > %d))"
|
|
" %sthrow_toomany_arguments(\"%s\", %d%s);\n",
|
|
m_maxParam, sysret, fullname.c_str(), m_maxParam, level);
|
|
}
|
|
return guarded;
|
|
}
|
|
|
|
void FunctionScope::outputCPPDynamicInvoke(CodeGenerator &cg,
|
|
AnalysisResultPtr ar,
|
|
const char *funcPrefix,
|
|
const char *name,
|
|
bool voidWrapperOff /* = false */,
|
|
bool fewArgs /* = false */,
|
|
bool ret /* = true */,
|
|
const char *extraArg /* = NULL */,
|
|
bool constructor /* = false */,
|
|
const char *instance /* = NULL */,
|
|
const char *class_name /* = "" */) {
|
|
const char *voidWrapper = (m_returnType || voidWrapperOff) ? "" : ", null";
|
|
const char *retrn = ret ? "return " : "";
|
|
bool variable = isVariableArgument();
|
|
bool refVariable = isReferenceVariableArgument();
|
|
int maxCount = fewArgs ? Option::InvokeFewArgsCount : INT_MAX;
|
|
bool useDefaults = !m_stmt || ar->isSystem();
|
|
|
|
assert(m_minParam >= 0);
|
|
|
|
int guarded = outputCPPInvokeArgCountCheck(cg, ar, ret,
|
|
constructor, maxCount);
|
|
if (guarded > maxCount) return;
|
|
|
|
bool do_while = !ret && !fewArgs && m_maxParam > m_minParam && useDefaults;
|
|
cg_printf("%s", class_name);
|
|
if (!fewArgs && m_maxParam) {
|
|
for (int i = 0; i < m_maxParam; i++) {
|
|
if (isRefParam(i)) {
|
|
cg_printf("const_cast<Array&>(params).escalate(true);\n");
|
|
break;
|
|
}
|
|
}
|
|
if (do_while) cg_printf("do ");
|
|
cg_indentBegin("{\n");
|
|
cg_printf("ArrayData *ad(params.get());\n");
|
|
cg_printf("ssize_t pos = ad ? ad->iter_begin() : "
|
|
"ArrayData::invalid_index;\n");
|
|
}
|
|
|
|
CodeGenerator::Context context = cg.getContext();
|
|
std::vector<Variant> defs;
|
|
|
|
int i = !m_minParam ? -1 : 0;
|
|
while (true) {
|
|
if (i >= 0 && i < m_maxParam) {
|
|
bool ref = isRefParam(i);
|
|
int defIndex = -1;
|
|
bool wantNullVariantNotNull = fewArgs ? i < maxCount : ref;
|
|
bool dftNull = false;
|
|
bool isCVarRef = false;
|
|
if (!m_paramDefaults[i].empty() && !useDefaults) {
|
|
Variant tmp;
|
|
MethodStatementPtr m(dynamic_pointer_cast<MethodStatement>(m_stmt));
|
|
ExpressionListPtr params = m->getParams();
|
|
always_assert(params && params->getCount() > i);
|
|
ParameterExpressionPtr p(
|
|
dynamic_pointer_cast<ParameterExpression>((*params)[i]));
|
|
ExpressionPtr defVal = p->defaultValue();
|
|
bool isScalar = defVal->isScalar();
|
|
if (Option::UseScalarVariant && isScalar && !ref && fewArgs) isCVarRef = true;
|
|
dftNull = isScalar && defVal->getScalarValue(tmp) && tmp.isNull();
|
|
if (!isCVarRef && wantNullVariantNotNull && !dftNull && !ref) {
|
|
cg_printf("TypedValue def%d;\n", i);
|
|
defIndex = i;
|
|
}
|
|
}
|
|
cg_printf("%s arg%d(", ref ? "VRefParam" : "CVarRef", i);
|
|
if (m_paramDefaults[i].empty()) {
|
|
if (i >= guarded) {
|
|
if (i < maxCount) cg_printf("UNLIKELY(count <= %d) ? ", i);
|
|
cg_printf(ref ? "(VRefParamValue())" :
|
|
(wantNullVariantNotNull ? "null_variant" : "null"));
|
|
if (i < maxCount) cg_printf(" : ");
|
|
}
|
|
} else if (!useDefaults) {
|
|
bool close = false;
|
|
if (i < maxCount) {
|
|
cg_printf("count <= %d ? ", i);
|
|
} else if (defIndex < 0) {
|
|
cg_printf("(");
|
|
close = true;
|
|
}
|
|
if (dftNull) {
|
|
cg_printf(ref ? "(VRefParamValue())" :
|
|
(wantNullVariantNotNull ? "null_variant" : "null"));
|
|
} else {
|
|
MethodStatementPtr m(dynamic_pointer_cast<MethodStatement>(m_stmt));
|
|
ExpressionListPtr params = m->getParams();
|
|
always_assert(params && params->getCount() > i);
|
|
ParameterExpressionPtr p(
|
|
dynamic_pointer_cast<ParameterExpression>((*params)[i]));
|
|
|
|
if (defIndex >= 0) {
|
|
if (!isCVarRef) cg_printf("*new (&def%d) Variant(", defIndex);
|
|
} else {
|
|
ExpressionPtr defVal = p->defaultValue();
|
|
bool isScalar = defVal->isScalar();
|
|
if (Option::UseScalarVariant && isScalar && !ref && fewArgs) isCVarRef = true;
|
|
TypePtr type = p->defaultValue()->getCPPType();
|
|
bool isVariant = type && Type::IsMappedToVariant(type);
|
|
cg_printf("%s(", ref ? "VRefParamValue" :
|
|
(!fewArgs || i >= maxCount) && !isVariant && !isCVarRef ?
|
|
"Variant" : "");
|
|
}
|
|
cg.setContext(CodeGenerator::CppParameterDefaultValueDecl);
|
|
ExpressionPtr defVal = p->defaultValue();
|
|
if (isCVarRef) {
|
|
assert(!cg.hasScalarVariant());
|
|
cg.setScalarVariant();
|
|
}
|
|
|
|
TypePtr exp = defVal->getExpectedType();
|
|
defVal->setExpectedType(TypePtr());
|
|
defVal->outputCPP(cg, ar);
|
|
defVal->setExpectedType(exp);
|
|
|
|
if (isCVarRef) cg.clearScalarVariant();
|
|
assert(!cg.hasScalarVariant());
|
|
cg.setContext(context);
|
|
cg_printf(")");
|
|
}
|
|
if (close) cg_printf(")");
|
|
if (i < maxCount) cg_printf(" : ");
|
|
}
|
|
if (fewArgs) {
|
|
if (i < maxCount) cg_printf(ref ? "vref(a%d)" : "a%d", i);
|
|
} else {
|
|
cg_printf("%s(ad->getValue%s(pos%s))",
|
|
ref ? "vref" : "",
|
|
ref ? "Ref" : "",
|
|
i ? " = ad->iter_advance(pos)" : "");
|
|
}
|
|
cg_printf(");\n");
|
|
}
|
|
if (++i < m_minParam) continue;
|
|
const char *extra = "";
|
|
bool last = i >= maxCount || i == m_maxParam;
|
|
if (!useDefaults && !last) continue;
|
|
|
|
if (variable && last) {
|
|
if (fewArgs) {
|
|
if (i < Option::InvokeFewArgsCount) {
|
|
cg_printf("Array p;\n");
|
|
for (int j = i; j < Option::InvokeFewArgsCount; j++) {
|
|
if (refVariable) {
|
|
cg_printf("if (count >= %d) p.append(ref(a%d));\n", j + 1, j);
|
|
} else {
|
|
cg_printf("if (count >= %d) p.append(a%d);\n", j + 1, j);
|
|
}
|
|
}
|
|
extra = ", p";
|
|
}
|
|
} else {
|
|
if (m_maxParam) {
|
|
cg_printf("const Array &p(count > %d ? "
|
|
"params.slice(%d, count - %d, false) : Array());\n",
|
|
m_maxParam, m_maxParam, m_maxParam);
|
|
} else {
|
|
// in this case, avoid the un-necessary call to params.slice(),
|
|
// since we want the entire params array anyways
|
|
assert(m_maxParam == 0);
|
|
cg_printf("const Array &p(count > 0 ? "
|
|
"ArrayUtil::EnsureIntKeys(params) : Array());\n");
|
|
}
|
|
extra = ", p";
|
|
}
|
|
}
|
|
|
|
if (!last) {
|
|
cg_printf("if (count <= %d) ", i);
|
|
if (do_while) {
|
|
cg_indentBegin("{\n");
|
|
}
|
|
}
|
|
cg_printf("%s%s%s", retrn, (m_refReturn ? "strongBind(" : "("),
|
|
instance ? instance : "");
|
|
if (m_perfectVirtual) {
|
|
ClassScopePtr cls = getContainingClass();
|
|
cg_printf("%s%s::", Option::ClassPrefix, cls->getId().c_str());
|
|
}
|
|
cg_printf("%s%s(", funcPrefix, name);
|
|
|
|
bool preArgs = false;
|
|
if (name[0] == '0' && !m_method) {
|
|
cg_printf("extra"); // closure
|
|
preArgs = true;
|
|
}
|
|
if (extraArg) {
|
|
if (preArgs) cg_printf(", ");
|
|
cg_printf("%s", extraArg);
|
|
preArgs = true;
|
|
}
|
|
if (variable) {
|
|
if (preArgs) cg_printf(", ");
|
|
cg_printf("count");
|
|
preArgs = true;
|
|
}
|
|
for (int j = 0; j < i; j++) {
|
|
if (j >= m_minParam && j >= maxCount) break;
|
|
if (preArgs || j > 0) cg_printf(", ");
|
|
cg_printf("arg%d", j);
|
|
}
|
|
cg_printf("%s)%s);\n", extra, voidWrapper);
|
|
if (last) break;
|
|
if (do_while) {
|
|
cg_printf("break;\n");
|
|
cg_indentEnd("}\n");
|
|
}
|
|
}
|
|
|
|
if (!fewArgs && m_maxParam) {
|
|
if (do_while) {
|
|
cg_indentEnd("} while (false);\n");
|
|
} else {
|
|
cg_indentEnd("}\n");
|
|
}
|
|
}
|
|
}
|
|
|
|
void FunctionScope::serialize(JSON::CodeError::OutputStream &out) const {
|
|
JSON::CodeError::MapStream ms(out);
|
|
int vis = 0;
|
|
if (isPublic()) vis = ClassScope::Public;
|
|
else if (isProtected()) vis = ClassScope::Protected;
|
|
else if (isPrivate()) vis = ClassScope::Protected;
|
|
|
|
int mod = 0;
|
|
if (isAbstract()) mod = ClassScope::Abstract;
|
|
else if (isFinal()) mod = ClassScope::Final;
|
|
|
|
if (!m_returnType) {
|
|
ms.add("retTp", -1);
|
|
} else if (m_returnType->isSpecificObject()) {
|
|
ms.add("retTp", m_returnType->getName());
|
|
} else {
|
|
ms.add("retTp", m_returnType->getKindOf());
|
|
}
|
|
ms.add("minArgs", m_minParam)
|
|
.add("maxArgs", m_maxParam)
|
|
.add("varArgs", isVariableArgument())
|
|
.add("static", isStatic())
|
|
.add("modifier", mod)
|
|
.add("visibility", vis)
|
|
.add("argIsRef", m_refs)
|
|
.done();
|
|
}
|
|
|
|
void FunctionScope::serialize(JSON::DocTarget::OutputStream &out) const {
|
|
JSON::DocTarget::MapStream ms(out);
|
|
|
|
ms.add("name", getDocName());
|
|
ms.add("line", getStmt() ? getStmt()->getLocation()->line0 : 0);
|
|
ms.add("docs", m_docComment);
|
|
|
|
int mods = 0;
|
|
if (isPublic()) mods |= ClassInfo::IsPublic;
|
|
if (isProtected()) mods |= ClassInfo::IsProtected;
|
|
if (isPrivate()) mods |= ClassInfo::IsPrivate;
|
|
if (isStatic()) mods |= ClassInfo::IsStatic;
|
|
if (isFinal()) mods |= ClassInfo::IsFinal;
|
|
if (isAbstract()) mods |= ClassInfo::IsAbstract;
|
|
ms.add("modifiers", mods);
|
|
|
|
ms.add("refreturn", isRefReturn());
|
|
ms.add("return", getReturnType());
|
|
|
|
vector<SymParamWrapper> paramSymbols;
|
|
for (int i = 0; i < m_maxParam; i++) {
|
|
const string &name = getParamName(i);
|
|
const Symbol *sym = getVariables()->getSymbol(name);
|
|
assert(sym && sym->isParameter());
|
|
paramSymbols.push_back(SymParamWrapper(sym));
|
|
}
|
|
ms.add("parameters", paramSymbols);
|
|
|
|
// scopes that call this scope (callers)
|
|
vector<string> callers;
|
|
const BlockScopeRawPtrFlagsPtrVec &deps = getDeps();
|
|
for (BlockScopeRawPtrFlagsPtrVec::const_iterator it = deps.begin();
|
|
it != deps.end(); ++it) {
|
|
const BlockScopeRawPtrFlagsPtrPair &p(*it);
|
|
if ((*p.second & BlockScope::UseKindCaller) &&
|
|
p.first->is(BlockScope::FunctionScope)) {
|
|
FunctionScopeRawPtr f(
|
|
static_pointer_cast<FunctionScope>(p.first));
|
|
callers.push_back(f->getDocFullName());
|
|
}
|
|
}
|
|
ms.add("callers", callers);
|
|
|
|
// scopes that this scope calls (callees)
|
|
// TODO(stephentu): this list only contains *user* functions,
|
|
// we should also include builtins
|
|
vector<string> callees;
|
|
const BlockScopeRawPtrFlagsVec &users = getOrderedUsers();
|
|
for (BlockScopeRawPtrFlagsVec::const_iterator uit = users.begin();
|
|
uit != users.end(); ++uit) {
|
|
BlockScopeRawPtrFlagsVec::value_type pf = *uit;
|
|
if ((pf->second & BlockScope::UseKindCaller) &&
|
|
pf->first->is(BlockScope::FunctionScope)) {
|
|
FunctionScopeRawPtr f(
|
|
static_pointer_cast<FunctionScope>(pf->first));
|
|
callees.push_back(f->getDocFullName());
|
|
}
|
|
}
|
|
ms.add("callees", callees);
|
|
|
|
ms.done();
|
|
}
|
|
|
|
void FunctionScope::outputCPPCreateDecl(CodeGenerator &cg,
|
|
AnalysisResultPtr ar) {
|
|
ClassScopePtr scope = getContainingClass();
|
|
CodeGenerator::Context context = cg.getContext();
|
|
bool setWrapper = Option::HardTypeHints && needsTypeCheckWrapper();
|
|
|
|
cg_printf("public: %s%s *create(",
|
|
Option::ClassPrefix, scope->getId().c_str());
|
|
cg.setContext(setWrapper ?
|
|
CodeGenerator::CppTypedParamsWrapperDecl :
|
|
CodeGenerator::CppFunctionWrapperDecl);
|
|
outputCPPParamsDecl(cg, ar,
|
|
dynamic_pointer_cast<MethodStatement>(getStmt())
|
|
->getParams(), true);
|
|
cg.setContext(context);
|
|
cg_printf(");\n");
|
|
}
|
|
|
|
void FunctionScope::outputCPPCreateImpl(CodeGenerator &cg,
|
|
AnalysisResultPtr ar) {
|
|
ClassScopePtr scope = getContainingClass();
|
|
string clsNameStr = scope->getId();
|
|
const char *clsName = clsNameStr.c_str();
|
|
const string &funcNameStr = this->getName();
|
|
const char *consName = funcNameStr.c_str();
|
|
CodeGenerator::Context context = cg.getContext();
|
|
bool setWrapper = Option::HardTypeHints && needsTypeCheckWrapper();
|
|
|
|
cg_printf("%s%s *%s%s::create(",
|
|
Option::ClassPrefix, clsName, Option::ClassPrefix, clsName);
|
|
|
|
cg.setContext(setWrapper ?
|
|
CodeGenerator::CppTypedParamsWrapperImpl :
|
|
CodeGenerator::CppFunctionWrapperImpl);
|
|
outputCPPParamsImpl(cg, ar);
|
|
cg_indentBegin(") {\n");
|
|
cg_printf("CountableHelper h(this);\n");
|
|
cg_printf("init();\n");
|
|
cg_printf("%s%s(", Option::MethodPrefix, consName);
|
|
outputCPPParamsCall(cg, ar, false);
|
|
cg.setContext(context);
|
|
cg_printf(");\n");
|
|
if (scope->derivesFromRedeclaring() ||
|
|
scope->hasAttribute(ClassScope::HasDestructor, ar)) {
|
|
cg_printf("clearNoDestruct();\n");
|
|
}
|
|
cg_printf("return this;\n");
|
|
cg_indentEnd("}\n");
|
|
}
|
|
|
|
void FunctionScope::outputCPPClassMap(CodeGenerator &cg, AnalysisResultPtr ar) {
|
|
if (m_method && ParserBase::IsAnonFunctionName(m_name)) {
|
|
return;
|
|
}
|
|
int attribute = ClassInfo::IsNothing;
|
|
if (!isUserFunction()) attribute |= ClassInfo::IsSystem;
|
|
if (!m_method && isSepExtension()) attribute |= ClassInfo::IsPrivate;
|
|
if (isVolatile() && !isRedeclaring()) attribute |= ClassInfo::IsVolatile;
|
|
if (isRefReturn()) attribute |= ClassInfo::IsReference;
|
|
|
|
if (isProtected()) {
|
|
attribute |= ClassInfo::IsProtected;
|
|
} else if (isPrivate()) {
|
|
attribute |= ClassInfo::IsPrivate;
|
|
} else {
|
|
attribute |= ClassInfo::IsPublic;
|
|
}
|
|
if (isAbstract()) attribute |= ClassInfo::IsAbstract;
|
|
if (isStatic()) {
|
|
attribute |= ClassInfo::IsStatic;
|
|
}
|
|
if (isFinal()) attribute |= ClassInfo::IsFinal;
|
|
|
|
if (isVariableArgument()) {
|
|
attribute |= ClassInfo::VariableArguments;
|
|
}
|
|
if (isReferenceVariableArgument()) {
|
|
attribute |= ClassInfo::RefVariableArguments;
|
|
}
|
|
if (isMixedVariableArgument()) {
|
|
attribute |= ClassInfo::MixedVariableArguments;
|
|
}
|
|
if (hasGeneratorAsBody()) {
|
|
attribute |= ClassInfo::HasGeneratorAsBody;
|
|
}
|
|
if (isClosure()) {
|
|
attribute |= ClassInfo::IsClosure;
|
|
}
|
|
|
|
attribute |= m_attributeClassInfo;
|
|
if (!m_docComment.empty() && Option::GenerateDocComments) {
|
|
attribute |= ClassInfo::HasDocComment;
|
|
} else {
|
|
attribute &= ~ClassInfo::HasDocComment;
|
|
}
|
|
|
|
if (m_method && isConstructor(getContainingClass())) {
|
|
attribute |= ClassInfo::IsConstructor;
|
|
}
|
|
if (needsActRec()) {
|
|
attribute |= ClassInfo::NeedsActRec;
|
|
}
|
|
|
|
// Use the original cased name, for reflection to work correctly.
|
|
cg_printf("(const char *)0x%04X, \"%s\", \"%s\", (const char *)%d, "
|
|
"(const char *)%d,\n", attribute,
|
|
CodeGenerator::EscapeLabel(getOriginalName()).c_str(),
|
|
m_stmt ? m_stmt->getLocation()->file : "",
|
|
m_stmt ? m_stmt->getLocation()->line0 : 0,
|
|
m_stmt ? m_stmt->getLocation()->line1 : 0);
|
|
|
|
|
|
if (attribute & ClassInfo::IsVolatile) {
|
|
cg_printf("(const char*)offsetof(GlobalVariables, FVF(%s)),\n",
|
|
CodeGenerator::FormatLabel(m_name).c_str());
|
|
}
|
|
|
|
if (!m_docComment.empty() && Option::GenerateDocComments) {
|
|
std::string dc = string_cplus_escape(m_docComment.c_str(), m_docComment.size());
|
|
cg_printf("\"%s\",\n", dc.c_str());
|
|
}
|
|
|
|
if (attribute & ClassInfo::IsSystem) {
|
|
if (m_returnType) {
|
|
cg_printf("(const char *)0x%x, ", m_returnType->getDataType());
|
|
} else {
|
|
cg_printf("(const char *)-1, ");
|
|
}
|
|
}
|
|
|
|
Variant defArg;
|
|
for (int i = 0; i < m_maxParam; i++) {
|
|
int attr = ClassInfo::IsNothing;
|
|
if (isRefParam(i)) attr |= ClassInfo::IsReference;
|
|
|
|
cg_printf("(const char *)0x%04X, \"%s\", ",
|
|
attr, m_paramNames[i].c_str());
|
|
|
|
MethodStatementPtr m =
|
|
dynamic_pointer_cast<MethodStatement>(getStmt());
|
|
if (m) {
|
|
ExpressionListPtr params = m->getParams();
|
|
always_assert(i < params->getCount());
|
|
ParameterExpressionPtr param =
|
|
dynamic_pointer_cast<ParameterExpression>((*params)[i]);
|
|
always_assert(param);
|
|
cg_printf("\"%s\", ", param->hasTypeHint() ?
|
|
param->getOriginalTypeHint().c_str() : "");
|
|
if (attribute & ClassInfo::IsSystem) {
|
|
cg_printf("(const char *)-1, ");
|
|
}
|
|
ExpressionPtr def = param->defaultValue();
|
|
if (def) {
|
|
std::string text, value;
|
|
if (!def->isScalar() || !def->getScalarValue(defArg)) {
|
|
/**
|
|
* Special value runtime/ext/ext_reflection.cpp can check and throw.
|
|
* If we want to avoid seeing this so to make getDefaultValue()
|
|
* work better for reflections, we will have to implement
|
|
* getScalarValue() to greater extent under compiler/expressions.
|
|
*/
|
|
value = "\x01";
|
|
text = def->getText();
|
|
} else {
|
|
String str = f_serialize(defArg);
|
|
value = string_cplus_escape(str.data(), str.size());
|
|
text = VariableSerializer(VariableSerializer::PHPOutput).serialize(
|
|
defArg, true).data();
|
|
}
|
|
cg_printf("\"%s\", \"%s\",\n", value.c_str(),
|
|
string_cplus_escape(text.data(), text.size()).c_str());
|
|
} else {
|
|
cg_printf("\"\", \"\",\n");
|
|
}
|
|
// user attributes
|
|
ExpressionListPtr paramUserAttrs =
|
|
dynamic_pointer_cast<ExpressionList>(param->userAttributeList());
|
|
if (paramUserAttrs) {
|
|
for (int j = 0; j < paramUserAttrs->getCount(); ++j) {
|
|
UserAttributePtr a = dynamic_pointer_cast<UserAttribute>(
|
|
(*paramUserAttrs)[j]);
|
|
ExpressionPtr expr = a->getExp();
|
|
Variant v;
|
|
bool isScalar UNUSED = expr->getScalarValue(v);
|
|
assert(isScalar);
|
|
int valueLen = 0;
|
|
string valueText = SymbolTable::getEscapedText(v, valueLen);
|
|
cg_printf("\"%s\", (const char *)%d, \"%s\",\n",
|
|
CodeGenerator::EscapeLabel(a->getName()).c_str(),
|
|
valueLen, valueText.c_str());
|
|
}
|
|
}
|
|
cg_printf("NULL,\n");
|
|
} else {
|
|
cg_printf("\"\", ");
|
|
if (attribute & ClassInfo::IsSystem) {
|
|
cg_printf("(const char *)0x%x, ", m_paramTypes[i]->getDataType());
|
|
}
|
|
std::string def = string_cplus_escape(m_paramDefaults[i].data(),
|
|
m_paramDefaults[i].size());
|
|
std::string defText = string_cplus_escape(m_paramDefaultTexts[i].data(),
|
|
m_paramDefaultTexts[i].size());
|
|
cg_printf("\"%s\", \"%s\", NULL,\n", def.c_str(), defText.c_str());
|
|
}
|
|
}
|
|
cg_printf("NULL,\n");
|
|
|
|
m_variables->outputCPPStaticVariables(cg, ar);
|
|
|
|
// user attributes
|
|
UserAttributeMap::const_iterator it = m_userAttributes.begin();
|
|
for (; it != m_userAttributes.end(); ++it) {
|
|
ExpressionPtr expr = it->second;
|
|
Variant v;
|
|
bool isScalar UNUSED = expr->getScalarValue(v);
|
|
assert(isScalar);
|
|
int valueLen = 0;
|
|
string valueText = SymbolTable::getEscapedText(v, valueLen);
|
|
cg_printf("\"%s\", (const char *)%d, \"%s\",\n",
|
|
CodeGenerator::EscapeLabel(it->first).c_str(),
|
|
valueLen, valueText.c_str());
|
|
}
|
|
cg_printf("NULL,\n");
|
|
}
|
|
|
|
void FunctionScope::outputCPPHelperClassAlloc(CodeGenerator &cg,
|
|
AnalysisResultPtr ar) {
|
|
|
|
const string &funcName = CodeGenerator::FormatLabel(m_name);
|
|
ParameterExpressionPtrVec useVars;
|
|
if (needsAnonClosureClass(useVars)) {
|
|
cg_printf("IMPLEMENT_OBJECT_ALLOCATION_NO_DEFAULT_SWEEP(%sClosure$%s)\n",
|
|
Option::ClassPrefix, funcName.c_str());
|
|
}
|
|
if (isGenerator()) {
|
|
cg_printf(
|
|
"IMPLEMENT_OBJECT_ALLOCATION_NO_DEFAULT_SWEEP(%sContinuation$%s)\n",
|
|
Option::ClassPrefix, funcName.c_str());
|
|
}
|
|
}
|
|
|
|
void FunctionScope::outputCPPCallInfo(CodeGenerator &cg,
|
|
AnalysisResultPtr ar) {
|
|
if (isAbstract()) return;
|
|
string id;
|
|
if (m_method) {
|
|
id = CodeGenerator::FormatLabel(m_name);
|
|
} else {
|
|
id = getId();
|
|
}
|
|
uint64 refflags = 0;
|
|
for (int i = 0; i < m_maxParam; ++i) {
|
|
if (isRefParam(i)) {
|
|
refflags |= 1 << i;
|
|
}
|
|
}
|
|
int flags = 0;
|
|
if (isMixedVariableArgument()) {
|
|
flags |= CallInfo::MixedVarArgs;
|
|
} else if (isReferenceVariableArgument()) {
|
|
flags |= CallInfo::RefVarArgs;
|
|
} else if (isVariableArgument()) {
|
|
flags |= CallInfo::VarArgs;
|
|
}
|
|
if (m_method) {
|
|
flags |= CallInfo::Method;
|
|
if (isProtected()) {
|
|
flags |= CallInfo::Protected;
|
|
} else if (isPrivate()) {
|
|
flags |= CallInfo::Private;
|
|
}
|
|
if (isStatic()) {
|
|
flags |= CallInfo::StaticMethod;
|
|
}
|
|
ClassScopePtr scope = getContainingClass();
|
|
string clsName = scope->getId();
|
|
|
|
cg.printf("extern const CallInfo %s%s%s%s = { (void*)&%s%s::%s%s, ",
|
|
Option::CallInfoPrefix, clsName.c_str(),
|
|
Option::IdPrefix.c_str(), id.c_str(),
|
|
Option::ClassPrefix, clsName.c_str(), Option::InvokePrefix,
|
|
id.c_str());
|
|
cg.printf("(void*)&%s%s::%s%s", Option::ClassPrefix, clsName.c_str(),
|
|
Option::InvokeFewArgsPrefix, id.c_str());
|
|
if (m_name == "__invoke" &&
|
|
strcasecmp(clsName.c_str(), "closure")) {
|
|
cg.printf(", %d, %d, 0x%.16llXLL};\n",
|
|
m_maxParam, flags, refflags);
|
|
|
|
// need to generate an extra call info for an extra wrapper
|
|
cg.printf("const CallInfo %s%s%s%s = { (void*)&%s%s::%s%s, ",
|
|
Option::CallInfoWrapperPrefix, clsName.c_str(),
|
|
Option::IdPrefix.c_str(), id.c_str(),
|
|
Option::ClassPrefix, clsName.c_str(),
|
|
Option::InvokeWrapperPrefix, id.c_str());
|
|
cg.printf("(void*)&%s%s::%s%s", Option::ClassPrefix, clsName.c_str(),
|
|
Option::InvokeWrapperFewArgsPrefix, id.c_str());
|
|
}
|
|
} else {
|
|
cg.printf("extern const %sCallInfo %s%s = {",
|
|
isRedeclaring() ? "Redeclared" : "",
|
|
Option::CallInfoPrefix, id.c_str());
|
|
if (isRedeclaring()) cg_printf("{");
|
|
cg_printf("(void*)&%s%s, (void*)&%s%s",
|
|
Option::InvokePrefix, id.c_str(),
|
|
Option::InvokeFewArgsPrefix, id.c_str());
|
|
}
|
|
cg.printf(", %d, %d, 0x%.16llXL", m_maxParam, flags, refflags);
|
|
if (isRedeclaring()) {
|
|
cg_printf("}, %d", getRedeclaringId());
|
|
}
|
|
cg_printf("};\n");
|
|
}
|
|
|
|
void FunctionScope::getClosureUseVars(
|
|
ParameterExpressionPtrIdxPairVec &useVars,
|
|
bool filterUsed /* = true */) {
|
|
useVars.clear();
|
|
if (!m_closureVars) return;
|
|
assert(isClosure());
|
|
VariableTablePtr variables = getVariables();
|
|
for (int i = 0; i < m_closureVars->getCount(); i++) {
|
|
ParameterExpressionPtr param =
|
|
dynamic_pointer_cast<ParameterExpression>((*m_closureVars)[i]);
|
|
const string &name = param->getName();
|
|
if (!filterUsed || variables->isUsed(name)) {
|
|
useVars.push_back(ParameterExpressionPtrIdxPair(param, i));
|
|
}
|
|
}
|
|
}
|
|
|
|
template <class U, class V>
|
|
static U pair_first_elem(std::pair<U, V> p) { return p.first; }
|
|
|
|
bool FunctionScope::needsAnonClosureClass(ParameterExpressionPtrVec &useVars) {
|
|
useVars.clear();
|
|
if (!isClosure()) return false;
|
|
ParameterExpressionPtrIdxPairVec useVars0;
|
|
getClosureUseVars(useVars0, !m_closureGenerator);
|
|
useVars.resize(useVars0.size());
|
|
// C++ seems to be unable to infer the type here on pair_first_elem
|
|
transform(useVars0.begin(),
|
|
useVars0.end(),
|
|
useVars.begin(),
|
|
pair_first_elem<ParameterExpressionPtr, int>);
|
|
return useVars.size() > 0 || getVariables()->hasStaticLocals();
|
|
}
|
|
|
|
bool FunctionScope::needsAnonClosureClass(
|
|
ParameterExpressionPtrIdxPairVec &useVars) {
|
|
useVars.clear();
|
|
if (!isClosure()) return false;
|
|
getClosureUseVars(useVars, !m_closureGenerator);
|
|
return useVars.size() > 0 || getVariables()->hasStaticLocals();
|
|
}
|
|
|
|
void FunctionScope::outputCPPSubClassParam(CodeGenerator &cg,
|
|
AnalysisResultPtr ar,
|
|
ParameterExpressionPtr param) {
|
|
VariableTablePtr variables = getVariables();
|
|
const string &name = param->getName();
|
|
Symbol *sym = variables->getSymbol(name);
|
|
assert(sym);
|
|
TypePtr t(sym->getFinalType());
|
|
if (!param->isRef()) {
|
|
if (t->is(Type::KindOfVariant) || t->is(Type::KindOfSome)) {
|
|
cg_printf("CVarRef");
|
|
} else if (t->is(Type::KindOfArray)) cg_printf("CArrRef");
|
|
else if (t->is(Type::KindOfString)) cg_printf("CStrRef");
|
|
else if (t->isStandardObject()) cg_printf("CObjRef");
|
|
else t->outputCPPDecl(cg, ar, shared_from_this());
|
|
} else {
|
|
t->outputCPPDecl(cg, ar, shared_from_this());
|
|
}
|
|
cg_printf(" %s%s",
|
|
Option::TempVariablePrefix,
|
|
CodeGenerator::FormatLabel(name).c_str());
|
|
}
|
|
|
|
void FunctionScope::outputCPPPreface(CodeGenerator &cg, AnalysisResultPtr ar) {
|
|
ClassScopeRawPtr cls = getContainingClass();
|
|
if (!cls) {
|
|
if (!inPseudoMain()) {
|
|
// spit out extern CallInfo decl
|
|
cg_printf("extern const %sCallInfo %s%s;\n",
|
|
isRedeclaring() ? "Redeclared" : "",
|
|
Option::CallInfoPrefix, getId().c_str());
|
|
}
|
|
} else {
|
|
if (isGenerator()) {
|
|
cg_printf("extern const CallInfo %s%s%s%s;\n",
|
|
Option::CallInfoPrefix, getContainingClass()->getId().c_str(),
|
|
Option::IdPrefix.c_str(), getId().c_str());
|
|
}
|
|
}
|
|
|
|
const string &funcName = CodeGenerator::FormatLabel(m_name);
|
|
ParameterExpressionPtrVec useVars;
|
|
if (needsAnonClosureClass(useVars) &&
|
|
cg.insertDeclaredClosure(this)) {
|
|
cg_printf("FORWARD_DECLARE_CLASS(Closure$%s);\n", funcName.c_str());
|
|
cg_indentBegin("class %sClosure$%s : public %sClosure {\n",
|
|
Option::ClassPrefix, funcName.c_str(),
|
|
Option::ClassPrefix);
|
|
|
|
cg_printf("public:\n");
|
|
|
|
cg_printf("DECLARE_OBJECT_ALLOCATION_NO_SWEEP(%sClosure$%s)\n",
|
|
Option::ClassPrefix, funcName.c_str());
|
|
|
|
VariableTablePtr variables = getVariables();
|
|
if (!useVars.empty()) {
|
|
BOOST_FOREACH(ParameterExpressionPtr param, useVars) {
|
|
const string &name = param->getName();
|
|
Symbol *sym = variables->getSymbol(name);
|
|
TypePtr t(sym->getFinalType());
|
|
t->outputCPPDecl(cg, ar, shared_from_this());
|
|
const string &varName = variables->getVariableName(ar, sym);
|
|
cg_printf(" %s;\n", varName.c_str());
|
|
}
|
|
cg_printf("\n");
|
|
}
|
|
|
|
if (variables->hasStaticLocals()) {
|
|
variables->outputCPPStaticLocals(cg, ar, false);
|
|
cg_printf("\n");
|
|
}
|
|
|
|
cg_printf("%sClosure$%s(const CallInfo *func, const char *name",
|
|
Option::ClassPrefix, funcName.c_str());
|
|
|
|
if (!useVars.empty()) cg_printf(", ");
|
|
bool hasEmit = false;
|
|
BOOST_FOREACH(ParameterExpressionPtr param, useVars) {
|
|
if (!hasEmit) hasEmit = true;
|
|
else cg_printf(", ");
|
|
outputCPPSubClassParam(cg, ar, param);
|
|
}
|
|
|
|
// TODO: non ref variants can be directly assigned to the member
|
|
// variable in the initialization list, giving an ever-so-slight
|
|
// gain in performance
|
|
cg_printf(") : %sClosure(func, name)", Option::ClassPrefix);
|
|
if (variables->hasStaticLocals()) {
|
|
cg_printf(", ");
|
|
variables->outputCPPStaticLocals(cg, ar, true);
|
|
}
|
|
cg_indentBegin(" {\n");
|
|
BOOST_FOREACH(ParameterExpressionPtr param, useVars) {
|
|
const string &name = param->getName();
|
|
Symbol *sym = variables->getSymbol(name);
|
|
assert(sym);
|
|
TypePtr t(sym->getFinalType());
|
|
assert(!param->isRef() || t->is(Type::KindOfVariant));
|
|
const string &varName = variables->getVariableName(ar, sym);
|
|
const string &tmpName =
|
|
string(Option::TempVariablePrefix) + CodeGenerator::FormatLabel(name);
|
|
if (t->is(Type::KindOfVariant)) {
|
|
const char *s = param->isRef() ? "Ref" : "Val";
|
|
cg_printf("%s.assign%s(%s);\n", varName.c_str(), s, tmpName.c_str());
|
|
} else {
|
|
assert(!param->isRef());
|
|
cg_printf("%s = %s;\n", varName.c_str(), tmpName.c_str());
|
|
}
|
|
}
|
|
cg_indentEnd("}\n");
|
|
cg_indentEnd("};\n");
|
|
}
|
|
|
|
if (isGenerator()) {
|
|
cg_printf("FORWARD_DECLARE_CLASS(Continuation$%s);\n", funcName.c_str());
|
|
cg_indentBegin("class %sContinuation$%s : public %sContinuation {\n",
|
|
Option::ClassPrefix, funcName.c_str(), Option::ClassPrefix);
|
|
|
|
if (cls && cls->derivedByDynamic()) {
|
|
/*
|
|
* The m_obj property is potentially a redeclared-parent. We
|
|
* need to keep a reference to the root object too, to ensure
|
|
* that the root object doesnt get destroyed before m_obj
|
|
*/
|
|
cg_printf("Object o_rootObj;\n");
|
|
}
|
|
cg_printf("public:\n");
|
|
|
|
cg_printf("DECLARE_OBJECT_ALLOCATION_NO_SWEEP(%sContinuation$%s)\n",
|
|
Option::ClassPrefix, funcName.c_str());
|
|
|
|
VariableTablePtr variables = getVariables();
|
|
vector<Symbol*> symbols;
|
|
variables->getSymbols(symbols, true);
|
|
|
|
if (!symbols.empty()) {
|
|
BOOST_FOREACH(Symbol *sym, symbols) {
|
|
const string &varName = variables->getVariableName(ar, sym);
|
|
TypePtr type = sym->getFinalType();
|
|
type->outputCPPDecl(cg, ar, shared_from_this());
|
|
cg_printf(" %s;\n", varName.c_str());
|
|
}
|
|
cg_printf("\n");
|
|
}
|
|
|
|
if (variables->hasStaticLocals()) {
|
|
variables->outputCPPStaticLocals(cg, ar, false);
|
|
cg_printf("\n");
|
|
|
|
// no arg ctor w/ init list of static locals
|
|
cg_printf("%sContinuation$%s() : ",
|
|
Option::ClassPrefix,
|
|
funcName.c_str());
|
|
variables->outputCPPStaticLocals(cg, ar, true);
|
|
cg_printf(" {}\n");
|
|
}
|
|
|
|
// constructor is bootstrapped with all the parameters
|
|
// of the original generator function + use vars for any
|
|
// surrounding closure generator
|
|
cg_printf("static %sContinuation$%s Build("
|
|
"int64 func, int64 extra, bool isMethod, CStrRef origFuncName, ",
|
|
Option::SmartPtrPrefix, funcName.c_str());
|
|
|
|
MethodStatementRawPtr orig = getOrigGenStmt();
|
|
assert(orig);
|
|
ExpressionListPtr params = orig->getParams();
|
|
|
|
vector<ParameterExpressionPtr> ctorParams;
|
|
if (params) {
|
|
for (int i = 0; i < params->getCount(); i++) {
|
|
ParameterExpressionPtr param =
|
|
dynamic_pointer_cast<ParameterExpression>((*params)[i]);
|
|
ctorParams.push_back(param);
|
|
}
|
|
}
|
|
useVars.clear();
|
|
bool needsClosureCls =
|
|
orig->getFunctionScope()->needsAnonClosureClass(useVars);
|
|
if (needsClosureCls) {
|
|
assert(useVars.size() > 0);
|
|
ctorParams.insert(ctorParams.end(), useVars.begin(), useVars.end());
|
|
}
|
|
|
|
bool hasEmit = false;
|
|
BOOST_FOREACH(ParameterExpressionPtr param, ctorParams) {
|
|
const string& name = param->getName();
|
|
Symbol *sym = variables->getSymbol(name);
|
|
if (sym) {
|
|
if (!hasEmit) hasEmit = true;
|
|
else cg_printf(", ");
|
|
outputCPPSubClassParam(cg, ar, param);
|
|
}
|
|
}
|
|
|
|
if (hasEmit) cg_printf(", ");
|
|
if (cls && cls->derivedByDynamic()) {
|
|
cg_printf("CObjRef rootObj, ");
|
|
}
|
|
cg_indentBegin("CVarRef obj, CArrRef args) {\n");
|
|
cg_printf("%sContinuation$%s cont = "
|
|
"%sContinuation$%s(NEWOBJ(%sContinuation$%s)());\n",
|
|
Option::SmartPtrPrefix, funcName.c_str(),
|
|
Option::SmartPtrPrefix, funcName.c_str(),
|
|
Option::ClassPrefix, funcName.c_str());
|
|
cg_printf("cont->%s__construct"
|
|
"(func, extra, isMethod, origFuncName, obj, args);\n",
|
|
Option::MethodPrefix);
|
|
if (cls && cls->derivedByDynamic()) {
|
|
cg_printf("cont->o_rootObj = rootObj;\n");
|
|
}
|
|
|
|
BOOST_FOREACH(ParameterExpressionPtr param, ctorParams) {
|
|
const string& name = param->getName();
|
|
Symbol *sym = variables->getSymbol(name);
|
|
if (sym) {
|
|
const string &varName = variables->getVariableName(ar, sym);
|
|
const string &tmpName =
|
|
string(Option::TempVariablePrefix) +
|
|
CodeGenerator::FormatLabel(name);
|
|
TypePtr t(sym->getFinalType());
|
|
if (t->is(Type::KindOfVariant)) {
|
|
const char *s = param->isRef() ? "Ref" : "Val";
|
|
cg_printf("cont->%s.assign%s(%s);\n",
|
|
varName.c_str(), s, tmpName.c_str());
|
|
} else {
|
|
assert(!param->isRef());
|
|
cg_printf("cont->%s = %s;\n", varName.c_str(), tmpName.c_str());
|
|
}
|
|
}
|
|
}
|
|
if (usesLSB()) {
|
|
cg_printf("cont->setCalledClass(f_get_called_class());\n");
|
|
}
|
|
cg_printf("return cont;\n");
|
|
cg_indentEnd("}\n");
|
|
cg_indentEnd("};\n");
|
|
}
|
|
}
|
|
|
|
FunctionScope::StringToFunctionInfoPtrMap FunctionScope::s_refParamInfo;
|
|
static Mutex s_refParamInfoLock;
|
|
|
|
void FunctionScope::RecordFunctionInfo(string fname, FunctionScopePtr func) {
|
|
VariableTablePtr variables = func->getVariables();
|
|
if (Option::WholeProgram) {
|
|
Lock lock(s_refParamInfoLock);
|
|
FunctionInfoPtr &info = s_refParamInfo[fname];
|
|
if (!info) {
|
|
info = FunctionInfoPtr(new FunctionInfo());
|
|
}
|
|
if (func->isStatic()) {
|
|
info->setMaybeStatic();
|
|
}
|
|
if (func->isRefReturn()) {
|
|
info->setMaybeRefReturn();
|
|
}
|
|
if (func->isReferenceVariableArgument()) {
|
|
info->setRefVarArg(func->getMaxParamCount());
|
|
}
|
|
for (int i = 0; i < func->getMaxParamCount(); i++) {
|
|
if (func->isRefParam(i)) info->setRefParam(i);
|
|
}
|
|
}
|
|
for (int i = 0; i < func->getMaxParamCount(); i++) {
|
|
variables->addParam(func->getParamName(i),
|
|
TypePtr(), AnalysisResultPtr(), ConstructPtr());
|
|
}
|
|
}
|
|
|
|
FunctionScope::FunctionInfoPtr FunctionScope::GetFunctionInfo(string fname) {
|
|
assert(Option::WholeProgram);
|
|
StringToFunctionInfoPtrMap::iterator it = s_refParamInfo.find(fname);
|
|
if (it == s_refParamInfo.end()) {
|
|
return FunctionInfoPtr();
|
|
}
|
|
return it->second;
|
|
}
|
|
|
|
void FunctionScope::outputMethodWrapper(CodeGenerator &cg,
|
|
AnalysisResultPtr ar,
|
|
const char *clsToConstruct) {
|
|
cg_printf("\n");
|
|
if (m_stmt) {
|
|
m_stmt->printSource(cg);
|
|
}
|
|
cg.printDocComment(m_docComment);
|
|
|
|
int minCount = getMinParamCount();
|
|
int maxCount = getMaxParamCount();
|
|
|
|
for (int count = minCount; count <= maxCount; count++) {
|
|
TypePtr type = getReturnType();
|
|
|
|
if (clsToConstruct) {
|
|
cg_printf("static %s%s Create(", Option::SmartPtrPrefix, clsToConstruct);
|
|
} else {
|
|
if (isStatic()) cg_printf("static ");
|
|
if (type) {
|
|
type->outputCPPDecl(cg, ar, BlockScopeRawPtr(this));
|
|
} else {
|
|
cg_printf("void");
|
|
}
|
|
cg_printf(" %s%s(", Option::MethodWrapperPrefix, getId().c_str());
|
|
}
|
|
|
|
for (int i = 0; i < count; i++) {
|
|
if (i > 0) cg_printf(", ");
|
|
getParamType(i)->outputCPPDecl(cg, ar, BlockScopeRawPtr(this));
|
|
cg_printf(" %s%s", Option::VariablePrefix, getParamName(i).c_str());
|
|
}
|
|
if (isVariableArgument()) {
|
|
if (count) cg_printf(", ");
|
|
cg_printf("Array args = Array()");
|
|
}
|
|
cg_indentBegin(") {\n");
|
|
|
|
if (clsToConstruct) {
|
|
cg_printf("%s%s ret(NEWOBJ(%s%s)());\n",
|
|
Option::SmartPtrPrefix, clsToConstruct,
|
|
Option::ClassPrefix, clsToConstruct);
|
|
}
|
|
|
|
if ((isStatic() || isPerfectVirtual() || !isVirtual() || clsToConstruct) &&
|
|
!isRedeclaring()) {
|
|
|
|
if (clsToConstruct) {
|
|
cg_printf("ret->");
|
|
} else if (type) {
|
|
cg_printf("return ");
|
|
}
|
|
|
|
cg_printf("%s%s(", Option::MethodPrefix,
|
|
CodeGenerator::FormatLabel(m_name).c_str());
|
|
if (isVariableArgument()) {
|
|
cg_printf("args.size() + %d, ", count);
|
|
}
|
|
for (int i = 0; i < count; i++) {
|
|
if (i > 0) cg_printf(", ");
|
|
bool isRef = isRefParam(i);
|
|
if (isRef) cg_printf("ref(");
|
|
cg_printf("%s%s", Option::VariablePrefix, getParamName(i).c_str());
|
|
if (isRef) cg_printf(")");
|
|
}
|
|
if (isVariableArgument()) {
|
|
if (count) cg_printf(", ");
|
|
cg_printf("args");
|
|
}
|
|
cg_printf(");\n");
|
|
|
|
} else {
|
|
cg_printf("Array params;\n");
|
|
for (int i = 0; i < count; i++) {
|
|
cg_printf("params.append(");
|
|
|
|
bool isRef = isRefParam(i);
|
|
if (isRef) cg_printf("ref(");
|
|
cg_printf("%s%s", Option::VariablePrefix, getParamName(i).c_str());
|
|
if (isRef) cg_printf(")");
|
|
|
|
cg_printf(");\n");
|
|
}
|
|
if (isVariableArgument()) {
|
|
cg_printf("params.merge(args);\n");
|
|
}
|
|
|
|
if (clsToConstruct) {
|
|
cg_printf("ret->");
|
|
} else if (type) {
|
|
cg_printf("return ");
|
|
}
|
|
|
|
always_assert(!isStatic());
|
|
cg_printf("%sinvoke(\"%s\", params, -1);\n",
|
|
Option::ObjectPrefix, m_name.c_str());
|
|
}
|
|
|
|
if (clsToConstruct) {
|
|
cg_printf("return ret;\n");
|
|
}
|
|
cg_indentEnd("}\n");
|
|
}
|
|
}
|