void ClassStatement::getAllParents(AnalysisResultPtr ar,
std::vector<std::string> &names) {
if (!m_parent.empty()) {
ClassScopePtr cls = ar->findClass(m_parent);
if (cls) {
if (!cls->isRedeclaring()) {
cls->getAllParents(ar, names);
}
names.push_back(m_parent);
}
}
if (m_base) {
vector<string> bases;
m_base->getStrings(bases);
for (unsigned int i = 0; i < bases.size(); i++) {
ClassScopePtr cls = ar->findClass(bases[i]);
if (cls) {
if (!cls->isRedeclaring()) {
cls->getAllParents(ar, names);
}
names.push_back(bases[i]);
}
}
}
}
TypePtr ParameterExpression::getTypeSpecForClass(AnalysisResultPtr ar,
bool forInference) {
TypePtr ret;
if (forInference) {
ClassScopePtr cls = ar->findClass(m_type);
if (!cls || cls->isRedeclaring() || cls->derivedByDynamic()) {
if (!cls && getScope()->isFirstPass() && !ar->isTypeAliasName(m_type)) {
ConstructPtr self = shared_from_this();
Compiler::Error(Compiler::UnknownClass, self);
}
ret = Type::Variant;
}
if (cls) {
// Classes must be redeclaring if there are also type aliases
// with the same name.
assert(!ar->isTypeAliasName(m_type) || cls->isRedeclaring());
}
}
if (!ret) {
ret = ar->isTypeAliasName(m_type) || !Option::WholeProgram
? Type::Variant
: Type::CreateObjectType(m_type);
}
always_assert(ret);
return ret;
}
TypePtr DynamicFunctionCall::inferTypes(AnalysisResultPtr ar, TypePtr type,
bool coerce) {
reset();
ConstructPtr self = shared_from_this();
if (!m_className.empty()) {
ClassScopePtr cls = ar->resolveClass(m_className);
if (!cls || cls->isRedeclaring()) {
if (cls) {
m_redeclared = true;
ar->getScope()->getVariables()->
setAttribute(VariableTable::NeedGlobalPointer);
}
if (!cls && ar->isFirstPass()) {
ar->getCodeError()->record(self, CodeError::UnknownClass, self);
}
} else {
m_validClass = true;
}
}
ar->containsDynamicFunctionCall();
if (ar->isFirstPass()) {
ar->getCodeError()->record(self, CodeError::UseDynamicFunction, self);
}
m_nameExp->inferAndCheck(ar, Type::String, false);
if (m_params) {
for (int i = 0; i < m_params->getCount(); i++) {
(*m_params)[i]->inferAndCheck(ar, Type::Variant, true);
}
}
return Type::Variant;
}
void CatchStatement::inferTypes(AnalysisResultPtr ar) {
ClassScopePtr cls = ar->findClass(m_className);
TypePtr type;
m_valid = cls;
if (!m_valid) {
if (ar->isFirstPass()) {
ConstructPtr self = shared_from_this();
ar->getCodeError()->record(self, CodeError::UnknownClass, self);
}
type = NEW_TYPE(Object);
} else if (cls->isRedeclaring()) {
type = NEW_TYPE(Object);
} else {
type = Type::CreateObjectType(m_className);
}
BlockScopePtr scope = ar->getScope();
VariableTablePtr variables = scope->getVariables();
variables->add(m_variable, type, false, ar, shared_from_this(),
ModifierExpressionPtr(), false);
if (ar->isFirstPass()) {
FunctionScopePtr func = dynamic_pointer_cast<FunctionScope>(scope);
if (func && variables->isParameter(m_variable)) {
variables->addLvalParam(m_variable);
}
}
if (m_stmt) m_stmt->inferTypes(ar);
}
void VariableTable::forceVariants(AnalysisResultConstPtr ar, int varClass,
bool recur /* = true */) {
int mask = varClass & ~m_forcedVariants;
if (mask) {
if (!m_hasPrivate) mask &= ~AnyPrivateVars;
if (!m_hasStatic) mask &= ~AnyStaticVars;
if (mask) {
for (unsigned int i = 0; i < m_symbolVec.size(); i++) {
Symbol *sym = m_symbolVec[i];
if (!sym->isHidden() && sym->declarationSet() &&
mask & GetVarClassMaskForSym(sym)) {
setType(ar, sym, Type::Variant, true);
sym->setIndirectAltered();
}
}
}
m_forcedVariants |= varClass;
if (recur) {
ClassScopePtr parent = m_blockScope.getParentScope(ar);
if (parent && !parent->isRedeclaring()) {
parent->getVariables()->forceVariants(ar, varClass & ~AnyPrivateVars);
}
}
}
}
FunctionScopePtr ClassScope::findFunction(AnalysisResultConstPtr ar,
const std::string &name,
bool recursive,
bool exclIntfBase /* = false */) {
auto iter = m_functions.find(name);
if (iter != m_functions.end()) {
assert(iter->second);
return iter->second;
}
// walk up
if (recursive) {
int s = m_bases.size();
for (int i = 0; i < s; i++) {
const string &base = m_bases[i];
ClassScopePtr super = ar->findClass(base);
if (!super) continue;
if (exclIntfBase && super->isInterface()) break;
if (super->isRedeclaring()) {
if (base == m_parent) {
m_derivesFromRedeclaring = Derivation::Redeclaring;
break;
}
continue;
}
FunctionScopePtr func =
super->findFunction(ar, name, true, exclIntfBase);
if (func) return func;
}
}
return FunctionScopePtr();
}
TypePtr NewObjectExpression::inferTypes(AnalysisResultPtr ar, TypePtr type,
bool coerce) {
reset();
ConstructPtr self = shared_from_this();
if (!m_name.empty()) {
ClassScopePtr cls = ar->resolveClass(m_name);
if (cls) {
m_name = cls->getName();
}
if (!cls || cls->isRedeclaring()) {
if (cls) {
m_redeclared = true;
ar->getScope()->getVariables()->
setAttribute(VariableTable::NeedGlobalPointer);
}
if (!cls && ar->isFirstPass()) {
ar->getCodeError()->record(self, CodeError::UnknownClass, self);
}
if (m_params) m_params->inferAndCheck(ar, NEW_TYPE(Any), false);
return NEW_TYPE(Object);
}
if (cls->isVolatile()) {
ar->getScope()->getVariables()->
setAttribute(VariableTable::NeedGlobalPointer);
}
m_dynamic = cls->derivesFromRedeclaring();
m_validClass = true;
FunctionScopePtr func = cls->findConstructor(ar, true);
if (!func) {
if (m_params) {
if (!m_dynamic && m_params->getCount()) {
if (ar->isFirstPass()) {
ar->getCodeError()->record(self, CodeError::BadConstructorCall,
self);
}
m_params->setOutputCount(0);
}
m_params->inferAndCheck(ar, NEW_TYPE(Any), false);
}
} else {
m_extraArg = func->inferParamTypes(ar, self, m_params,
m_validClass);
m_variableArgument = func->isVariableArgument();
}
return Type::CreateObjectType(m_name);
} else {
ar->containsDynamicClass();
if (ar->isFirstPass()) {
ar->getCodeError()->record(self, CodeError::UseDynamicClass,
self);
}
if (m_params) {
m_params->markParams(false);
}
}
m_nameExp->inferAndCheck(ar, Type::String, false);
if (m_params) m_params->inferAndCheck(ar, NEW_TYPE(Any), false);
return Type::Variant;//NEW_TYPE(Object);
}
TypePtr ParameterExpression::getTypeSpec(AnalysisResultPtr ar, bool error) {
TypePtr ret;
if (m_type.empty() || m_defaultValue) {
ret = Type::Some;
} else if (m_type == "array") {
ret = Type::Array;
} else {
ClassScopePtr cls = ar->findClass(m_type);
if (!cls || cls->isRedeclaring()) {
if (error && !cls && ar->isFirstPass()) {
ConstructPtr self = shared_from_this();
ar->getCodeError()->record(self, CodeError::UnknownClass, self);
}
ret = Type::Some;
} else {
ret = Type::CreateObjectType(m_type);
}
}
// we still want the above to run, so to record errors and infer defaults
if (m_ref) {
ret = Type::Variant;
}
return ret;
}
TypePtr ParameterExpression::getTypeSpec(AnalysisResultPtr ar,
bool forInference) {
const Type::TypePtrMap &types = Type::GetTypeHintTypes();
Type::TypePtrMap::const_iterator iter;
TypePtr ret;
if (m_type.empty() || (forInference && m_defaultValue)) {
ret = Type::Some;
} else if ((iter = types.find(m_type)) != types.end()) {
ret = iter->second;
} else {
if (forInference) {
ClassScopePtr cls = ar->findClass(m_type);
if (Option::SystemGen ||
!cls || cls->isRedeclaring() || cls->derivedByDynamic()) {
if (!cls && getScope()->isFirstPass()) {
ConstructPtr self = shared_from_this();
Compiler::Error(Compiler::UnknownClass, self);
}
ret = Type::Variant;
}
}
if (!ret) {
ret = Type::CreateObjectType(m_type);
}
}
// we still want the above to run, so to record errors and infer defaults
if (m_ref && forInference) {
ret = Type::Variant;
}
return ret;
}
bool Type::IsLegalCast(AnalysisResultConstPtr ar, TypePtr from, TypePtr to) {
if (!from->m_kindOf) return true;
// since both 'from' and 'to' represent sets of types, we do
// this by computing the set of types that we could possibly cast 'from'
// to, and then determining whether that overlaps with 'to'.
int canCastTo = KindOfBoolean | from->m_kindOf;
if (from->m_kindOf & KindOfVoid) canCastTo |= KindOfVoid;
// Boolean, Numeric, and String can all be cast among each other
if (from->m_kindOf & (KindOfBoolean | KindOfNumeric | KindOfString)) {
canCastTo |= KindOfNumeric | KindOfString;
}
if (from->m_kindOf & KindOfObject) {
// Objects can only cast to string if they have __tostring
if (from->m_name.empty()) {
canCastTo |= KindOfString; // we don't know which class it is
} else {
ClassScopePtr cls = ar->findClass(from->m_name);
if (!cls || cls->isRedeclaring() ||
cls->findFunction(ar, "__tostring", true)) {
canCastTo |= KindOfString;
}
}
// can only cast between objects if there's a subclass relation
if ((to->m_kindOf & KindOfObject) && !to->m_name.empty() &&
!from->m_name.empty() && to->m_name != from->m_name) {
ClassScopePtr cls = ar->findClass(from->m_name);
if (cls && (cls->isRedeclaring() ||
!cls->derivesFrom(ar, to->m_name, true, true))) {
canCastTo &= ~KindOfObject;
}
}
}
bool overlap = (to->m_kindOf & canCastTo);
return overlap;
}
ClassScopePtr ConstantTable::findParent(AnalysisResultConstPtr ar,
const std::string &name) {
for (ClassScopePtr parent = m_blockScope.getParentScope(ar);
parent && !parent->isRedeclaring();
parent = parent->getParentScope(ar)) {
if (parent->hasConst(name)) {
return parent;
}
}
return ClassScopePtr();
}
ClassScopePtr AnalysisResult::findExactClass(ConstructPtr cs,
const std::string &name) const {
ClassScopePtr cls = findClass(name);
if (!cls || !cls->isRedeclaring()) return cls;
if (ClassScopePtr currentCls = cs->getClassScope()) {
if (cls->isNamed(currentCls->getScopeName())) {
return currentCls;
}
}
return ClassScopePtr();
}
ClassScopePtr Type::getClass(AnalysisResultPtr ar, BlockScopeRawPtr scope) {
if (m_name.empty()) return ClassScopePtr();
ClassScopePtr cls = ar->findClass(m_name);
if (cls->isRedeclaring()) {
if (!scope) {
cls.reset();
} else {
cls = scope->findExactClass(Util::toLower(m_name));
}
}
return cls;
}
ClassScopePtr VariableTable::findParent(AnalysisResultConstPtr ar,
const string &name,
const Symbol *&sym) const {
sym = nullptr;
for (ClassScopePtr parent = m_blockScope.getParentScope(ar);
parent && !parent->isRedeclaring();
parent = parent->getParentScope(ar)) {
sym = parent->getVariables()->getSymbol(name);
assert(!sym || sym->isPresent());
if (sym) return parent;
}
return ClassScopePtr();
}
void SimpleVariable::analyzeProgram(AnalysisResultPtr ar) {
m_superGlobal = BuiltinSymbols::IsSuperGlobal(m_name);
m_superGlobalType = BuiltinSymbols::GetSuperGlobalType(m_name);
VariableTablePtr variables = getScope()->getVariables();
if (m_superGlobal) {
variables->setAttribute(VariableTable::NeedGlobalPointer);
} else if (m_name == "GLOBALS") {
m_globals = true;
} else {
m_sym = variables->addSymbol(m_name);
}
if (ar->getPhase() == AnalysisResult::AnalyzeAll) {
if (FunctionScopePtr func = getFunctionScope()) {
if (m_name == "this" && getClassScope()) {
func->setContainsThis();
m_this = true;
if (!hasContext(ObjectContext)) {
func->setContainsBareThis();
if (variables->getAttribute(VariableTable::ContainsDynamicVariable)) {
ClassScopePtr cls = getClassScope();
TypePtr t = cls->isRedeclaring() ?
Type::Variant : Type::CreateObjectType(cls->getName());
variables->add(m_sym, t, true, ar, shared_from_this(),
getScope()->getModifiers());
}
}
}
if (m_sym && !(m_context & AssignmentLHS) &&
!((m_context & UnsetContext) && (m_context & LValue))) {
m_sym->setUsed();
}
}
} else if (ar->getPhase() == AnalysisResult::AnalyzeFinal) {
if (m_sym && !m_sym->isSystem() &&
!(getContext() &
(LValue|RefValue|RefParameter|UnsetContext|ExistContext)) &&
m_sym->getDeclaration().get() == this &&
!variables->getAttribute(VariableTable::ContainsLDynamicVariable) &&
!getScope()->is(BlockScope::ClassScope)) {
if (getScope()->inPseudoMain()) {
Compiler::Error(Compiler::UseUndeclaredGlobalVariable,
shared_from_this());
} else {
Compiler::Error(Compiler::UseUndeclaredVariable, shared_from_this());
}
}
}
}
void MethodStatement::outputCPPTypeCheckWrapper(CodeGenerator &cg,
AnalysisResultPtr ar) {
FunctionScopePtr funcScope = getFunctionScope();
TypePtr type = funcScope->getReturnType();
bool isMethod = getClassScope();
string fname = isMethod ? funcScope->getName() : funcScope->getId(cg);
funcScope->outputCPP(cg, ar);
cg_printf("%s%s%s(", type ? "return " : "",
(isMethod ? (m_modifiers->isStatic() ?
Option::TypedMethodImplPrefix :
Option::TypedMethodPrefix) :
Option::TypedFunctionPrefix),
fname.c_str());
if (getClassScope() && m_modifiers->isStatic()) {
cg_printf("cls, ");
}
if (funcScope->isVariableArgument()) {
cg_printf("num_args, ");
}
assert(m_params);
for (int i = 0; i < m_params->getCount(); i++) {
ParameterExpressionPtr param =
dynamic_pointer_cast<ParameterExpression>((*m_params)[i]);
ASSERT(param);
if (i) cg_printf(", ");
cg_printf("%s%s", Option::VariablePrefix,
param->getName().c_str());
if (TypePtr spec = funcScope->getParamTypeSpec(i)) {
if (Type::SameType(spec, funcScope->getParamType(i))) {
if (spec->is(Type::KindOfArray)) {
cg_printf(".getArrayData()");
} else {
ClassScopePtr cls = ar->findClass(spec->getName());
assert(cls && !cls->isRedeclaring());
cg_printf(".getObjectData()");
}
}
}
}
if (funcScope->isVariableArgument()) {
cg_printf(", args");
}
cg_printf(");\n");
}
bool ClassScope::needsInvokeParent(AnalysisResultConstPtr ar,
bool considerSelf /* = true */) {
// check all functions this class has
if (considerSelf) {
for (const auto& func : m_functionsVec) {
if (func->isPrivate()) return true;
}
}
// walk up
if (!m_parent.empty()) {
ClassScopePtr super = ar->findClass(m_parent);
return !super || super->isRedeclaring() || super->needsInvokeParent(ar);
}
return false;
}
bool ClassScope::needsInvokeParent(AnalysisResultConstPtr ar,
bool considerSelf /* = true */) {
// check all functions this class has
if (considerSelf) {
for (FunctionScopePtrVec::const_iterator iter =
m_functionsVec.begin(); iter != m_functionsVec.end(); ++iter) {
if ((*iter)->isPrivate()) return true;
}
}
// walk up
if (!m_parent.empty()) {
ClassScopePtr super = ar->findClass(m_parent);
return !super || super->isRedeclaring() || super->needsInvokeParent(ar);
}
return false;
}
bool ClassScope::derivesFrom(AnalysisResultConstPtr ar,
const std::string &base,
bool strict, bool def) const {
if (derivesDirectlyFrom(base)) return true;
for (std::string base_i: m_bases) {
ClassScopePtr cl = ar->findClass(base_i);
if (cl) {
if (strict && cl->isRedeclaring()) {
if (def) return true;
continue;
}
if (cl->derivesFrom(ar, base, strict, def)) return true;
}
}
return false;
}
ClassScopePtr StaticClassName::resolveClass() {
m_present = false;
m_unknown = true;
if (m_class) return ClassScopePtr();
BlockScopeRawPtr scope = originalScope(this);
if (m_self) {
if (ClassScopePtr self = scope->getContainingClass()) {
m_className = self->getName();
m_origClassName = self->getOriginalName();
m_present = true;
m_unknown = false;
return self;
}
} else if (m_parent) {
if (ClassScopePtr self = scope->getContainingClass()) {
if (!self->getOriginalParent().empty()) {
m_className = Util::toLower(self->getOriginalParent());
m_origClassName = self->getOriginalParent();
m_present = true;
}
} else {
m_parent = false;
}
}
ClassScopePtr cls = scope->getContainingProgram()->findClass(m_className);
if (cls) {
m_unknown = false;
if (cls->isVolatile()) {
ClassScopeRawPtr c = scope->getContainingFile()->resolveClass(cls);
if (!c) {
c = scope->getContainingClass();
if (c && c->getName() != m_className) c.reset();
}
m_present = c.get() != 0;
if (cls->isRedeclaring()) {
cls = c;
if (!m_present) m_redeclared = true;
}
} else {
m_present = true;
}
}
return cls;
}
TypePtr ParameterExpression::getTypeSpecForClass(AnalysisResultPtr ar,
bool forInference) {
TypePtr ret;
if (forInference) {
ClassScopePtr cls = ar->findClass(m_type);
if (!cls || cls->isRedeclaring() || cls->derivedByDynamic()) {
if (!cls && getScope()->isFirstPass()) {
ConstructPtr self = shared_from_this();
Compiler::Error(Compiler::UnknownClass, self);
}
ret = Type::Variant;
}
}
if (!ret) {
ret = Type::CreateObjectType(m_type);
}
always_assert(ret);
return ret;
}
bool MethodStatement::outputFFI(CodeGenerator &cg, AnalysisResultPtr ar) {
FunctionScopePtr funcScope = m_funcScope.lock();
ClassScopePtr clsScope = ar->getClassScope();
bool pseudoMain = funcScope->inPseudoMain();
bool inClass = !m_className.empty();
// only expose public methods, and ignore those in redeclared classes
bool inaccessible =
inClass && (!m_modifiers->isPublic() || clsScope->isRedeclaring());
// skip constructors
bool isConstructor = inClass && funcScope->isConstructor(clsScope);
bool valid = !pseudoMain && !inaccessible && !isConstructor;
if (cg.getContext() == CodeGenerator::CppFFIDecl ||
cg.getContext() == CodeGenerator::CppFFIImpl) {
if (valid) outputCPPFFIStub(cg, ar);
return true;
}
if (cg.getContext() == CodeGenerator::HsFFI) {
if (valid) outputHSFFIStub(cg, ar);
return true;
}
if (cg.getContext() == CodeGenerator::JavaFFI
|| cg.getContext() == CodeGenerator::JavaFFIInterface) {
if (valid) outputJavaFFIStub(cg, ar);
return true;
}
if (cg.getContext() == CodeGenerator::JavaFFICppDecl
|| cg.getContext() == CodeGenerator::JavaFFICppImpl) {
if (valid) outputJavaFFICPPStub(cg, ar);
return true;
}
if (cg.getContext() == CodeGenerator::SwigFFIDecl
|| cg.getContext() == CodeGenerator::SwigFFIImpl) {
if (valid) outputSwigFFIStub(cg, ar);
return true;
}
return false;
}
TypePtr ClassConstantExpression::inferTypes(AnalysisResultPtr ar,
TypePtr type, bool coerce) {
m_valid = false;
ConstructPtr self = shared_from_this();
ClassScopePtr cls = ar->resolveClass(m_className);
if (!cls || cls->isRedeclaring()) {
if (cls) {
m_redeclared = true;
ar->getScope()->getVariables()->
setAttribute(VariableTable::NeedGlobalPointer);
}
if (!cls && ar->isFirstPass()) {
ar->getCodeError()->record(self, CodeError::UnknownClass, self);
}
return type;
}
if (cls->getConstants()->isDynamic(m_varName)) {
ar->getScope()->getVariables()->
setAttribute(VariableTable::NeedGlobalPointer);
}
if (cls->getConstants()->isExplicitlyDeclared(m_varName)) {
string name = m_className + "::" + m_varName;
ConstructPtr decl = cls->getConstants()->getDeclaration(m_varName);
if (decl) { // No decl means an extension class.
ar->getDependencyGraph()->add(DependencyGraph::KindOfConstant,
ar->getName(),
name, shared_from_this(), name, decl);
}
m_valid = true;
}
bool present;
TypePtr t = cls->checkConst(m_varName, type, coerce, ar,
shared_from_this(), present);
if (present) {
m_valid = true;
}
return t;
}
ExpressionPtr ClassConstantExpression::preOptimize(AnalysisResultPtr ar) {
if (ar->getPhase() < AnalysisResult::FirstPreOptimize) {
return ExpressionPtr();
}
if (m_redeclared) return ExpressionPtr();
ClassScopePtr cls = ar->resolveClass(m_className);
if (!cls || cls->isRedeclaring()) return ExpressionPtr();
ConstantTablePtr constants = cls->getConstants();
if (constants->isExplicitlyDeclared(m_varName)) {
ConstructPtr decl = constants->getValue(m_varName);
if (decl) {
ExpressionPtr value = dynamic_pointer_cast<Expression>(decl);
if (!m_visited) {
m_visited = true;
ar->pushScope(cls);
ExpressionPtr optExp = value->preOptimize(ar);
ar->popScope();
m_visited = false;
if (optExp) value = optExp;
}
if (value->isScalar()) {
// inline the value
if (value->is(Expression::KindOfScalarExpression)) {
ScalarExpressionPtr exp =
dynamic_pointer_cast<ScalarExpression>(Clone(value));
exp->setComment(getText());
return exp;
} else if (value->is(Expression::KindOfConstantExpression)) {
// inline the value
ConstantExpressionPtr exp =
dynamic_pointer_cast<ConstantExpression>(Clone(value));
exp->setComment(getText());
return exp;
}
}
}
}
return ExpressionPtr();
}
TypePtr ConstantTable::checkBases(const std::string &name, TypePtr type,
bool coerce, AnalysisResultConstPtr ar,
ConstructPtr construct,
const std::vector<std::string> &bases,
BlockScope *&defScope) {
TypePtr actualType;
defScope = NULL;
ClassScopePtr parent = findParent(ar, name);
if (parent) {
actualType = parent->checkConst(name, type, coerce, ar, construct,
parent->getBases(), defScope);
if (defScope) return actualType;
}
for (int i = bases.size() - 1; i >= (parent ? 1 : 0); i--) {
const string &base = bases[i];
ClassScopePtr super = ar->findClass(base);
if (!super || super->isRedeclaring()) continue;
actualType = super->checkConst(name, type, coerce, ar, construct,
super->getBases(), defScope);
if (defScope) return actualType;
}
return actualType;
}
void MethodStatement::outputCPPImpl(CodeGenerator &cg, AnalysisResultPtr ar) {
FunctionScopePtr funcScope = m_funcScope.lock();
ClassScopePtr scope = getClassScope();
if (outputFFI(cg, ar)) return;
cg.setPHPLineNo(-1);
CodeGenerator::Context context = cg.getContext();
if (context == CodeGenerator::CppImplementation) {
printSource(cg);
}
bool isWrapper = context == CodeGenerator::CppTypedParamsWrapperDecl ||
context == CodeGenerator::CppTypedParamsWrapperImpl;
bool needsWrapper = isWrapper ||
(Option::HardTypeHints && funcScope->needsTypeCheckWrapper());
const char *prefix = needsWrapper && !isWrapper ?
Option::TypedMethodPrefix : Option::MethodPrefix;
switch (context) {
case CodeGenerator::CppDeclaration:
case CodeGenerator::CppTypedParamsWrapperDecl:
{
if (!m_stmt && !funcScope->isPerfectVirtual()) {
cg_printf("// ");
}
m_modifiers->outputCPP(cg, ar);
if (!m_stmt || m_name == "__offsetget_lval" ||
funcScope->isPerfectVirtual()) {
cg_printf("virtual ");
}
TypePtr type = funcScope->getReturnType();
if (type) {
type->outputCPPDecl(cg, ar);
} else {
cg_printf("void");
}
if (m_name == "__offsetget_lval") {
cg_printf(" &___offsetget_lval(");
} else if (m_modifiers->isStatic() && m_stmt) {
// Static method wrappers get generated as support methods
cg_printf(" %s%s(CStrRef cls%s",
needsWrapper && !isWrapper ?
Option::TypedMethodImplPrefix : Option::MethodImplPrefix,
cg.formatLabel(m_name).c_str(),
funcScope->isVariableArgument() ||
(m_params && m_params->getCount()) ? ", " : "");
} else {
cg_printf(" %s%s(", prefix, cg.formatLabel(m_name).c_str());
}
funcScope->outputCPPParamsDecl(cg, ar, m_params, true);
if (m_stmt) {
cg_printf(");\n");
} else if (funcScope->isPerfectVirtual()) {
cg_printf(") { return throw_fatal(\"pure virtual\");}\n");
} else {
cg_printf(") = 0;\n");
}
if (context != CodeGenerator::CppTypedParamsWrapperDecl) {
if (funcScope->isConstructor(scope)
&& !funcScope->isAbstract() && !scope->isInterface()) {
funcScope->outputCPPCreateDecl(cg, ar);
}
if (Option::HardTypeHints && funcScope->needsTypeCheckWrapper()) {
cg.setContext(CodeGenerator::CppTypedParamsWrapperDecl);
outputCPPImpl(cg, ar);
cg.setContext(context);
}
}
}
break;
case CodeGenerator::CppImplementation:
case CodeGenerator::CppTypedParamsWrapperImpl:
if (m_stmt) {
TypePtr type = funcScope->getReturnType();
if (type) {
type->outputCPPDecl(cg, ar);
} else {
cg_printf("void");
}
string origFuncName = getOriginalFullName();
string funcSection = Option::FunctionSections[origFuncName];
if (!funcSection.empty()) {
cg_printf(" __attribute__ ((section (\".text.%s\")))",
funcSection.c_str());
}
if (m_name == "__offsetget_lval") {
cg_printf(" &%s%s::___offsetget_lval(",
Option::ClassPrefix, scope->getId(cg).c_str());
} else if (m_modifiers->isStatic()) {
cg_printf(" %s%s::%s%s(CStrRef cls%s", Option::ClassPrefix,
scope->getId(cg).c_str(),
needsWrapper && !isWrapper ?
Option::TypedMethodImplPrefix : Option::MethodImplPrefix,
cg.formatLabel(m_name).c_str(),
funcScope->isVariableArgument() ||
(m_params && m_params->getCount()) ? ", " : "");
} else {
cg_printf(" %s%s::%s%s(", Option::ClassPrefix,
scope->getId(cg).c_str(),
prefix, cg.formatLabel(m_name).c_str());
}
funcScope->outputCPPParamsDecl(cg, ar, m_params, false);
cg_indentBegin(") {\n");
if (context != CodeGenerator::CppTypedParamsWrapperImpl) {
if (m_stmt->hasBody()) {
const char *sys =
(cg.getOutput() == CodeGenerator::SystemCPP ? "_BUILTIN" : "");
if (m_modifiers->isStatic()) {
cg_printf("STATIC_METHOD_INJECTION%s(%s, %s);\n", sys,
scope->getOriginalName().c_str(), origFuncName.c_str());
} else if (cg.getOutput() != CodeGenerator::SystemCPP &&
!scope->isRedeclaring() && !scope->derivedByDynamic()) {
cg_printf("INSTANCE_METHOD_INJECTION_ROOTLESS(%s, %s);\n",
scope->getOriginalName().c_str(), origFuncName.c_str());
} else {
cg_printf("INSTANCE_METHOD_INJECTION%s(%s, %s);\n", sys,
scope->getOriginalName().c_str(), origFuncName.c_str());
}
}
outputCPPArgInjections(cg, ar, origFuncName.c_str(),
scope, funcScope);
if (m_name == "__offsetget_lval") {
ParameterExpressionPtr param =
dynamic_pointer_cast<ParameterExpression>((*m_params)[0]);
cg_printf("Variant &v = %s->__lvalProxy;\n", cg.getGlobals(ar));
string lowered = Util::toLower(m_originalName);
cg_printf("v = %s%s(%s%s);\n",
prefix, lowered.c_str(),
Option::VariablePrefix, param->getName().c_str());
cg_printf("return v;\n");
} else {
if (funcScope->isConstructor(scope)) {
cg_printf("bool oldInCtor = gasInCtor(true);\n");
} else if (m_name == "__destruct") {
cg_printf("setInDtor();\n");
}
funcScope->outputCPP(cg, ar);
cg.setContext(
CodeGenerator::NoContext); // no inner functions/classes
if (!funcScope->isStatic() && funcScope->getVariables()->
getAttribute(VariableTable::ContainsDynamicVariable)) {
cg_printf("%sthis = this;\n", Option::VariablePrefix);
}
outputCPPStmt(cg, ar);
}
cg_indentEnd("}\n");
if (Option::HardTypeHints && funcScope->needsTypeCheckWrapper()) {
cg.setContext(CodeGenerator::CppTypedParamsWrapperImpl);
outputCPPImpl(cg, ar);
}
} else {
outputCPPTypeCheckWrapper(cg, ar);
cg_indentEnd("}\n");
}
cg.setContext(context);
cg.printImplSplitter();
}
break;
default:
break;
}
}
void ClassStatement::outputCPPImpl(CodeGenerator &cg, AnalysisResultPtr ar) {
ClassScopePtr classScope = m_classScope.lock();
if (cg.getContext() == CodeGenerator::NoContext) {
if (classScope->isRedeclaring()) {
cg_printf("g->%s%s = ClassStaticsPtr(NEW(%s%s)());\n",
Option::ClassStaticsObjectPrefix,
cg.formatLabel(m_name).c_str(),
Option::ClassStaticsPrefix, classScope->getId(cg).c_str());
cg_printf("g->%s%s = &%s%s;\n",
Option::ClassStaticsCallbackPrefix,
cg.formatLabel(m_name).c_str(),
Option::ClassWrapperFunctionPrefix,
classScope->getId(cg).c_str());
}
if (classScope->isVolatile()) {
cg_printf("g->CDEC(%s) = true;\n", m_name.c_str());
}
const vector<string> &bases = classScope->getBases();
for (vector<string>::const_iterator it = bases.begin();
it != bases.end(); ++it) {
ClassScopePtr base = ar->findClass(*it);
if (base && base->isVolatile()) {
cg_printf("checkClassExists(\"%s\", g);\n",
base->getOriginalName().c_str());
}
}
return;
}
if (cg.getContext() != CodeGenerator::CppForwardDeclaration) {
printSource(cg);
}
ar->pushScope(classScope);
string clsNameStr = classScope->getId(cg);
const char *clsName = clsNameStr.c_str();
bool redeclared = classScope->isRedeclaring();
switch (cg.getContext()) {
case CodeGenerator::CppForwardDeclaration:
if (Option::GenerateCPPMacros) {
cg_printf("FORWARD_DECLARE_CLASS(%s)\n", clsName);
if (redeclared) {
cg_printf("FORWARD_DECLARE_REDECLARED_CLASS(%s)\n", clsName);
}
}
if (m_stmt) {
cg.setContext(CodeGenerator::CppClassConstantsDecl);
m_stmt->outputCPP(cg, ar);
cg.setContext(CodeGenerator::CppForwardDeclaration);
}
break;
case CodeGenerator::CppDeclaration:
{
bool system = cg.getOutput() == CodeGenerator::SystemCPP;
ClassScopePtr parCls;
if (!m_parent.empty()) {
parCls = ar->findClass(m_parent);
if (parCls && parCls->isRedeclaring()) parCls.reset();
}
cg_printf("class %s%s", Option::ClassPrefix, clsName);
if (!m_parent.empty() && classScope->derivesDirectlyFrom(ar, m_parent)) {
if (!parCls) {
cg_printf(" : public DynamicObjectData");
} else {
cg_printf(" : public %s%s", Option::ClassPrefix,
parCls->getId(cg).c_str());
}
} else {
if (classScope->derivesFromRedeclaring()) {
cg_printf(" : public DynamicObjectData");
} else if (system) {
cg_printf(" : public ExtObjectData");
} else {
cg_printf(" : public ObjectData");
}
}
if (m_base && Option::UseVirtualDispatch) {
for (int i = 0; i < m_base->getCount(); i++) {
ScalarExpressionPtr exp =
dynamic_pointer_cast<ScalarExpression>((*m_base)[i]);
const char *intf = exp->getString().c_str();
ClassScopePtr intfClassScope = ar->findClass(intf);
if (intfClassScope && !intfClassScope->isRedeclaring() &&
classScope->derivesDirectlyFrom(ar, intf) &&
(!parCls || !parCls->derivesFrom(ar, intf, true, false))) {
string id = intfClassScope->getId(cg);
cg_printf(", public %s%s", Option::ClassPrefix, id.c_str());
}
}
}
cg_indentBegin(" {\n");
if (Option::GenerateCPPMacros) {
// Get all of this class's ancestors
vector<string> bases;
getAllParents(ar, bases);
// Eliminate duplicates
sort(bases.begin(), bases.end());
bases.erase(unique(bases.begin(), bases.end()), bases.end());
cg_indentBegin("BEGIN_CLASS_MAP(%s)\n",
Util::toLower(classScope->getName()).c_str());
for (unsigned int i = 0; i < bases.size(); i++) {
cg_printf("PARENT_CLASS(%s)\n", bases[i].c_str());
}
if (classScope->derivesFromRedeclaring()) {
cg_printf("CLASS_MAP_REDECLARED()\n");
}
cg_indentEnd("END_CLASS_MAP(%s)\n", clsName);
}
if (Option::GenerateCPPMacros) {
bool dyn = (!parCls && !m_parent.empty()) ||
classScope->derivesFromRedeclaring() ==
ClassScope::DirectFromRedeclared;
bool idyn = parCls && classScope->derivesFromRedeclaring() ==
ClassScope::IndirectFromRedeclared;
bool redec = classScope->isRedeclaring();
if (!classScope->derivesFromRedeclaring()) {
outputCPPClassDecl(cg, ar, clsName, m_originalName.c_str(),
parCls ? parCls->getId(cg).c_str() : "ObjectData");
} else {
cg_printf("DECLARE_DYNAMIC_CLASS(%s, %s, %s)\n", clsName,
m_originalName.c_str(),
dyn || !parCls ? "DynamicObjectData" :
parCls->getId(cg).c_str());
}
if (system || Option::EnableEval >= Option::LimitedEval) {
cg_printf("DECLARE_INVOKES_FROM_EVAL\n");
}
if (dyn || idyn || redec) {
if (redec) {
cg_printf("DECLARE_ROOT;\n");
if (!dyn && !idyn) {
cg_printf("private: ObjectData* root;\n");
cg_printf("public:\n");
cg_printf("virtual ObjectData *getRoot() { return root; }\n");
}
}
string conInit = ":";
if (dyn) {
conInit += "DynamicObjectData(\"" + m_parent + "\", r)";
} else if (idyn) {
conInit += string(Option::ClassPrefix) + parCls->getId(cg) +
"(r?r:this)";
} else {
conInit += "root(r?r:this)";
}
cg_printf("%s%s(ObjectData* r = NULL)%s {}\n",
Option::ClassPrefix, clsName,
conInit.c_str());
}
}
cg_printf("void init();\n",
Option::ClassPrefix, clsName);
if (classScope->needLazyStaticInitializer()) {
cg_printf("static GlobalVariables *lazy_initializer"
"(GlobalVariables *g);\n");
}
classScope->getVariables()->outputCPPPropertyDecl(cg, ar,
classScope->derivesFromRedeclaring());
if (!classScope->getAttribute(ClassScope::HasConstructor)) {
FunctionScopePtr func = classScope->findFunction(ar, "__construct",
false);
if (func && !func->isAbstract() && !classScope->isInterface()) {
ar->pushScope(func);
func->outputCPPCreateDecl(cg, ar);
ar->popScope();
}
}
if (classScope->getAttribute(ClassScope::HasDestructor)) {
cg_printf("public: virtual void destruct();\n");
}
// doCall
if (classScope->getAttribute(ClassScope::HasUnknownMethodHandler)) {
cg_printf("Variant doCall(Variant v_name, Variant v_arguments, "
"bool fatal);\n");
}
// doGet
if (classScope->getAttribute(ClassScope::HasUnknownPropHandler)) {
cg_printf("Variant doGet(Variant v_name, bool error);\n");
}
if (classScope->isRedeclaring() &&
!classScope->derivesFromRedeclaring()) {
cg_printf("Variant doRootCall(Variant v_name, Variant v_arguments, "
"bool fatal);\n");
}
if (m_stmt) m_stmt->outputCPP(cg, ar);
{
set<string> done;
classScope->outputCPPStaticMethodWrappers(cg, ar, done, clsName);
}
if (cg.getOutput() == CodeGenerator::SystemCPP &&
ar->isBaseSysRsrcClass(clsName) &&
!classScope->hasProperty("rsrc")) {
cg_printf("public: Variant %srsrc;\n", Option::PropertyPrefix);
}
cg_indentEnd("};\n");
if (redeclared) {
cg_indentBegin("class %s%s : public ClassStatics {\n",
Option::ClassStaticsPrefix, clsName);
cg_printf("public:\n");
cg_printf("DECLARE_OBJECT_ALLOCATION(%s%s);\n",
Option::ClassStaticsPrefix, clsName);
cg_printf("%s%s() : ClassStatics(%d) {}\n",
Option::ClassStaticsPrefix, clsName,
classScope->getRedeclaringId());
cg_indentBegin("Variant %sgetInit(const char *s, int64 hash = -1) {\n",
Option::ObjectStaticPrefix);
cg_printf("return %s%s::%sgetInit(s, hash);\n", Option::ClassPrefix,
clsName, Option::ObjectStaticPrefix);
cg_indentEnd("}\n");
cg_indentBegin("Variant %sget(const char *s, int64 hash = -1) {\n",
Option::ObjectStaticPrefix);
cg_printf("return %s%s::%sget(s, hash);\n", Option::ClassPrefix,
clsName, Option::ObjectStaticPrefix);
cg_indentEnd("}\n");
cg_indentBegin("Variant &%slval(const char* s, int64 hash = -1) {\n",
Option::ObjectStaticPrefix);
cg_printf("return %s%s::%slval(s, hash);\n", Option::ClassPrefix,
clsName, Option::ObjectStaticPrefix);
cg_indentEnd("}\n");
cg_indentBegin("Variant %sinvoke(const char *c, const char *s, "
"CArrRef params, int64 hash = -1, bool fatal = true) "
"{\n",
Option::ObjectStaticPrefix);
cg_printf("return %s%s::%sinvoke(c, s, params, hash, fatal);\n",
Option::ClassPrefix, clsName,
Option::ObjectStaticPrefix);
cg_indentEnd("}\n");
cg_indentBegin("Object create(CArrRef params, bool init = true, "
"ObjectData* root = NULL) {\n");
cg_printf("return Object((NEW(%s%s)(root))->"
"dynCreate(params, init));\n",
Option::ClassPrefix, clsName);
cg_indentEnd("}\n");
cg_indentBegin("Variant %sconstant(const char* s) {\n",
Option::ObjectStaticPrefix);
cg_printf("return %s%s::%sconstant(s);\n", Option::ClassPrefix,
clsName, Option::ObjectStaticPrefix);
cg_indentEnd("}\n");
cg_indentBegin("Variant %sinvoke_from_eval(const char *c, "
"const char *s, Eval::VariableEnvironment &env, "
"const Eval::FunctionCallExpression *call, "
"int64 hash = -1, bool fatal = true) "
"{\n",
Option::ObjectStaticPrefix);
cg_printf("return %s%s::%sinvoke_from_eval(c, s, env, call, hash, "
"fatal);\n",
Option::ClassPrefix, clsName,
Option::ObjectStaticPrefix);
cg_indentEnd("}\n");
cg_indentEnd("};\n");
}
classScope->outputCPPGlobalTableWrappersDecl(cg, ar);
}
break;
case CodeGenerator::CppImplementation:
if (m_stmt) {
cg.setContext(CodeGenerator::CppClassConstantsImpl);
m_stmt->outputCPP(cg, ar);
cg.setContext(CodeGenerator::CppImplementation);
}
classScope->outputCPPSupportMethodsImpl(cg, ar);
if (redeclared) {
cg_printf("IMPLEMENT_OBJECT_ALLOCATION(%s%s);\n",
Option::ClassStaticsPrefix, clsName);
}
cg_indentBegin("void %s%s::init() {\n",
Option::ClassPrefix, clsName);
if (!m_parent.empty()) {
if (classScope->derivesFromRedeclaring() ==
ClassScope::DirectFromRedeclared) {
cg_printf("parent->init();\n");
} else {
cg_printf("%s%s::init();\n", Option::ClassPrefix, m_parent.c_str());
}
}
if (classScope->getVariables()->
getAttribute(VariableTable::NeedGlobalPointer)) {
cg.printDeclareGlobals();
}
cg.setContext(CodeGenerator::CppConstructor);
if (m_stmt) m_stmt->outputCPP(cg, ar);
// This is lame. Exception base class needs to prepare stacktrace outside
// of its PHP constructor. Every subclass of exception also needs this
// stacktrace, so we're adding an artificial __init__ in exception.php
// and calling it here.
if (m_name == "exception") {
cg_printf("{CountableHelper h(this); t___init__();}\n");
}
cg_indentEnd("}\n");
if (classScope->needStaticInitializer()) {
cg_indentBegin("void %s%s::os_static_initializer() {\n",
Option::ClassPrefix, clsName);
cg.printDeclareGlobals();
cg.setContext(CodeGenerator::CppStaticInitializer);
if (m_stmt) m_stmt->outputCPP(cg, ar);
cg_indentEnd("}\n");
cg_indentBegin("void %s%s() {\n",
Option::ClassStaticInitializerPrefix, clsName);
cg_printf("%s%s::os_static_initializer();\n", Option::ClassPrefix,
clsName);
cg_indentEnd("}\n");
}
if (classScope->needLazyStaticInitializer()) {
cg_indentBegin("GlobalVariables *%s%s::lazy_initializer("
"GlobalVariables *g) {\n", Option::ClassPrefix, clsName);
cg_indentBegin("if (!g->%s%s) {\n",
Option::ClassStaticInitializerFlagPrefix, clsName);
cg_printf("g->%s%s = true;\n", Option::ClassStaticInitializerFlagPrefix,
clsName);
cg.setContext(CodeGenerator::CppLazyStaticInitializer);
if (m_stmt) m_stmt->outputCPP(cg, ar);
cg_indentEnd("}\n");
cg_printf("return g;\n");
cg_indentEnd("}\n");
}
cg.setContext(CodeGenerator::CppImplementation);
if (m_stmt) m_stmt->outputCPP(cg, ar);
break;
case CodeGenerator::CppFFIDecl:
case CodeGenerator::CppFFIImpl:
if (m_stmt) m_stmt->outputCPP(cg, ar);
break;
case CodeGenerator::JavaFFI:
{
if (classScope->isRedeclaring()) break;
// TODO support PHP namespaces, once HPHP supports it
string packageName = Option::JavaFFIRootPackage;
string packageDir = packageName;
Util::replaceAll(packageDir, ".", "/");
string outputDir = ar->getOutputPath() + "/" + Option::FFIFilePrefix +
packageDir + "/";
Util::mkdir(outputDir);
// uses a different cg to generate a separate file for each PHP class
// also, uses the original capitalized class name
string clsFile = outputDir + getOriginalName() + ".java";
ofstream fcls(clsFile.c_str());
CodeGenerator cgCls(&fcls, CodeGenerator::FileCPP);
cgCls.setContext(CodeGenerator::JavaFFI);
cgCls.printf("package %s;\n\n", packageName.c_str());
cgCls.printf("import hphp.*;\n\n");
printSource(cgCls);
string clsModifier;
switch (m_type) {
case T_CLASS:
break;
case T_ABSTRACT:
clsModifier = "abstract ";
break;
case T_FINAL:
clsModifier = "final ";
break;
}
cgCls.printf("public %sclass %s ", clsModifier.c_str(),
getOriginalName().c_str());
ClassScopePtr parCls;
if (!m_parent.empty()) parCls = ar->findClass(m_parent);
if (!m_parent.empty() && classScope->derivesDirectlyFrom(ar, m_parent)
&& parCls && parCls->isUserClass() && !parCls->isRedeclaring()) {
// system classes are not supported in static FFI translation
// they shouldn't appear as superclasses as well
cgCls.printf("extends %s", parCls->getOriginalName().c_str());
}
else {
cgCls.printf("extends HphpObject");
}
if (m_base) {
bool first = true;
for (int i = 0; i < m_base->getCount(); i++) {
ScalarExpressionPtr exp =
dynamic_pointer_cast<ScalarExpression>((*m_base)[i]);
const char *intf = exp->getString().c_str();
ClassScopePtr intfClassScope = ar->findClass(intf);
if (intfClassScope && classScope->derivesFrom(ar, intf, false, false)
&& intfClassScope->isUserClass()) {
if (first) {
cgCls.printf(" implements ");
first = false;
}
else {
cgCls.printf(", ");
}
cgCls.printf(intfClassScope->getOriginalName().c_str());
}
}
}
cgCls.indentBegin(" {\n");
// constructor for initializing the variant pointer
cgCls.printf("protected %s(long ptr) { super(ptr); }\n\n",
getOriginalName().c_str());
FunctionScopePtr cons = classScope->findConstructor(ar, true);
if (cons && !cons->isAbstract() || m_type != T_ABSTRACT) {
// if not an abstract class and not having an explicit constructor,
// adds a default constructor
outputJavaFFIConstructor(cgCls, ar, cons);
}
if (m_stmt) m_stmt->outputCPP(cgCls, ar);
cgCls.indentEnd("}\n");
fcls.close();
}
break;
case CodeGenerator::JavaFFICppDecl:
case CodeGenerator::JavaFFICppImpl:
{
if (classScope->isRedeclaring()) break;
if (m_stmt) m_stmt->outputCPP(cg, ar);
FunctionScopePtr cons = classScope->findConstructor(ar, true);
if (cons && !cons->isAbstract() || m_type != T_ABSTRACT) {
outputJavaFFICPPCreator(cg, ar, cons);
}
}
break;
default:
ASSERT(false);
break;
}
ar->popScope();
}
void SimpleVariable::analyzeProgram(AnalysisResultPtr ar) {
m_superGlobal = BuiltinSymbols::IsSuperGlobal(m_name);
m_superGlobalType = BuiltinSymbols::GetSuperGlobalType(m_name);
VariableTablePtr variables = getScope()->getVariables();
if (m_superGlobal) {
variables->setAttribute(VariableTable::NeedGlobalPointer);
} else if (m_name == "GLOBALS") {
m_globals = true;
} else {
m_sym = variables->addDeclaredSymbol(m_name, shared_from_this());
}
if (ar->getPhase() == AnalysisResult::AnalyzeAll) {
if (FunctionScopePtr func = getFunctionScope()) {
if (m_name == "this" && func->mayContainThis()) {
func->setContainsThis();
m_this = true;
if (!hasContext(ObjectContext)) {
bool unset = hasAllContext(UnsetContext | LValue);
func->setContainsBareThis(
true,
hasAnyContext(RefValue | RefAssignmentLHS) ||
m_sym->isRefClosureVar() || unset);
if (variables->getAttribute(VariableTable::ContainsDynamicVariable)) {
ClassScopePtr cls = getClassScope();
TypePtr t = !cls || cls->isRedeclaring() ?
Type::Variant : Type::CreateObjectType(cls->getName());
variables->add(m_sym, t, true, ar, shared_from_this(),
getScope()->getModifiers());
}
}
}
if (m_sym && !(m_context & AssignmentLHS) &&
!((m_context & UnsetContext) && (m_context & LValue))) {
m_sym->setUsed();
}
}
} else if (ar->getPhase() == AnalysisResult::AnalyzeFinal) {
if (m_sym && !m_this) {
if (!m_sym->isSystem() &&
!(getContext() &
(LValue|RefValue|RefParameter|UnsetContext|ExistContext)) &&
m_sym->getDeclaration().get() == this) {
assert(!m_sym->isParameter());
if (!variables->getAttribute(VariableTable::ContainsLDynamicVariable) &&
!getScope()->is(BlockScope::ClassScope)) {
if (getScope()->inPseudoMain()) {
Compiler::Error(Compiler::UseUndeclaredGlobalVariable,
shared_from_this());
} else if (!m_sym->isClosureVar()) {
Compiler::Error(Compiler::UseUndeclaredVariable,
shared_from_this());
}
}
}
// check function parameter that can occur in lval context
if (m_sym->isParameter() &&
m_context & (LValue | RefValue | DeepReference |
UnsetContext | InvokeArgument | OprLValue |
DeepOprLValue)) {
m_sym->setLvalParam();
}
}
}
}
TypePtr SimpleVariable::inferAndCheck(AnalysisResultPtr ar, TypePtr type,
bool coerce) {
TypePtr ret;
ConstructPtr construct = shared_from_this();
BlockScopePtr scope = ar->getScope();
VariableTablePtr variables = scope->getVariables();
// check function parameter that can occur in lval context
if (m_context & (LValue | RefValue | UnsetContext | InvokeArgument)) {
FunctionScopePtr func = dynamic_pointer_cast<FunctionScope>(scope);
if (func) {
if (variables->isParameter(m_name)) {
variables->addLvalParam(m_name);
}
}
}
if (m_name == "this") {
ClassScopePtr cls = getOriginalScope(ar);
if (cls) {
bool isStaticFunc = false;
FunctionScopePtr func = dynamic_pointer_cast<FunctionScope>(scope);
if (func->isStatic()) isStaticFunc = true;
if (cls->isRedeclaring()) {
ret = Type::Variant;
} else {
ret = Type::CreateObjectType(cls->getName());
}
if (!isStaticFunc || (m_context & ObjectContext)) m_this = true;
}
}
if ((m_context & (LValue|Declaration)) && !(m_context & ObjectContext)) {
if (m_superGlobal) {
ret = m_superGlobalType;
} else if (m_superGlobalType) { // For system
if (!m_this) {
ret = variables->add(m_name, m_superGlobalType,
((m_context & Declaration) != Declaration), ar,
construct, scope->getModifiers());
}
} else {
if (m_globals) {
ret = Type::Variant; // this can happen with "unset($GLOBALS)"
} else if (!m_this) {
ret = variables->add(m_name, type,
((m_context & Declaration) != Declaration), ar,
construct, scope->getModifiers());
}
}
} else {
if (!m_this) {
if (m_superGlobalType) {
ret = m_superGlobalType;
} else if (m_globals) {
ret = Type::Array;
} else if (scope->is(BlockScope::ClassScope)) {
// ClassVariable expression will come to this block of code
int properties;
ret = variables->checkProperty(m_name, type, true, ar, construct,
properties);
} else {
TypePtr tmpType = type;
if (m_context & RefValue) {
tmpType = Type::Variant;
coerce = true;
}
int p;
ret = variables->checkVariable(m_name, tmpType, coerce, ar, construct,
p);
}
}
}
TypePtr actual = propagateTypes(ar, ret);
setTypes(actual, type);
if (Type::SameType(actual, ret)) {
m_implementedType.reset();
} else {
m_implementedType = ret;
}
return actual;
}
void ClassStatement::outputCPPImpl(CodeGenerator &cg, AnalysisResultPtr ar) {
ClassScopeRawPtr classScope = getClassScope();
if (cg.getContext() == CodeGenerator::NoContext) {
if (classScope->isVolatile()) {
string name = cg.formatLabel(m_name);
if (classScope->isRedeclaring()) {
cg_printf("g->%s%s = ClassStaticsPtr(NEWOBJ(%s%s)());\n",
Option::ClassStaticsObjectPrefix,
name.c_str(),
Option::ClassStaticsPrefix, classScope->getId(cg).c_str());
cg_printf("g->%s%s = &%s%s;\n",
Option::ClassStaticsCallbackPrefix,
name.c_str(),
Option::ClassWrapperFunctionPrefix,
classScope->getId(cg).c_str());
}
cg_printf("g->CDEC(%s) = true;\n", name.c_str());
const vector<string> &bases = classScope->getBases();
for (vector<string>::const_iterator it = bases.begin();
it != bases.end(); ++it) {
if (cg.checkHoistedClass(*it)) continue;
ClassScopePtr base = ar->findClass(*it);
if (base && base->isVolatile()) {
cg_printf("checkClassExists(");
cg_printString(base->getOriginalName(), ar, shared_from_this());
string lname = Util::toLower(base->getOriginalName());
cg_printf(", &%s->CDEC(%s), %s->FVF(__autoload));\n",
cg.getGlobals(ar), cg.formatLabel(lname).c_str(),
cg.getGlobals(ar));
}
}
}
return;
}
if (cg.getContext() != CodeGenerator::CppForwardDeclaration) {
printSource(cg);
}
string clsNameStr = classScope->getId(cg);
const char *clsName = clsNameStr.c_str();
bool redeclared = classScope->isRedeclaring();
switch (cg.getContext()) {
case CodeGenerator::CppDeclaration:
{
if (Option::GenerateCPPMacros) {
classScope->outputForwardDeclaration(cg);
}
bool system = cg.getOutput() == CodeGenerator::SystemCPP;
ClassScopePtr parCls;
if (!m_parent.empty()) {
parCls = ar->findClass(m_parent);
if (parCls && parCls->isRedeclaring()) parCls.reset();
}
if (Option::GenerateCppLibCode) {
cg.printDocComment(classScope->getDocComment());
}
cg_printf("class %s%s", Option::ClassPrefix, clsName);
if (!m_parent.empty() && classScope->derivesDirectlyFrom(m_parent)) {
if (!parCls) {
cg_printf(" : public DynamicObjectData");
} else {
cg_printf(" : public %s%s", Option::ClassPrefix,
parCls->getId(cg).c_str());
}
} else {
if (classScope->derivesFromRedeclaring()) {
cg_printf(" : public DynamicObjectData");
} else if (system) {
cg_printf(" : public ExtObjectData");
} else {
cg_printf(" : public ObjectData");
}
}
if (m_base && Option::UseVirtualDispatch) {
for (int i = 0; i < m_base->getCount(); i++) {
ScalarExpressionPtr exp =
dynamic_pointer_cast<ScalarExpression>((*m_base)[i]);
const char *intf = exp->getString().c_str();
ClassScopePtr intfClassScope = ar->findClass(intf);
if (intfClassScope && !intfClassScope->isRedeclaring() &&
classScope->derivesDirectlyFrom(intf) &&
(!parCls || !parCls->derivesFrom(ar, intf, true, false))) {
string id = intfClassScope->getId(cg);
cg_printf(", public %s%s", Option::ClassPrefix, id.c_str());
}
}
}
cg_indentBegin(" {\n");
cg_printf("public:\n");
cg.printSection("Properties");
classScope->getVariables()->outputCPPPropertyDecl(cg, ar,
classScope->derivesFromRedeclaring());
if (Option::GenerateCppLibCode) {
cg.printSection("Methods");
classScope->outputMethodWrappers(cg, ar);
cg.printSection(">>>>>>>>>> Internal Implementation <<<<<<<<<<");
cg_printf("// NOTE: Anything below is subject to change. "
"Use everything above instead.\n");
}
cg.printSection("Class Map");
if (Option::GenerateCPPMacros) {
cg_printf("virtual bool o_instanceof(CStrRef s) const;\n");
}
if (Option::GenerateCPPMacros) {
bool dyn = (!parCls && !m_parent.empty()) ||
classScope->derivesFromRedeclaring() ==
ClassScope::DirectFromRedeclared;
bool idyn = parCls && classScope->derivesFromRedeclaring() ==
ClassScope::IndirectFromRedeclared;
bool redec = classScope->isRedeclaring();
if (!classScope->derivesFromRedeclaring()) {
outputCPPClassDecl(cg, ar, clsName, m_originalName.c_str(),
parCls ? parCls->getId(cg).c_str()
: "ObjectData");
} else {
cg_printf("DECLARE_DYNAMIC_CLASS(%s, %s, %s)\n", clsName,
m_originalName.c_str(),
dyn || !parCls ? "DynamicObjectData" :
parCls->getId(cg).c_str());
}
bool hasGet = classScope->getAttribute(
ClassScope::HasUnknownPropGetter);
bool hasSet = classScope->getAttribute(
ClassScope::HasUnknownPropSetter);
bool hasCall = classScope->getAttribute(
ClassScope::HasUnknownMethodHandler);
bool hasCallStatic = classScope->getAttribute(
ClassScope::HasUnknownStaticMethodHandler);
if (dyn || idyn || redec || hasGet || hasSet ||
hasCall || hasCallStatic) {
if (redec && classScope->derivedByDynamic()) {
if (!dyn && !idyn) {
cg_printf("private: ObjectData* root;\n");
cg_printf("public:\n");
cg_printf("virtual ObjectData *getRoot() { return root; }\n");
}
}
string conInit = "";
bool hasParam = false;
if (dyn) {
conInit = " : DynamicObjectData(\"" + m_parent + "\", r)";
hasParam = true;
} else if (idyn) {
conInit = " : " + string(Option::ClassPrefix) + parCls->getId(cg) +
"(r ? r : this)";
hasParam = true;
} else {
if (redec && classScope->derivedByDynamic()) {
conInit = " : root(r ? r : this)";
}
hasParam = true;
}
cg_indentBegin("%s%s(%s)%s {%s",
Option::ClassPrefix, clsName,
hasParam ? "ObjectData* r = NULL" : "",
conInit.c_str(),
hasGet || hasSet || hasCall || hasCallStatic ?
"\n" : "");
if (hasGet) cg_printf("setAttribute(UseGet);\n");
if (hasSet) cg_printf("setAttribute(UseSet);\n");
if (hasCall) cg_printf("setAttribute(HasCall);\n");
if (hasCallStatic) cg_printf("setAttribute(HasCallStatic);\n");
cg_indentEnd("}\n");
}
}
cg_printf("void init();\n");
if (classScope->needLazyStaticInitializer()) {
cg_printf("static GlobalVariables *lazy_initializer"
"(GlobalVariables *g);\n");
}
if (!classScope->getAttribute(ClassScope::HasConstructor)) {
FunctionScopePtr func = classScope->findFunction(ar, "__construct",
false);
if (func && !func->isAbstract() && !classScope->isInterface()) {
func->outputCPPCreateDecl(cg, ar);
}
}
if (classScope->getAttribute(ClassScope::HasDestructor)) {
cg_printf("public: virtual void destruct();\n");
}
// doCall
if (classScope->getAttribute(ClassScope::HasUnknownMethodHandler)) {
cg_printf("Variant doCall(Variant v_name, Variant v_arguments, "
"bool fatal);\n");
}
if (classScope->isRedeclaring() &&
!classScope->derivesFromRedeclaring() &&
classScope->derivedByDynamic()) {
cg_printf("Variant doRootCall(Variant v_name, Variant v_arguments, "
"bool fatal);\n");
}
if (m_stmt) m_stmt->outputCPP(cg, ar);
{
set<string> done;
classScope->outputCPPStaticMethodWrappers(cg, ar, done, clsName);
}
if (cg.getOutput() == CodeGenerator::SystemCPP &&
ar->isBaseSysRsrcClass(clsName) &&
!classScope->hasProperty("rsrc")) {
cg_printf("public: Variant %srsrc;\n", Option::PropertyPrefix);
}
if (Option::GenerateCPPMacros) {
classScope->outputCPPJumpTableDecl(cg, ar);
}
cg_indentEnd("};\n");
if (redeclared) {
cg_indentBegin("class %s%s : public ClassStatics {\n",
Option::ClassStaticsPrefix, clsName);
cg_printf("public:\n");
cg_printf("DECLARE_OBJECT_ALLOCATION(%s%s);\n",
Option::ClassStaticsPrefix, clsName);
cg_printf("%s%s() : ClassStatics(%d) {}\n",
Option::ClassStaticsPrefix, clsName,
classScope->getRedeclaringId());
cg_indentBegin("Variant %sgetInit(CStrRef s) {\n",
Option::ObjectStaticPrefix);
cg_printf("return %s%s::%sgetInit(s);\n", Option::ClassPrefix,
clsName, Option::ObjectStaticPrefix);
cg_indentEnd("}\n");
cg_indentBegin("Variant %sget(CStrRef s) {\n",
Option::ObjectStaticPrefix);
cg_printf("return %s%s::%sget(s);\n", Option::ClassPrefix,
clsName, Option::ObjectStaticPrefix);
cg_indentEnd("}\n");
cg_indentBegin("Variant &%slval(CStrRef s) {\n",
Option::ObjectStaticPrefix);
cg_printf("return %s%s::%slval(s);\n", Option::ClassPrefix,
clsName, Option::ObjectStaticPrefix);
cg_indentEnd("}\n");
cg_indentBegin("Object createOnly(ObjectData* root = NULL) {\n");
cg_printf("Object r((NEWOBJ(%s%s)(root)));\n", Option::ClassPrefix,
clsName);
cg_printf("r->init();\n");
cg_printf("return r;\n");
cg_indentEnd("}\n");
cg_indentBegin("Variant %sconstant(const char* s) {\n",
Option::ObjectStaticPrefix);
cg_printf("return %s%s::%sconstant(s);\n", Option::ClassPrefix,
clsName, Option::ObjectStaticPrefix);
cg_indentEnd("}\n");
cg_indentBegin("bool %sget_call_info(MethodCallPackage &mcp, "
"int64 hash = -1) {\n",
Option::ObjectStaticPrefix);
cg_printf("return %s%s::%sget_call_info(mcp, hash);\n",
Option::ClassPrefix, clsName, Option::ObjectStaticPrefix);
cg_indentEnd("}\n");
cg_indentEnd("};\n");
}
if (m_stmt) {
cg.setContext(CodeGenerator::CppClassConstantsDecl);
m_stmt->outputCPP(cg, ar);
cg.setContext(CodeGenerator::CppDeclaration);
}
classScope->outputCPPGlobalTableWrappersDecl(cg, ar);
}
break;
case CodeGenerator::CppImplementation:
if (m_stmt) {
cg.setContext(CodeGenerator::CppClassConstantsImpl);
m_stmt->outputCPP(cg, ar);
cg.setContext(CodeGenerator::CppImplementation);
}
classScope->outputCPPSupportMethodsImpl(cg, ar);
if (redeclared) {
cg_printf("IMPLEMENT_OBJECT_ALLOCATION(%s%s);\n",
Option::ClassStaticsPrefix, clsName);
}
cg_indentBegin("void %s%s::init() {\n",
Option::ClassPrefix, clsName);
if (!m_parent.empty()) {
if (classScope->derivesFromRedeclaring() ==
ClassScope::DirectFromRedeclared) {
cg_printf("parent->init();\n");
} else {
ClassScopePtr parCls = ar->findClass(m_parent);
cg_printf("%s%s::init();\n", Option::ClassPrefix,
parCls->getId(cg).c_str());
}
}
if (classScope->getVariables()->
getAttribute(VariableTable::NeedGlobalPointer)) {
cg.printDeclareGlobals();
}
cg.setContext(CodeGenerator::CppConstructor);
if (m_stmt) m_stmt->outputCPP(cg, ar);
// This is lame. Exception base class needs to prepare stacktrace outside
// of its PHP constructor. Every subclass of exception also needs this
// stacktrace, so we're adding an artificial __init__ in exception.php
// and calling it here.
if (m_name == "exception") {
cg_printf("{CountableHelper h(this); t___init__();}\n");
}
cg_indentEnd("}\n");
if (classScope->needStaticInitializer()) {
cg_indentBegin("void %s%s::os_static_initializer() {\n",
Option::ClassPrefix, clsName);
cg.printDeclareGlobals();
cg.setContext(CodeGenerator::CppStaticInitializer);
if (m_stmt) m_stmt->outputCPP(cg, ar);
cg_indentEnd("}\n");
cg_indentBegin("void %s%s() {\n",
Option::ClassStaticInitializerPrefix, clsName);
cg_printf("%s%s::os_static_initializer();\n", Option::ClassPrefix,
clsName);
cg_indentEnd("}\n");
}
if (classScope->needLazyStaticInitializer()) {
cg_indentBegin("GlobalVariables *%s%s::lazy_initializer("
"GlobalVariables *g) {\n", Option::ClassPrefix, clsName);
cg_indentBegin("if (!g->%s%s) {\n",
Option::ClassStaticInitializerFlagPrefix, clsName);
cg_printf("g->%s%s = true;\n", Option::ClassStaticInitializerFlagPrefix,
clsName);
cg.setContext(CodeGenerator::CppLazyStaticInitializer);
if (m_stmt) m_stmt->outputCPP(cg, ar);
cg_indentEnd("}\n");
cg_printf("return g;\n");
cg_indentEnd("}\n");
}
cg.setContext(CodeGenerator::CppImplementation);
if (m_stmt) m_stmt->outputCPP(cg, ar);
break;
case CodeGenerator::CppFFIDecl:
case CodeGenerator::CppFFIImpl:
if (m_stmt) m_stmt->outputCPP(cg, ar);
break;
case CodeGenerator::JavaFFI:
{
if (classScope->isRedeclaring()) break;
// TODO support PHP namespaces, once HPHP supports it
string packageName = Option::JavaFFIRootPackage;
string packageDir = packageName;
Util::replaceAll(packageDir, ".", "/");
string outputDir = ar->getOutputPath() + "/" + Option::FFIFilePrefix +
packageDir + "/";
Util::mkdir(outputDir);
// uses a different cg to generate a separate file for each PHP class
// also, uses the original capitalized class name
string clsFile = outputDir + getOriginalName() + ".java";
ofstream fcls(clsFile.c_str());
CodeGenerator cgCls(&fcls, CodeGenerator::FileCPP);
cgCls.setContext(CodeGenerator::JavaFFI);
cgCls.printf("package %s;\n\n", packageName.c_str());
cgCls.printf("import hphp.*;\n\n");
printSource(cgCls);
string clsModifier;
switch (m_type) {
case T_CLASS:
break;
case T_ABSTRACT:
clsModifier = "abstract ";
break;
case T_FINAL:
clsModifier = "final ";
break;
}
cgCls.printf("public %sclass %s ", clsModifier.c_str(),
getOriginalName().c_str());
ClassScopePtr parCls;
if (!m_parent.empty()) parCls = ar->findClass(m_parent);
if (!m_parent.empty() && classScope->derivesDirectlyFrom(m_parent)
&& parCls && parCls->isUserClass() && !parCls->isRedeclaring()) {
// system classes are not supported in static FFI translation
// they shouldn't appear as superclasses as well
cgCls.printf("extends %s", parCls->getOriginalName().c_str());
}
else {
cgCls.printf("extends HphpObject");
}
if (m_base) {
bool first = true;
for (int i = 0; i < m_base->getCount(); i++) {
ScalarExpressionPtr exp =
dynamic_pointer_cast<ScalarExpression>((*m_base)[i]);
const char *intf = exp->getString().c_str();
ClassScopePtr intfClassScope = ar->findClass(intf);
if (intfClassScope && classScope->derivesFrom(ar, intf, false, false)
&& intfClassScope->isUserClass()) {
if (first) {
cgCls.printf(" implements ");
first = false;
}
else {
cgCls.printf(", ");
}
cgCls.printf(intfClassScope->getOriginalName().c_str());
}
}
}
cgCls.indentBegin(" {\n");
// constructor for initializing the variant pointer
cgCls.printf("protected %s(long ptr) { super(ptr); }\n\n",
getOriginalName().c_str());
FunctionScopePtr cons = classScope->findConstructor(ar, true);
if (cons && !cons->isAbstract() || m_type != T_ABSTRACT) {
// if not an abstract class and not having an explicit constructor,
// adds a default constructor
outputJavaFFIConstructor(cgCls, ar, cons);
}
if (m_stmt) m_stmt->outputCPP(cgCls, ar);
cgCls.indentEnd("}\n");
fcls.close();
}
break;
case CodeGenerator::JavaFFICppDecl:
case CodeGenerator::JavaFFICppImpl:
{
if (classScope->isRedeclaring()) break;
if (m_stmt) m_stmt->outputCPP(cg, ar);
FunctionScopePtr cons = classScope->findConstructor(ar, true);
if (cons && !cons->isAbstract() || m_type != T_ABSTRACT) {
outputJavaFFICPPCreator(cg, ar, cons);
}
}
break;
default:
ASSERT(false);
break;
}
}
