bool InterfaceStatement::checkVolatileBases(AnalysisResultPtr ar) {
ClassScopePtr classScope = m_classScope.lock();
ASSERT(!classScope->isVolatile());
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()) return true;
}
return false;
}
void InterfaceStatement::checkVolatile(AnalysisResultPtr ar) {
ClassScopePtr classScope = m_classScope.lock();
// redeclared classes/interfaces are automatically volatile
if (!classScope->isVolatile()) {
if (checkVolatileBases(ar)) {
// if any base is volatile, the class is volatile
classScope->setVolatile();
}
}
if (classScope->isVolatile()) {
ar->getFunctionScope()->getVariables()->
setAttribute(VariableTable::NeedGlobalPointer);
}
}
bool ClassConstantExpression::containsDynamicConstant(AnalysisResultPtr ar)
const {
if (m_class) return true;
ClassScopePtr cls = ar->findClass(m_origClassName);
return !cls || cls->isVolatile() ||
!cls->getConstants()->isRecursivelyDeclared(ar, m_varName);
}
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);
}
bool InterfaceStatement::checkVolatileBases(AnalysisResultConstRawPtr ar) {
ClassScopeRawPtr classScope = getClassScope();
assert(!classScope->isVolatile());
auto const& bases = classScope->getBases();
for (auto it = bases.begin(); it != bases.end(); ++it) {
ClassScopePtr base = ar->findClass(*it);
if (base && base->isVolatile()) return true;
}
return false;
}
void StatementList::outputCPPImpl(CodeGenerator &cg, AnalysisResultPtr ar) {
FunctionScopePtr func = getFunctionScope();
bool inPseudoMain = func && func->inPseudoMain();
std::vector<bool> isDeclaration;
if (inPseudoMain) {
// We need these declarations to go first, because PHP allows top level
// function and class declarations to appear after usage.
for (unsigned int i = 0; i < m_stmts.size(); i++) {
StatementPtr stmt = m_stmts[i];
bool isDecl = false;
if (stmt->is(Statement::KindOfFunctionStatement)) {
isDecl = true;
} else if (stmt->is(Statement::KindOfClassStatement) ||
stmt->is(Statement::KindOfInterfaceStatement)) {
ClassScopePtr cls =
(dynamic_pointer_cast<InterfaceStatement>(stmt))->getClassScope();
isDecl = cls->isBaseClass() || !cls->isVolatile();
}
if (isDecl) stmt->outputCPP(cg,ar);
isDeclaration.push_back(isDecl);
}
}
for (unsigned int i = 0; i < m_stmts.size(); i++) {
StatementPtr stmt = m_stmts[i];
if (stmt->is(Statement::KindOfClassStatement)) {
if (!inPseudoMain || !isDeclaration[i]) stmt->outputCPP(cg, ar);
} else if (!(stmt->is(Statement::KindOfFunctionStatement) ||
stmt->is(Statement::KindOfInterfaceStatement)) ||
(!inPseudoMain || !isDeclaration[i])) {
stmt->outputCPP(cg, ar);
if (stmt->is(Statement::KindOfMethodStatement)) {
MethodStatementPtr methodStmt =
dynamic_pointer_cast<MethodStatement>(stmt);
std::string methodName = methodStmt->getName();
if (methodName == "offsetget") {
ClassScopePtr cls = getClassScope();
std::string arrayAccess("arrayaccess");
if (cls->derivesFrom(ar, arrayAccess, false, false)) {
FunctionScopePtr funcScope = methodStmt->getFunctionScope();
std::string name = funcScope->getName();
funcScope->setName("__offsetget_lval");
methodStmt->setName("__offsetget_lval");
methodStmt->outputCPP(cg, ar);
funcScope->setName(name);
methodStmt->setName("offsetget");
}
}
}
}
}
}
ExpressionPtr ClassConstantExpression::preOptimize(AnalysisResultConstPtr ar) {
if (ar->getPhase() < AnalysisResult::FirstPreOptimize) {
return ExpressionPtr();
}
if (m_class) {
updateClassName();
if (m_class) {
return ExpressionPtr();
}
}
ClassScopePtr cls = resolveClass();
if (!cls || (cls->isVolatile() && !isPresent())) {
if (cls && !m_depsSet) {
cls->addUse(getScope(), BlockScope::UseKindConstRef);
m_depsSet = true;
}
return ExpressionPtr();
}
ConstantTablePtr constants = cls->getConstants();
ClassScopePtr defClass = cls;
ConstructPtr decl = constants->getValueRecur(ar, m_varName, defClass);
if (decl) {
BlockScope::s_constMutex.lock();
ExpressionPtr value = dynamic_pointer_cast<Expression>(decl);
BlockScope::s_constMutex.unlock();
if (!value->isScalar() &&
(value->is(KindOfClassConstantExpression) ||
value->is(KindOfConstantExpression))) {
std::set<ExpressionPtr> seen;
do {
if (!seen.insert(value).second) return ExpressionPtr();
value = value->preOptimize(ar);
if (!value) return ExpressionPtr();
} while (!value->isScalar() &&
(value->is(KindOfClassConstantExpression) ||
value->is(KindOfConstantExpression)));
}
ExpressionPtr rep = Clone(value, getScope());
rep->setComment(getText());
copyLocationTo(rep);
return replaceValue(rep);
}
return ExpressionPtr();
}
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;
}
void ClassStatement::analyzeProgram(AnalysisResultPtr ar) {
vector<string> bases;
if (!m_parent.empty()) bases.push_back(m_parent);
if (m_base) m_base->getStrings(bases);
for (unsigned int i = 0; i < bases.size(); i++) {
string className = bases[i];
addUserClass(ar, bases[i]);
}
ClassScopePtr classScope = m_classScope.lock();
if (hasHphpNote("Volatile")) classScope->setVolatile();
FunctionScopePtr func = ar->getFunctionScope();
// redeclared classes are automatically volatile
if (classScope->isVolatile()) {
func->getVariables()->setAttribute(VariableTable::NeedGlobalPointer);
}
if (m_stmt) {
ar->pushScope(classScope);
m_stmt->analyzeProgram(ar);
ar->popScope();
}
DependencyGraphPtr dependencies = ar->getDependencyGraph();
for (unsigned int i = 0; i < bases.size(); i++) {
ClassScopePtr cls = ar->findClass(bases[i]);
if (cls) {
if (dependencies->checkCircle(DependencyGraph::KindOfClassDerivation,
m_originalName,
cls->getOriginalName())) {
ClassScopePtr classScope = m_classScope.lock();
ar->getCodeError()->record(CodeError::InvalidDerivation,
shared_from_this(), ConstructPtr(),
cls->getOriginalName());
m_parent = "";
m_base = ExpressionListPtr();
classScope->clearBases();
} else if (cls->isUserClass()) {
dependencies->add(DependencyGraph::KindOfClassDerivation,
ar->getName(),
m_originalName, shared_from_this(),
cls->getOriginalName(), cls->getStmt());
}
}
}
}
TypePtr NewObjectExpression::inferTypes(AnalysisResultPtr ar, TypePtr type,
bool coerce) {
reset();
m_classScope.reset();
FunctionScopePtr prev = m_funcScope;
m_funcScope.reset();
ConstructPtr self = shared_from_this();
if (!m_name.empty() && !isStatic()) {
ClassScopePtr cls = resolveClassWithChecks();
m_name = m_className;
if (!cls) {
if (m_params) m_params->inferAndCheck(ar, Type::Any, false);
return Type::Object;
}
if (getScope()->isFirstPass() &&
(cls->isTrait() ?
!isSelf() && !isParent() :
cls->isInterface() || cls->isAbstract())) {
Compiler::Error(Compiler::InvalidInstantiation, self);
}
if (cls->isVolatile() && !isPresent()) {
getScope()->getVariables()->
setAttribute(VariableTable::NeedGlobalPointer);
}
m_dynamic = cls->derivesFromRedeclaring();
bool valid = true;
FunctionScopePtr func = cls->findConstructor(ar, true);
if (!func) {
if (m_params) {
if (!m_dynamic && m_params->getCount()) {
if (getScope()->isFirstPass()) {
Compiler::Error(Compiler::BadConstructorCall, self);
}
}
m_params->inferAndCheck(ar, Type::Some, false);
}
} else {
if (func != prev) func->addNewObjCaller(getScope());
m_extraArg = func->inferParamTypes(ar, self, m_params, valid);
m_variableArgument = func->isVariableArgument();
}
if (valid) {
m_classScope = cls;
m_funcScope = func;
}
if (!valid || m_dynamic) {
m_implementedType = Type::Object;
} else {
m_implementedType.reset();
}
return Type::CreateObjectType(m_name);
} else {
if (m_params) {
m_params->markParams(canInvokeFewArgs());
}
}
m_implementedType.reset();
m_nameExp->inferAndCheck(ar, Type::String, false);
if (m_params) m_params->inferAndCheck(ar, Type::Any, false);
return Type::Object;
}
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;
}
}
TypePtr SimpleFunctionCall::inferAndCheck(AnalysisResultPtr ar, TypePtr type,
bool coerce) {
reset();
ConstructPtr self = shared_from_this();
// handling define("CONSTANT", ...);
if (m_className.empty()) {
if (m_type == DefineFunction && m_params && m_params->getCount() >= 2) {
ScalarExpressionPtr name =
dynamic_pointer_cast<ScalarExpression>((*m_params)[0]);
string varName;
if (name) {
varName = name->getIdentifier();
if (!varName.empty()) {
ExpressionPtr value = (*m_params)[1];
TypePtr varType = value->inferAndCheck(ar, NEW_TYPE(Some), false);
ar->getDependencyGraph()->
addParent(DependencyGraph::KindOfConstant,
ar->getName(), varName, self);
ConstantTablePtr constants =
ar->findConstantDeclarer(varName)->getConstants();
if (constants != ar->getConstants()) {
if (value && !value->isScalar()) {
constants->setDynamic(ar, varName);
varType = Type::Variant;
}
if (constants->isDynamic(varName)) {
m_dynamicConstant = true;
ar->getScope()->getVariables()->
setAttribute(VariableTable::NeedGlobalPointer);
} else {
constants->setType(ar, varName, varType, true);
}
// in case the old 'value' has been optimized
constants->setValue(ar, varName, value);
}
return checkTypesImpl(ar, type, Type::Boolean, coerce);
}
}
if (varName.empty() && ar->isFirstPass()) {
ar->getCodeError()->record(self, CodeError::BadDefine, self);
}
} else if (m_type == ExtractFunction) {
ar->getScope()->getVariables()->forceVariants(ar);
}
}
FunctionScopePtr func;
// avoid raising both MissingObjectContext and UnknownFunction
bool errorFlagged = false;
if (m_className.empty()) {
func = ar->findFunction(m_name);
} else {
ClassScopePtr cls = ar->resolveClass(m_className);
if (cls && cls->isVolatile()) {
ar->getScope()->getVariables()
->setAttribute(VariableTable::NeedGlobalPointer);
}
if (!cls || cls->isRedeclaring()) {
if (cls) {
m_redeclaredClass = true;
}
if (!cls && ar->isFirstPass()) {
ar->getCodeError()->record(self, CodeError::UnknownClass, self);
}
if (m_params) {
m_params->inferAndCheck(ar, NEW_TYPE(Some), false);
}
return checkTypesImpl(ar, type, Type::Variant, coerce);
}
m_derivedFromRedeclaring = cls->derivesFromRedeclaring();
m_validClass = true;
if (m_name == "__construct") {
// if the class is known, php will try to identify class-name ctor
func = cls->findConstructor(ar, true);
}
else {
func = cls->findFunction(ar, m_name, true, true);
}
if (func && !func->isStatic()) {
ClassScopePtr clsThis = ar->getClassScope();
FunctionScopePtr funcThis = ar->getFunctionScope();
if (!clsThis ||
(clsThis->getName() != m_className &&
!clsThis->derivesFrom(ar, m_className)) ||
funcThis->isStatic()) {
// set the method static to avoid "unknown method" runtime exception
if (Option::StaticMethodAutoFix && !func->containsThis()) {
func->setStatic();
}
if (ar->isFirstPass()) {
ar->getCodeError()->record(self, CodeError::MissingObjectContext,
self);
errorFlagged = true;
}
func.reset();
}
}
}
if (!func || func->isRedeclaring()) {
if (func) {
m_redeclared = true;
ar->getScope()->getVariables()->
setAttribute(VariableTable::NeedGlobalPointer);
}
if (!func && !errorFlagged && ar->isFirstPass()) {
ar->getCodeError()->record(self, CodeError::UnknownFunction, self);
}
if (m_params) {
if (func) {
FunctionScope::RefParamInfoPtr info =
FunctionScope::GetRefParamInfo(m_name);
ASSERT(info);
for (int i = m_params->getCount(); i--; ) {
if (info->isRefParam(i)) {
m_params->markParam(i, canInvokeFewArgs());
}
}
}
m_params->inferAndCheck(ar, NEW_TYPE(Some), false);
}
return checkTypesImpl(ar, type, Type::Variant, coerce);
}
m_builtinFunction = !func->isUserFunction();
if (m_redeclared) {
if (m_params) {
m_params->inferAndCheck(ar, NEW_TYPE(Some), false);
}
return checkTypesImpl(ar, type, type, coerce);
}
CHECK_HOOK(beforeSimpleFunctionCallCheck);
m_valid = true;
type = checkParamsAndReturn(ar, type, coerce, func);
if (!m_valid && m_params) {
m_params->markParams(false);
}
CHECK_HOOK(afterSimpleFunctionCallCheck);
return type;
}
ExpressionPtr SimpleFunctionCall::preOptimize(AnalysisResultPtr ar) {
ar->preOptimize(m_nameExp);
ar->preOptimize(m_params);
if (ar->getPhase() != AnalysisResult::SecondPreOptimize) {
return ExpressionPtr();
}
// optimize away various "exists" functions, this may trigger
// dead code elimination and improve type-inference.
if (m_className.empty() &&
(m_type == DefinedFunction ||
m_type == FunctionExistsFunction ||
m_type == ClassExistsFunction ||
m_type == InterfaceExistsFunction) &&
m_params && m_params->getCount() == 1) {
ExpressionPtr value = (*m_params)[0];
if (value->isScalar()) {
ScalarExpressionPtr name = dynamic_pointer_cast<ScalarExpression>(value);
if (name && name->isLiteralString()) {
string symbol = name->getLiteralString();
switch (m_type) {
case DefinedFunction: {
ConstantTablePtr constants = ar->getConstants();
// system constant
if (constants->isPresent(symbol)) {
return CONSTANT("true");
}
// user constant
BlockScopePtr block = ar->findConstantDeclarer(symbol);
// not found (i.e., undefined)
if (!block) {
if (symbol.find("::") == std::string::npos) {
return CONSTANT("false");
} else {
// e.g., defined("self::ZERO")
return ExpressionPtr();
}
}
constants = block->getConstants();
// already set to be dynamic
if (constants->isDynamic(symbol)) return ExpressionPtr();
ConstructPtr decl = constants->getValue(symbol);
ExpressionPtr constValue = dynamic_pointer_cast<Expression>(decl);
if (constValue->isScalar()) {
return CONSTANT("true");
} else {
return ExpressionPtr();
}
break;
}
case FunctionExistsFunction: {
const std::string &lname = Util::toLower(symbol);
if (Option::DynamicInvokeFunctions.find(lname) ==
Option::DynamicInvokeFunctions.end()) {
FunctionScopePtr func = ar->findFunction(lname);
if (!func) {
return CONSTANT("false");
} else if (!func->isVolatile()) {
return CONSTANT("true");
}
}
break;
}
case InterfaceExistsFunction: {
ClassScopePtr cls = ar->findClass(Util::toLower(symbol));
if (!cls || !cls->isInterface()) {
return CONSTANT("false");
} else if (!cls->isVolatile()) {
return CONSTANT("true");
}
break;
}
case ClassExistsFunction: {
ClassScopePtr cls = ar->findClass(Util::toLower(symbol));
if (!cls || cls->isInterface()) {
return CONSTANT("false");
} else if (!cls->isVolatile()) {
return CONSTANT("true");
}
break;
}
default:
ASSERT(false);
}
}
}
}
return ExpressionPtr();
}
void ClassScope::collectMethods(AnalysisResultPtr ar,
StringToFunctionScopePtrMap &funcs,
bool collectPrivate) {
// add all functions this class has
for (FunctionScopePtrVec::const_iterator iter =
m_functionsVec.begin(); iter != m_functionsVec.end(); ++iter) {
const FunctionScopePtr &fs = *iter;
if (!collectPrivate && fs->isPrivate()) continue;
FunctionScopePtr &func = funcs[fs->getScopeName()];
if (!func) {
func = fs;
} else {
func->setVirtual();
fs->setVirtual();
fs->setHasOverride();
if (fs->isFinal()) {
std::string s__MockClass = "__MockClass";
ClassScopePtr derivedClass = func->getContainingClass();
if (derivedClass->m_userAttributes.find(s__MockClass) ==
derivedClass->m_userAttributes.end()) {
Compiler::Error(Compiler::InvalidOverride,
fs->getStmt(), func->getStmt());
}
}
}
}
int n = m_bases.size();
for (int i = 0; i < n; i++) {
const string &base = m_bases[i];
ClassScopePtr super = ar->findClass(base);
if (super) {
if (super->isRedeclaring()) {
const ClassScopePtrVec &classes = ar->findRedeclaredClasses(base);
StringToFunctionScopePtrMap pristine(funcs);
for (auto& cls : classes) {
StringToFunctionScopePtrMap cur(pristine);
derivedMagicMethods(cls);
cls->collectMethods(ar, cur, false);
inheritedMagicMethods(cls);
funcs.insert(cur.begin(), cur.end());
}
m_derivesFromRedeclaring = Derivation::Redeclaring;
setVolatile();
} else {
derivedMagicMethods(super);
super->collectMethods(ar, funcs, false);
inheritedMagicMethods(super);
if (super->derivesFromRedeclaring() == Derivation::Redeclaring) {
m_derivesFromRedeclaring = Derivation::Redeclaring;
setVolatile();
} else if (super->isVolatile()) {
setVolatile();
}
}
} else {
Compiler::Error(Compiler::UnknownBaseClass, m_stmt, base);
if (base == m_parent) {
ar->declareUnknownClass(m_parent);
m_derivesFromRedeclaring = Derivation::Redeclaring;
setVolatile();
} else {
/*
* TODO(#3685260): this should not be removing interfaces from
* the base list.
*/
if (isInterface()) {
m_derivesFromRedeclaring = Derivation::Redeclaring;
}
m_bases.erase(m_bases.begin() + i);
n--;
i--;
}
}
}
}
TypePtr NewObjectExpression::inferTypes(AnalysisResultPtr ar, TypePtr type,
bool coerce) {
reset();
m_classScope.reset();
m_funcScope.reset();
ConstructPtr self = shared_from_this();
if (!m_name.empty()) {
ClassScopePtr cls = resolveClass(getScope());
m_name = m_className;
if (!cls) {
if (isRedeclared()) {
getScope()->getVariables()->
setAttribute(VariableTable::NeedGlobalPointer);
} else if (getScope()->isFirstPass()) {
Compiler::Error(Compiler::UnknownClass, self);
}
if (m_params) m_params->inferAndCheck(ar, Type::Any, false);
return Type::Object;
}
if (cls->isVolatile() && !isPresent()) {
getScope()->getVariables()->
setAttribute(VariableTable::NeedGlobalPointer);
}
m_dynamic = cls->derivesFromRedeclaring();
bool valid = true;
FunctionScopePtr func = cls->findConstructor(ar, true);
if (!func) {
if (m_params) {
if (!m_dynamic && m_params->getCount()) {
if (getScope()->isFirstPass()) {
Compiler::Error(Compiler::BadConstructorCall, self);
}
m_params->setOutputCount(0);
}
m_params->inferAndCheck(ar, Type::Some, false);
}
} else {
m_extraArg = func->inferParamTypes(ar, self, m_params,
valid);
m_variableArgument = func->isVariableArgument();
}
if (valid) {
m_classScope = cls;
m_funcScope = func;
}
if (!valid || m_dynamic) {
m_implementedType = Type::Object;
} else {
m_implementedType.reset();
}
return Type::CreateObjectType(m_name);
} else {
ar->containsDynamicClass();
if (m_params) {
m_params->markParams(false);
}
}
m_implementedType.reset();
m_nameExp->inferAndCheck(ar, Type::String, false);
if (m_params) m_params->inferAndCheck(ar, Type::Any, false);
return Type::Object;
}
void ClassStatement::outputCPP(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, m_name.c_str(),
Option::ClassStaticsPrefix, classScope->getId().c_str());
}
if (classScope->isVolatile()) {
cg.printf("g->declareClass(\"%s\");\n",
m_name.c_str());
}
return;
}
if (cg.getContext() != CodeGenerator::CppForwardDeclaration) {
printSource(cg);
}
ar->pushScope(classScope);
string clsNameStr = classScope->getId();
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:
{
ClassScopePtr parCls;
if (!m_parent.empty()) parCls = ar->findClass(m_parent);
cg.printf("class %s%s", Option::ClassPrefix, clsName);
bool derived = false;
if (!m_parent.empty() && classScope->derivesFrom(ar, m_parent)) {
if (parCls->isRedeclaring()) {
cg.printf(" : public DynamicObjectData");
} else {
cg.printf(" : virtual public %s%s", Option::ClassPrefix,
parCls->getId().c_str());
}
derived = true;
}
if (m_base) {
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)) {
// temporary fix for inheriting from a re-declaring class
string id = intfClassScope->getId();
if (!derived) {
derived = true;
cg.printf(" :");
} else {
cg.printf(",");
}
cg.printf(" virtual public %s%s", Option::ClassPrefix, id.c_str());
}
}
}
if (!derived) {
const char *op = derived ? "," : " :";
if (classScope->derivesFromRedeclaring()) {
cg.printf("%s public DynamicObjectData", op);
} else {
cg.printf("%s virtual public ObjectData", op);
}
}
cg.indentBegin(" {\n");
if (Option::GenerateCPPMacros) {
vector<string> bases;
getAllParents(ar, bases);
cg.indentBegin("BEGIN_CLASS_MAP(%s)\n", clsName);
for (unsigned int i = 0; i < bases.size(); i++) {
cg.printf("PARENT_CLASS(%s)\n", bases[i].c_str());
}
cg.indentEnd("END_CLASS_MAP(%s)\n", clsName);
}
if (Option::GenerateCPPMacros) {
bool dyn = classScope->derivesFromRedeclaring() ==
ClassScope::DirectFromRedeclared;
bool idyn = classScope->derivesFromRedeclaring() ==
ClassScope::IndirectFromRedeclared;
bool redec = classScope->isRedeclaring();
if (!classScope->derivesFromRedeclaring()) {
cg.printf("DECLARE_CLASS(%s, %s, %s)\n", clsName,
m_originalName.c_str(),
m_parent.empty() ? "ObjectData" : m_parent.c_str());
} else {
cg.printf("DECLARE_DYNAMIC_CLASS(%s, %s)\n", clsName,
m_originalName.c_str());
}
if (cg.getOutput() == CodeGenerator::SystemCPP ||
Option::EnableEval >= Option::LimitedEval) {
cg.printf("DECLARE_INVOKES_FROM_EVAL\n");
}
if (dyn || idyn || redec) {
if (redec) {
cg.indentBegin("Variant %sroot_invoke(const char* s, CArrRef ps, "
"int64 h, bool f = true) {\n",
Option::ObjectPrefix);
cg.printf("return root->%sinvoke(s, ps, h, f);\n",
Option::ObjectPrefix);
cg.indentEnd("}\n");
cg.indentBegin("Variant %sroot_invoke_few_args(const char* s, "
"int64 h, int count", Option::ObjectPrefix);
for (int i = 0; i < Option::InvokeFewArgsCount; i++) {
cg.printf(", CVarRef a%d = null_variant", i);
}
cg.printf(") {\n");
cg.printf("return root->%sinvoke_few_args(s, h, count",
Option::ObjectPrefix);
for (int i = 0; i < Option::InvokeFewArgsCount; i++) {
cg.printf(", a%d", i);
}
cg.printf(");\n");
cg.indentEnd("}\n");
if (!dyn && !idyn) cg.printf("private: ObjectData* root;\n");
cg.printf("public:\n");
}
string conInit = ":";
if (dyn) {
conInit += "DynamicObjectData(\"" + m_parent + "\", r)";
} else if (idyn) {
conInit += string(Option::ClassPrefix) + parCls->getId() +
"(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");
}
if (!classScope->derivesFromRedeclaring()){
classScope->getVariables()->outputCPPPropertyDecl(cg, ar);
}
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");
}
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 %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(%s%s(NEW(%s%s)(root))->"
"dynCreate(params, init));\n",
Option::SmartPtrPrefix, clsName,
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");
}
}
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());
}
}
cg.setContext(CodeGenerator::CppConstructor);
if (m_stmt) m_stmt->outputCPP(cg, ar);
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->derivesFrom(ar, m_parent)
&& 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());
}
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)
&& intfClassScope->isUserClass()) {
if (first) {
cgCls.printf(" implements ");
first = false;
}
else {
cgCls.printf(", ");
}
cgCls.printf(intfClassScope->getOriginalName());
}
}
}
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();
}
bool ClassStatement::hasImpl() const {
ClassScopePtr cls = m_classScope.lock();
return cls->isVolatile() ||
cls->getVariables()->getAttribute(VariableTable::ContainsDynamicStatic);
}
void InterfaceStatement::outputCPPImpl(CodeGenerator &cg, AnalysisResultPtr ar) {
ClassScopePtr classScope = m_classScope.lock();
if (cg.getContext() == CodeGenerator::NoContext) {
if (classScope->isVolatile()) {
cg.printf("g->CDEC(%s) = true;\n", m_name.c_str());
}
return;
}
ar->pushScope(classScope);
string clsNameStr = classScope->getId();
const char *clsName = clsNameStr.c_str();
switch (cg.getContext()) {
case CodeGenerator::CppForwardDeclaration:
if (Option::GenerateCPPMacros) {
cg.printf("FORWARD_DECLARE_CLASS(%s);\n", clsName);
}
break;
case CodeGenerator::CppDeclaration:
{
printSource(cg);
cg.printf("class %s%s", Option::ClassPrefix, clsName);
cg.indentBegin(" {\n");
if (m_stmt) m_stmt->outputCPP(cg, ar);
cg.indentEnd("};\n");
}
break;
case CodeGenerator::CppImplementation:
// do nothing
break;
case CodeGenerator::CppFFIDecl:
case CodeGenerator::CppFFIImpl:
// do nothing
break;
case CodeGenerator::JavaFFI:
{
// 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
string clsFile = outputDir + getOriginalName() + ".java";
ofstream fcls(clsFile.c_str());
CodeGenerator cgCls(&fcls, CodeGenerator::FileCPP);
cgCls.setContext(CodeGenerator::JavaFFIInterface);
cgCls.printf("package %s;\n\n", packageName.c_str());
cgCls.printf("import hphp.*;\n\n");
cgCls.printf("public interface %s", getOriginalName().c_str());
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(" extends ");
first = false;
}
else {
cgCls.printf(", ");
}
cgCls.printf(intfClassScope->getOriginalName());
}
}
}
cgCls.indentBegin(" {\n");
if (m_stmt) m_stmt->outputCPP(cgCls, ar);
cgCls.indentEnd("}\n");
fcls.close();
}
break;
case CodeGenerator::JavaFFICppDecl:
case CodeGenerator::JavaFFICppImpl:
// do nothing
break;
default:
ASSERT(false);
break;
}
ar->popScope();
}
void InterfaceStatement::outputCPPImpl(CodeGenerator &cg,
AnalysisResultPtr ar) {
ClassScopeRawPtr classScope = getClassScope();
if (cg.getContext() == CodeGenerator::NoContext) {
if (classScope->isVolatile()) {
const vector<string> &bases = classScope->getBases();
for (unsigned i = 0; i < bases.size(); ++i) {
const string &name = bases[i];
if (cg.checkHoistedClass(name) ||
classScope->hasKnownBase(i)) {
continue;
}
ClassScopePtr base = ar->findClass(name);
if (base && base->isVolatile()) {
cg_printf("checkClassExistsThrow(");
cg_printString(name, ar, shared_from_this());
cg_printf(", &%s->CDEC(%s));\n",
cg.getGlobals(ar),
CodeGenerator::FormatLabel(base->getName()).c_str());
}
}
classScope->outputCPPDef(cg);
cg.addHoistedClass(m_name);
}
return;
}
string clsNameStr = classScope->getId();
const char *clsName = clsNameStr.c_str();
switch (cg.getContext()) {
case CodeGenerator::CppDeclaration:
{
printSource(cg);
if (Option::GenerateCPPMacros) {
classScope->outputForwardDeclaration(cg);
}
if (classScope->isRedeclaring()) {
classScope->outputCPPGlobalTableWrappersDecl(cg, ar);
}
cg_printf("class %s%s", Option::ClassPrefix, clsName);
if (m_base && Option::UseVirtualDispatch &&
!classScope->isRedeclaring()) {
const char *sep = " :";
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)) {
string id = intfClassScope->getId();
cg_printf("%s public %s%s", sep, Option::ClassPrefix, id.c_str());
sep = ",";
}
}
}
cg_indentBegin(" {\n");
if (m_stmt) m_stmt->outputCPP(cg, ar);
bool hasPropTable = classScope->checkHasPropTable(ar);
if (hasPropTable) {
cg_printf("public: static const ClassPropTable %sprop_table;\n",
Option::ObjectStaticPrefix);
}
cg_indentEnd("};\n");
if (hasPropTable) {
classScope->outputCPPGlobalTableWrappersDecl(cg, ar);
}
if (m_stmt) {
cg.setContext(CodeGenerator::CppClassConstantsDecl);
m_stmt->outputCPP(cg, ar);
cg.setContext(CodeGenerator::CppDeclaration);
}
}
break;
case CodeGenerator::CppImplementation:
{
if (m_stmt) {
cg.setContext(CodeGenerator::CppClassConstantsImpl);
m_stmt->outputCPP(cg, ar);
cg.setContext(CodeGenerator::CppImplementation);
}
cg.addClass(getClassScope()->getName(), getClassScope());
if (classScope->isRedeclaring() || classScope->checkHasPropTable(ar)) {
classScope->outputCPPGlobalTableWrappersImpl(cg, ar);
}
}
break;
case CodeGenerator::CppFFIDecl:
case CodeGenerator::CppFFIImpl:
// do nothing
break;
case CodeGenerator::JavaFFI:
{
// 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
string clsFile = outputDir + getOriginalName() + ".java";
std::ofstream fcls(clsFile.c_str());
CodeGenerator cgCls(&fcls, CodeGenerator::FileCPP);
cgCls.setContext(CodeGenerator::JavaFFIInterface);
cgCls.printf("package %s;\n\n", packageName.c_str());
cgCls.printf("import hphp.*;\n\n");
cgCls.printf("public interface %s", getOriginalName().c_str());
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(" extends ");
first = false;
}
else {
cgCls.printf(", ");
}
cgCls.printf(intfClassScope->getOriginalName().c_str());
}
}
}
cgCls.indentBegin(" {\n");
if (m_stmt) m_stmt->outputCPP(cgCls, ar);
cgCls.indentEnd("}\n");
fcls.close();
}
break;
case CodeGenerator::JavaFFICppDecl:
case CodeGenerator::JavaFFICppImpl:
// do nothing
break;
default:
ASSERT(false);
break;
}
}
bool InterfaceStatement::hasImpl() const {
ClassScopePtr cls = m_classScope.lock();
return cls->isVolatile();
}
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 ClassStatement::outputCPPImpl(CodeGenerator &cg, AnalysisResultPtr ar) {
ClassScopeRawPtr classScope = getClassScope();
if (cg.getContext() == CodeGenerator::NoContext) {
if (classScope->isVolatile()) {
string name = CodeGenerator::FormatLabel(m_name);
if (classScope->isRedeclaring()) {
cg_printf("g->%s%s = &%s%s;\n",
Option::ClassStaticsCallbackPrefix,
name.c_str(),
Option::ClassStaticsCallbackPrefix,
classScope->getId().c_str());
}
cg_printf("g->CDEC(%s) = true;\n", name.c_str());
cg.addHoistedClass(name);
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("checkClassExistsThrow(");
cg_printString(*it, ar, shared_from_this());
string lname = Util::toLower(*it);
cg_printf(", &%s->CDEC(%s));\n",
cg.getGlobals(ar),
CodeGenerator::FormatLabel(lname).c_str());
}
}
}
return;
}
if (cg.getContext() != CodeGenerator::CppForwardDeclaration) {
printSource(cg);
}
string clsNameStr = classScope->getId();
const char *clsName = clsNameStr.c_str();
switch (cg.getContext()) {
case CodeGenerator::CppDeclaration:
{
if (Option::GenerateCPPMacros) {
classScope->outputForwardDeclaration(cg);
}
classScope->outputCPPGlobalTableWrappersDecl(cg, ar);
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().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_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");
bool hasEmitCppCtor = false;
bool needsCppCtor = classScope->needsCppCtor();
bool needsInit = classScope->needsInitMethod();
if (Option::GenerateCPPMacros) {
bool dyn = classScope->derivesFromRedeclaring() ==
ClassScope::DirectFromRedeclared;
bool idyn = parCls && classScope->derivesFromRedeclaring() ==
ClassScope::IndirectFromRedeclared;
bool redec = classScope->isRedeclaring();
if (!parCls && !m_parent.empty()) {
assert(dyn);
}
if (!classScope->derivesFromRedeclaring()) {
outputCPPClassDecl(cg, ar, clsName, m_originalName.c_str(),
parCls ? parCls->getId().c_str()
: "ObjectData");
} else {
cg_printf("DECLARE_DYNAMIC_CLASS(%s, %s, %s)\n", clsName,
CodeGenerator::EscapeLabel(m_originalName).c_str(),
dyn || !parCls ? "DynamicObjectData" :
parCls->getId().c_str());
}
if (classScope->checkHasPropTable()) {
cg_printf("static const ClassPropTable %sprop_table;\n",
Option::ObjectStaticPrefix);
}
bool hasGet = classScope->getAttribute(
ClassScope::HasUnknownPropGetter);
bool hasSet = classScope->getAttribute(
ClassScope::HasUnknownPropSetter);
bool hasIsset = classScope->getAttribute(
ClassScope::HasUnknownPropTester);
bool hasUnset = classScope->getAttribute(
ClassScope::HasPropUnsetter);
bool hasCall = classScope->getAttribute(
ClassScope::HasUnknownMethodHandler);
bool hasCallStatic = classScope->getAttribute(
ClassScope::HasUnknownStaticMethodHandler);
bool hasRootParam =
classScope->derivedByDynamic() && (redec || dyn || idyn);
string lateInit = "";
if (redec && classScope->derivedByDynamic()) {
if (!dyn && !idyn && (!parCls || parCls->isUserClass())) {
cg_printf("private: ObjectData* root;\n");
cg_printf("public:\n");
cg_printf("virtual ObjectData *getRoot() { return root; }\n");
lateInit = "root(r ? r : this)";
}
}
string callbacks = Option::ClassStaticsCallbackPrefix + clsNameStr;
string conInit = "";
if (dyn) {
conInit = "DynamicObjectData(cb, \"" +
CodeGenerator::EscapeLabel(m_parent) + "\", ";
if (hasRootParam) {
conInit += "r)";
} else {
conInit += "this)";
}
} else if (parCls) {
conInit = string(Option::ClassPrefix) + parCls->getId() + "(";
if (parCls->derivedByDynamic() &&
(parCls->isRedeclaring() ||
parCls->derivesFromRedeclaring() != ClassScope::FromNormal)) {
if (hasRootParam) {
conInit += "r ? r : ";
}
conInit += "this, ";
}
conInit += "cb)";
} else {
if (system) {
conInit = "ExtObjectData(cb)";
} else {
conInit = "ObjectData(cb, false)";
}
}
cg_printf("%s%s(%sconst ObjectStaticCallbacks *cb = &%s%s) : %s",
Option::ClassPrefix,
clsName,
hasRootParam ? "ObjectData* r = NULL," : "",
callbacks.c_str(),
redec ? ".oscb" : "",
conInit.c_str());
if (needsCppCtor) {
cg_printf(", ");
cg.setContext(CodeGenerator::CppConstructor);
ASSERT(!cg.hasInitListFirstElem());
m_stmt->outputCPP(cg, ar);
cg.clearInitListFirstElem();
cg.setContext(CodeGenerator::CppDeclaration);
}
if (!lateInit.empty()) {
cg_printf(", %s", lateInit.c_str());
}
cg_indentBegin(" {%s",
hasGet || hasSet || hasIsset || hasUnset ||
hasCall || hasCallStatic ?
"\n" : "");
if (hasGet) cg_printf("setAttribute(UseGet);\n");
if (hasSet) cg_printf("setAttribute(UseSet);\n");
if (hasIsset) cg_printf("setAttribute(UseIsset);\n");
if (hasUnset) cg_printf("setAttribute(UseUnset);\n");
if (hasCall) cg_printf("setAttribute(HasCall);\n");
if (hasCallStatic) cg_printf("setAttribute(HasCallStatic);\n");
cg_indentEnd("}\n");
hasEmitCppCtor = true;
}
if (needsCppCtor && !hasEmitCppCtor) {
cg_printf("%s%s() : ", Option::ClassPrefix, clsName);
cg.setContext(CodeGenerator::CppConstructor);
ASSERT(!cg.hasInitListFirstElem());
m_stmt->outputCPP(cg, ar);
cg.clearInitListFirstElem();
cg.setContext(CodeGenerator::CppDeclaration);
cg_printf(" {}\n");
}
if (needsInit) {
cg_printf("void init();\n");
}
if (!classScope->getAttribute(ClassScope::HasConstructor)) {
FunctionScopePtr func = classScope->findFunction(ar, "__construct",
false);
if (func && !func->isAbstract() && !classScope->isInterface()) {
func->outputCPPCreateDecl(cg, ar);
}
}
// doCall
if (classScope->getAttribute(ClassScope::HasUnknownMethodHandler)) {
cg_printf("Variant doCall(Variant v_name, Variant v_arguments, "
"bool fatal);\n");
}
if (classScope->getAttribute(ClassScope::HasInvokeMethod)) {
FunctionScopePtr func =
classScope->findFunction(ar, "__invoke", false);
ASSERT(func);
if (!func->isAbstract()) {
cg_printf("const CallInfo *"
"t___invokeCallInfoHelper(void *&extra);\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 (Option::GenerateCPPMacros) {
classScope->outputCPPJumpTableDecl(cg, ar);
}
cg_indentEnd("};\n");
classScope->outputCPPDynamicClassDecl(cg);
if (m_stmt) {
cg.setContext(CodeGenerator::CppClassConstantsDecl);
m_stmt->outputCPP(cg, ar);
cg.setContext(CodeGenerator::CppDeclaration);
}
}
break;
case CodeGenerator::CppImplementation:
{
if (m_stmt) {
cg.setContext(CodeGenerator::CppClassConstantsImpl);
m_stmt->outputCPP(cg, ar);
cg.setContext(CodeGenerator::CppImplementation);
}
classScope->outputCPPSupportMethodsImpl(cg, ar);
bool needsInit = classScope->needsInitMethod();
if (needsInit) {
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().c_str());
}
}
if (classScope->getVariables()->
getAttribute(VariableTable::NeedGlobalPointer)) {
cg.printDeclareGlobals();
}
cg.setContext(CodeGenerator::CppInitializer);
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");
}
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;
}
}
