void ConstantTable::outputCPP(CodeGenerator &cg, AnalysisResultPtr ar) {
bool decl = true;
if (cg.getContext() == CodeGenerator::CppConstantsDecl) {
decl = false;
}
bool printed = false;
for (StringToSymbolMap::iterator iter = m_symbolMap.begin(),
end = m_symbolMap.end(); iter != end; ++iter) {
Symbol *sym = &iter->second;
if (!sym->declarationSet() || sym->isDynamic()) continue;
if (sym->isSystem() && cg.getOutput() != CodeGenerator::SystemCPP) continue;
const string &name = sym->getName();
ConstructPtr value = sym->getValue();
printed = true;
cg_printf(decl ? "extern const " : "const ");
TypePtr type = sym->getFinalType();
bool isString = type->is(Type::KindOfString);
if (isString) {
cg_printf("StaticString");
} else {
type->outputCPPDecl(cg, ar);
}
if (decl) {
cg_printf(" %s%s", Option::ConstantPrefix,
cg.formatLabel(name).c_str());
} else {
cg_printf(" %s%s", Option::ConstantPrefix,
cg.formatLabel(name).c_str());
cg_printf(isString ? "(" : " = ");
if (value) {
ExpressionPtr exp = dynamic_pointer_cast<Expression>(value);
ASSERT(!exp->getExpectedType());
ScalarExpressionPtr scalarExp =
dynamic_pointer_cast<ScalarExpression>(exp);
if (isString && scalarExp) {
cg_printf("LITSTR_INIT(%s)",
scalarExp->getCPPLiteralString(cg).c_str());
} else {
exp->outputCPP(cg, ar);
}
} else {
cg_printf("\"%s\"", cg.escapeLabel(name).c_str());
}
if (isString) {
cg_printf(")");
}
}
cg_printf(";\n");
}
if (printed) {
cg_printf("\n");
}
}
void MethodStatement::outputCPPStaticMethodWrapper(CodeGenerator &cg,
AnalysisResultPtr ar,
const char *cls) {
if (!m_modifiers->isStatic() || !m_stmt) return;
CodeGenerator::Context context = cg.getContext();
FunctionScopePtr funcScope = m_funcScope.lock();
bool isWrapper = context == CodeGenerator::CppTypedParamsWrapperDecl ||
context == CodeGenerator::CppTypedParamsWrapperImpl;
bool needsWrapper = isWrapper ||
(Option::HardTypeHints && funcScope->needsTypeCheckWrapper());
m_modifiers->outputCPP(cg, ar);
TypePtr type = funcScope->getReturnType();
if (type) {
type->outputCPPDecl(cg, ar);
} else {
cg_printf("void");
}
cg_printf(" %s%s(", needsWrapper && !isWrapper ?
Option::TypedMethodPrefix : Option::MethodPrefix,
cg.formatLabel(m_name).c_str());
if (!isWrapper) cg.setContext(CodeGenerator::CppStaticMethodWrapper);
funcScope->outputCPPParamsDecl(cg, ar, m_params, true);
cg_printf(") { %s%s%s(", type ? "return " : "",
needsWrapper && !isWrapper ?
Option::TypedMethodImplPrefix : Option::MethodImplPrefix,
cg.formatLabel(m_name).c_str());
cg_printf("%s%s::s_class_name", Option::ClassPrefix, cls);
cg.setContext(context);
if (funcScope->isVariableArgument()) {
cg_printf(", num_args");
}
if (m_params) {
for (int i = 0; i < m_params->getCount(); i++) {
ParameterExpressionPtr param =
dynamic_pointer_cast<ParameterExpression>((*m_params)[i]);
ASSERT(param);
cg_printf(", %s%s", Option::VariablePrefix, param->getName().c_str());
}
}
if (funcScope->isVariableArgument()) {
cg_printf(", args");
}
cg_printf("); }\n");
if (!isWrapper && needsWrapper) {
cg.setContext(CodeGenerator::CppTypedParamsWrapperDecl);
outputCPPStaticMethodWrapper(cg, ar, cls);
cg.setContext(context);
}
}
void FunctionScope::outputCPPCreateImpl(CodeGenerator &cg,
AnalysisResultPtr ar) {
ClassScopePtr scope = ar->getClassScope();
string clsNameStr = scope->getId(cg);
const char *clsName = clsNameStr.c_str();
const char *consName = scope->classNameCtor() ? scope->getName().c_str()
: "__construct";
cg_printf("%s%s *%s%s::create(",
Option::ClassPrefix, clsName, Option::ClassPrefix, clsName);
outputCPPParamsImpl(cg, ar);
cg_indentBegin(") {\n");
cg_printf("CountableHelper h(this);\n");
cg_printf("init();\n");
cg_printf("%s%s(", Option::MethodPrefix, consName);
outputCPPParamsCall(cg, ar, false);
cg_printf(");\n");
cg_printf("return this;\n");
cg_indentEnd("}\n");
cg_indentBegin("ObjectData *%s%s::dynCreate(CArrRef params, "
"bool construct /* = true */) {\n",
Option::ClassPrefix, clsName);
cg_printf("init();\n");
cg_indentBegin("if (construct) {\n");
cg_printf("CountableHelper h(this);\n");
OutputCPPDynamicInvokeCount(cg);
outputCPPDynamicInvoke(cg, ar, Option::MethodPrefix,
cg.formatLabel(consName).c_str(),
true, false, false, NULL, true);
cg_indentEnd("}\n");
cg_printf("return this;\n");
cg_indentEnd("}\n");
if (isDynamic() || isSepExtension()) {
cg_indentBegin("void %s%s::dynConstruct(CArrRef params) {\n",
Option::ClassPrefix, clsName);
OutputCPPDynamicInvokeCount(cg);
outputCPPDynamicInvoke(cg, ar, Option::MethodPrefix,
cg.formatLabel(consName).c_str(),
true, false, false, NULL, true);
cg_indentEnd("}\n");
if (cg.getOutput() == CodeGenerator::SystemCPP ||
Option::EnableEval >= Option::LimitedEval) {
cg_indentBegin("void %s%s::dynConstructFromEval("
"Eval::VariableEnvironment &env, "
"const Eval::FunctionCallExpression *caller) {\n",
Option::ClassPrefix, clsName);
outputCPPEvalInvoke(cg, ar, Option::MethodPrefix,
cg.formatLabel(consName).c_str(), NULL, false);
cg_indentEnd("}\n");
}
}
}
void SimpleVariable::outputCPPImpl(CodeGenerator &cg, AnalysisResultPtr ar) {
if (m_this) {
ASSERT((getContext() & ObjectContext) == 0);
if (hasContext(OprLValue) || hasContext(AssignmentLHS)) {
cg_printf("throw_assign_this()");
} else if (hasContext(DeepOprLValue) ||
hasContext(DeepAssignmentLHS) ||
hasContext(LValue)) {
// $this[] op= ...; or $this[] = ...
cg_printf("Variant(GET_THIS())");
} else {
ClassScopePtr cls = getOriginalClass();
if (cls->derivedByDynamic()) {
cg_printf("Object(GET_THIS())");
} else {
cg_printf("GET_THIS_TYPED(%s)", cls->getId(cg).c_str());
}
}
} else if (m_superGlobal) {
VariableTablePtr variables = getScope()->getVariables();
string name = variables->getGlobalVariableName(cg, ar, m_name);
cg_printf("g->%s", name.c_str());
} else if (m_globals) {
cg_printf("get_global_array_wrapper()");
} else {
const char *prefix =
getScope()->getVariables()->getVariablePrefix(m_sym);
cg_printf("%s%s", prefix, cg.formatLabel(m_name).c_str());
}
}
std::string FunctionScope::getId(CodeGenerator &cg) const {
string name = cg.formatLabel(getOriginalName());
if (m_redeclaring < 0) {
return name;
}
return name + Option::IdPrefix +
boost::lexical_cast<std::string>(m_redeclaring);
}
void ConstantTable::collectCPPGlobalSymbols(StringPairVec &symbols,
CodeGenerator &cg,
AnalysisResultPtr ar) {
for (StringToSymbolMap::iterator iter = m_symbolMap.begin(),
end = m_symbolMap.end(); iter != end; ++iter) {
Symbol *sym = &iter->second;
if (sym->declarationSet() && sym->isDynamic()) {
string varname = Option::ConstantPrefix + cg.formatLabel(sym->getName());
symbols.push_back(pair<string, string>(varname, varname));
}
}
}
void ConstantTable::outputCPPDynamicImpl(CodeGenerator &cg,
AnalysisResultPtr ar) {
for (StringToSymbolMap::iterator iter = m_symbolMap.begin(),
end = m_symbolMap.end(); iter != end; ++iter) {
Symbol *sym = &iter->second;
if (sym->declarationSet() && sym->isDynamic()) {
cg_printf("%s%s = \"%s\";\n", Option::ConstantPrefix,
cg.formatLabel(sym->getName()).c_str(),
cg.escapeLabel(sym->getName()).c_str());
}
}
}
void ConstantTable::outputCPPDynamicDecl(CodeGenerator &cg,
AnalysisResultPtr ar) {
const char *prefix = Option::ConstantPrefix;
string classId;
const char *fmt = "Variant %s%s%s;\n";
ClassScopePtr scope = ar->getClassScope();
if (scope) {
prefix = Option::ClassConstantPrefix;
classId = scope->getId(cg);
fmt = "Variant %s%s_%s;\n";
}
for (StringToSymbolMap::iterator iter = m_symbolMap.begin(),
end = m_symbolMap.end(); iter != end; ++iter) {
Symbol *sym = &iter->second;
if (sym->declarationSet() && sym->isDynamic()) {
cg_printf(fmt, prefix, classId.c_str(),
cg.formatLabel(sym->getName()).c_str());
}
}
}
void SimpleVariable::outputCPPImpl(CodeGenerator &cg, AnalysisResultPtr ar) {
if (m_this) {
ASSERT((getContext() & ObjectContext) == 0);
if (hasContext(LValue)) {
// LValue and not ObjectContext must be $this = or $this[..] =
// Wrap with Variant to avoid compiler error
cg_printf("Variant(GET_THIS())");
} else {
cg_printf("GET_THIS()");
}
} else if (m_superGlobal) {
VariableTablePtr variables = ar->getScope()->getVariables();
string name = variables->getGlobalVariableName(cg, ar, m_name);
cg_printf("g->%s", name.c_str());
} else if (m_globals) {
cg_printf("get_global_array_wrapper()");
} else {
const char *prefix =
ar->getScope()->getVariables()->getVariablePrefix(ar, m_name);
cg_printf("%s%s", prefix, cg.formatLabel(m_name).c_str());
}
}
void ConstantTable::outputCPPDynamicDecl(CodeGenerator &cg,
AnalysisResultPtr ar,
Type2SymbolListMap &type2names) {
const char *prefix = Option::ConstantPrefix;
string classId;
const char *fmt = "";
ClassScopePtr scope = getClassScope();
if (scope) {
prefix = Option::ClassConstantPrefix;
classId = scope->getId(cg);
fmt = "_";
}
bool system = cg.getOutput() == CodeGenerator::SystemCPP;
SymbolList &symbols = type2names["Variant"];
BOOST_FOREACH(Symbol *sym, m_symbolVec) {
if (sym->declarationSet() && sym->isDynamic() &&
system == sym->isSystem()) {
symbols.push_back(string(prefix) + classId + fmt +
cg.formatLabel(sym->getName()));
}
}
}
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 = 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;
}
}
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 FunctionStatement::outputCPPImpl(CodeGenerator &cg,
AnalysisResultPtr ar) {
CodeGenerator::Context context = cg.getContext();
FunctionScopeRawPtr funcScope = getFunctionScope();
string fname = funcScope->getId(cg);
bool pseudoMain = funcScope->inPseudoMain();
string origFuncName = !pseudoMain ? funcScope->getOriginalName() :
("run_init::" + funcScope->getContainingFile()->getName());
string funcSection;
if (outputFFI(cg, ar)) return;
if (context == CodeGenerator::NoContext) {
string rname = cg.formatLabel(m_name);
if (funcScope->isRedeclaring()) {
cg.printf("g->GCI(%s) = &%s%s;\n", m_name.c_str(),
Option::CallInfoPrefix, fname.c_str());
}
if (funcScope->isVolatile()) {
cg_printf("g->declareFunctionLit(");
cg_printString(m_name, ar, shared_from_this());
cg_printf(");\n");
cg_printf("g->FVF(%s) = true;\n", rname.c_str());
}
return;
}
if (context == CodeGenerator::CppDeclaration &&
!funcScope->isInlined()) return;
if (context == CodeGenerator::CppPseudoMain &&
!pseudoMain) return;
if (context == CodeGenerator::CppImplementation &&
(funcScope->isInlined() || pseudoMain)) return;
cg.setPHPLineNo(-1);
if (pseudoMain && !Option::GenerateCPPMain) {
if (context == CodeGenerator::CppPseudoMain) {
if (cg.getOutput() != CodeGenerator::SystemCPP) {
cg.setContext(CodeGenerator::NoContext); // no inner functions/classes
funcScope->getVariables()->setAttribute(VariableTable::ForceGlobal);
outputCPPStmt(cg, ar);
funcScope->getVariables()->clearAttribute(VariableTable::ForceGlobal);
cg.setContext(CodeGenerator::CppPseudoMain);
return;
}
} else if (context == CodeGenerator::CppForwardDeclaration &&
cg.getOutput() != CodeGenerator::SystemCPP) {
return;
}
}
if (context == CodeGenerator::CppImplementation) {
printSource(cg);
} else if (context == CodeGenerator::CppForwardDeclaration &&
Option::GenerateCppLibCode) {
cg_printf("\n");
printSource(cg);
cg.printDocComment(funcScope->getDocComment());
}
bool isWrapper = context == CodeGenerator::CppTypedParamsWrapperDecl ||
context == CodeGenerator::CppTypedParamsWrapperImpl;
bool needsWrapper = isWrapper ||
(Option::HardTypeHints && funcScope->needsTypeCheckWrapper());
if (funcScope->isInlined()) cg_printf("inline ");
TypePtr type = funcScope->getReturnType();
if (type) {
type->outputCPPDecl(cg, ar, getScope());
} else {
cg_printf("void");
}
funcSection = Option::FunctionSections[origFuncName];
if (!funcSection.empty()) {
cg_printf(" __attribute__ ((section (\".text.%s\")))",
funcSection.c_str());
}
if (pseudoMain) {
cg_printf(" %s%s(", Option::PseudoMainPrefix,
funcScope->getContainingFile()->pseudoMainName().c_str());
} else {
cg_printf(" %s%s(",
needsWrapper && !isWrapper ?
Option::TypedFunctionPrefix : Option::FunctionPrefix,
fname.c_str());
}
switch (context) {
case CodeGenerator::CppForwardDeclaration:
case CodeGenerator::CppTypedParamsWrapperDecl:
funcScope->outputCPPParamsDecl(cg, ar, m_params, true);
cg_printf(");\n");
if (!isWrapper) {
if (funcScope->hasDirectInvoke()) {
cg_printf("Variant %s%s(void *extra, CArrRef params);\n",
Option::InvokePrefix, fname.c_str());
}
if (needsWrapper) {
cg.setContext(CodeGenerator::CppTypedParamsWrapperDecl);
outputCPPImpl(cg, ar);
cg.setContext(context);
}
}
break;
case CodeGenerator::CppDeclaration:
case CodeGenerator::CppImplementation:
case CodeGenerator::CppPseudoMain:
case CodeGenerator::CppTypedParamsWrapperImpl:
{
funcScope->outputCPPParamsDecl(cg, ar, m_params, false);
cg_indentBegin(") {\n");
if (!isWrapper) {
const char *sys =
(cg.getOutput() == CodeGenerator::SystemCPP ? "_BUILTIN" : "");
if (pseudoMain) {
cg_printf("PSEUDOMAIN_INJECTION%s(%s, %s%s);\n",
sys, origFuncName.c_str(), Option::PseudoMainPrefix,
funcScope->getContainingFile()->pseudoMainName().c_str());
} else {
if (m_stmt->hasBody()) {
cg_printf("FUNCTION_INJECTION%s(%s);\n", sys,
origFuncName.c_str());
}
outputCPPArgInjections(cg, ar, origFuncName.c_str(),
ClassScopePtr(), funcScope);
}
funcScope->outputCPP(cg, ar);
cg.setContext(CodeGenerator::NoContext); // no inner functions/classes
outputCPPStmt(cg, ar);
cg_indentEnd("}\n");
if (needsWrapper) {
cg.setContext(CodeGenerator::CppTypedParamsWrapperImpl);
outputCPPImpl(cg, ar);
}
cg.setContext(context);
} else {
outputCPPTypeCheckWrapper(cg, ar);
cg_indentEnd("}\n");
}
cg.printImplSplitter();
}
break;
default:
ASSERT(false);
}
}
void InterfaceStatement::outputCPPImpl(CodeGenerator &cg, AnalysisResultPtr ar) {
ClassScopeRawPtr classScope = getClassScope();
if (cg.getContext() == CodeGenerator::NoContext) {
if (classScope->isVolatile()) {
cg_printf("g->CDEC(%s) = true;\n", cg.formatLabel(m_name).c_str());
}
return;
}
string clsNameStr = classScope->getId(cg);
const char *clsName = clsNameStr.c_str();
switch (cg.getContext()) {
case CodeGenerator::CppForwardDeclaration:
if (Option::GenerateCPPMacros) {
if (!Option::UseVirtualDispatch ||
classScope->isRedeclaring()) {
cg_printf("FORWARD_DECLARE_GENERIC_INTERFACE(%s);\n", clsName);
} else {
cg_printf("FORWARD_DECLARE_INTERFACE(%s);\n", clsName);
}
}
break;
case CodeGenerator::CppDeclaration:
{
printSource(cg);
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(ar, intf)) {
string id = intfClassScope->getId(cg);
cg_printf("%s public %s%s", sep, Option::ClassPrefix, id.c_str());
sep = ",";
}
}
}
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().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;
}
}
void FunctionScope::outputMethodWrapper(CodeGenerator &cg,
AnalysisResultPtr ar) {
cg_printf("\n");
if (m_stmt) {
m_stmt->printSource(cg);
}
cg.printDocComment(m_docComment);
int minCount = getMinParamCount();
int maxCount = getMaxParamCount();
for (int count = minCount; count <= maxCount; count++) {
if (isStatic()) cg_printf("static ");
TypePtr type = getReturnType();
if (type) {
type->outputCPPDecl(cg, ar);
} else {
cg_printf("void");
}
cg_printf(" %s%s(", Option::MethodWrapperPrefix, getId(cg).c_str());
for (int i = 0; i < count; i++) {
if (i > 0) cg_printf(", ");
getParamType(i)->outputCPPDecl(cg, ar);
cg_printf(" %s%s", Option::VariablePrefix, getParamName(i).c_str());
}
if (isVariableArgument()) {
if (count) cg_printf(", ");
cg_printf("Array args = Array()");
}
cg_indentBegin(") {\n");
if ((isStatic() || isPerfectVirtual() || !isVirtual()) &&
!isRedeclaring()) {
if (type) cg_printf("return ");
cg_printf("%s%s(", Option::MethodPrefix, cg.formatLabel(m_name).c_str());
if (isVariableArgument()) {
cg_printf("args.size() + %d, ", count);
}
for (int i = 0; i < count; i++) {
if (i > 0) cg_printf(", ");
cg_printf("%s%s", Option::VariablePrefix, getParamName(i).c_str());
}
if (isVariableArgument()) {
if (count) cg_printf(", ");
cg_printf("args");
}
cg_printf(");\n");
} else {
cg_printf("Array params;\n");
for (int i = 0; i < count; i++) {
cg_printf("params.append(%s%s);\n",
Option::VariablePrefix, getParamName(i).c_str());
}
if (isVariableArgument()) {
cg_printf("params.merge(args);\n");
}
if (type) cg_printf("return ");
if (isStatic()) {
cg_printf("%sinvoke_mil(NULL, \"%s\", params, -1);\n",
Option::ObjectStaticPrefix, m_name.c_str());
} else {
cg_printf("%sinvoke_mil(\"%s\", params, -1);\n",
Option::ObjectPrefix, m_name.c_str());
}
}
cg_indentEnd("}\n");
}
}
