void MethodStatement::outputSwigFFIStub(CodeGenerator &cg,
AnalysisResultPtr ar) {
FunctionScopePtr funcScope = m_funcScope.lock();
bool varArgs = funcScope->isVariableArgument();
bool ret = funcScope->getReturnType();
string fname = funcScope->getId();
string originalName = funcScope->getOriginalName();
int ac = funcScope->getMaxParamCount();
if (cg.getContext() == CodeGenerator::SwigFFIImpl) {
printSource(cg);
}
cg.printf("Variant *%s(HphpSession *s", originalName.c_str());
ostringstream args;
bool first = true;
for (int i = 0; i < ac; i++) {
cg.printf(", Variant *a%d", i);
if (first) first = false;
else args << ", ";
args << "a" << i;
}
if (varArgs) {
cg.printf(", Variant *va");
if (!first) args << ", ";
args << "va";
}
if (cg.getContext() == CodeGenerator::SwigFFIDecl) {
cg.printf(");\n\n");
return;
}
cg.indentBegin(") {\n");
if (ret) {
cg.printf("void *result;\n");
cg.printf("int kind = ");
cg.printf("%s%s(&result", Option::FFIFnPrefix, fname.c_str());
if (ac > 0 || varArgs) cg.printf(", ");
} else {
cg.printf("%s%s(", Option::FFIFnPrefix, fname.c_str());
}
cg.printf("%s);\n", args.str().c_str());
cg.printf("Variant *ret = ");
if (ret) {
cg.printf("hphpBuildVariant(kind, result);\n");
cg.printf("s->addVariant(ret);\n");
} else {
cg.printf("hphpBuildVariant(0, 0);\n");
cg.printf("s->addVariant(ret);\n");
}
cg.printf("return ret;\n");
cg.indentEnd("}\n\n");
}
void MethodStatement::outputCPPTypeCheckWrapper(CodeGenerator &cg,
AnalysisResultPtr ar) {
FunctionScopePtr funcScope = getFunctionScope();
TypePtr type = funcScope->getReturnType();
bool isMethod = getClassScope();
string fname = isMethod ? funcScope->getName() : funcScope->getId(cg);
funcScope->outputCPP(cg, ar);
cg_printf("%s%s%s(", type ? "return " : "",
(isMethod ? (m_modifiers->isStatic() ?
Option::TypedMethodImplPrefix :
Option::TypedMethodPrefix) :
Option::TypedFunctionPrefix),
fname.c_str());
if (getClassScope() && m_modifiers->isStatic()) {
cg_printf("cls, ");
}
if (funcScope->isVariableArgument()) {
cg_printf("num_args, ");
}
assert(m_params);
for (int i = 0; i < m_params->getCount(); i++) {
ParameterExpressionPtr param =
dynamic_pointer_cast<ParameterExpression>((*m_params)[i]);
ASSERT(param);
if (i) cg_printf(", ");
cg_printf("%s%s", Option::VariablePrefix,
param->getName().c_str());
if (TypePtr spec = funcScope->getParamTypeSpec(i)) {
if (Type::SameType(spec, funcScope->getParamType(i))) {
if (spec->is(Type::KindOfArray)) {
cg_printf(".getArrayData()");
} else {
ClassScopePtr cls = ar->findClass(spec->getName());
assert(cls && !cls->isRedeclaring());
cg_printf(".getObjectData()");
}
}
}
}
if (funcScope->isVariableArgument()) {
cg_printf(", args");
}
cg_printf(");\n");
}
/**
* Generates the Java stub method for a PHP toplevel function.
*
* @author qixin
*/
void MethodStatement::outputJavaFFIStub(CodeGenerator &cg,
AnalysisResultPtr ar) {
FunctionScopePtr funcScope = m_funcScope.lock();
bool varArgs = funcScope->isVariableArgument();
bool ret = funcScope->getReturnType();
bool inClass = !m_className.empty();
bool isStatic = !inClass || m_modifiers->isStatic();
string fname = funcScope->getId();
string originalName = funcScope->getOriginalName();
if (originalName.length() < fname.length()) {
// if there are functions of the same name, fname may contain "$$..."
// in the end
originalName += fname.substr(originalName.length());
}
if (originalName == "clone" || originalName == "equals"
|| originalName == "finalize" || originalName == "getClass"
|| originalName == "hashCode" || originalName == "notify"
|| originalName == "notifyAll" || originalName == "toString"
|| originalName == "wait") {
// not to clash with Java method names
originalName = "_" + originalName;
}
if (cg.getContext() == CodeGenerator::JavaFFIInterface
|| inClass && m_modifiers->isAbstract()) {
// skip all the abstract methods, because php overriding is not very
// compatible with Java
return;
}
if (!inClass) printSource(cg);
// This Java method extracts the Variant pointer from the HphpVariant
// argument as a 64-bit integer, and then calls the native version.
bool exposeNative = false;
int ac = funcScope->getMaxParamCount();
if (ac > 0 || varArgs || !isStatic || !ret && inClass
|| cg.getContext() == CodeGenerator::JavaFFIInterface) {
// make methods always return something, so that they can override
// each other
cg.printf("public %s%s %s(",
(isStatic ? "static " : ""),
(!ret && !inClass ? "void" : "HphpVariant"),
originalName.c_str());
ostringstream args;
bool first = true;
if (!isStatic) {
// instance method has an additional parameter
args << "this.getVariantPtr()";
}
for (int i = 0; i < ac; i++) {
if (first) {
first = false;
if (!isStatic) args << ", ";
}
else {
cg.printf(", ");
args << ", ";
}
cg.printf("HphpVariant a%d", i);
args << "a" << i << ".getVariantPtr()";
}
if (varArgs) {
if (!first) {
cg.printf(", ");
args << ", ";
}
else if (!isStatic) {
args << ", ";
}
cg.printf("HphpVariant va");
args << "va.getVariantPtr()";
}
if (cg.getContext() == CodeGenerator::JavaFFIInterface) {
cg.printf(");\n\n");
return;
}
cg.indentBegin(") {\n");
cg.printf("%s%s_native(%s);\n", (ret ? "return " : ""),
originalName.c_str(),
args.str().c_str());
if (!ret && inClass) {
cg.printf("return HphpNull.phpNull();\n");
}
cg.indentEnd("}\n\n");
}
else {
exposeNative = true;
}
// the native method stub
cg.printf("%s %snative %s %s%s(",
(exposeNative ? "public" : "private"),
(isStatic ? "static " : ""), (ret ? "HphpVariant" : "void"),
originalName.c_str(),
(exposeNative ? "" : "_native"));
bool first = true;
if (!isStatic) {
// instance method has an additional parameter
cg.printf("long targetPtr");
first = false;
}
for (int i = 0; i < ac; i++) {
if (first) first = false;
else cg.printf(", ");
cg.printf("long a%d", i);
}
if (varArgs) {
if (!first) cg.printf(", ");
cg.printf("long va");
}
cg.printf(");\n\n");
}
void MethodStatement::outputHSFFIStub(CodeGenerator &cg, AnalysisResultPtr ar) {
if (!m_className.empty()) {
// Haskell currently doesn't support FFI for class methods.
return;
}
FunctionScopePtr funcScope = m_funcScope.lock();
bool varArgs = funcScope->isVariableArgument();
bool ret = funcScope->getReturnType();
string fname = funcScope->getId().c_str();
cg.indentBegin("foreign import ccall \"stubs.h %s%s\" %s%s\n",
Option::FFIFnPrefix,
fname.c_str(),
Option::FFIFnPrefix,
fname.c_str());
cg.printf(":: ");
if (ret) {
cg.printf("PtrPtr a -> ");
}
int ac = funcScope->getMaxParamCount();
for (int i = 0; i < ac; ++i) {
cg.printf("HphpVariantPtr -> ");
}
if (varArgs) {
cg.printf("HphpVariantPtr -> ");
}
if (ret) {
cg.printf("IO CInt");
} else {
cg.printf("IO ()");
}
cg.indentEnd("\n");
cg.printf("f_%s :: ", fname.c_str());
bool first = true;
if (ac > 0) {
cg.printf("(");
}
for (int i = 0; i < ac; ++i) {
if (first) {
first = false;
} else {
cg.printf(", ");
}
cg.printf("VariantAble a%d", i);
}
if (ac > 0) {
cg.printf(") => ");
}
for (int i = 0; i < ac; ++i) {
cg.printf("a%d -> ", i);
}
if (varArgs) {
cg.printf("[Variant] -> ");
}
if (ret) {
cg.printf("IO Variant");
} else {
cg.printf("IO ()");
}
cg.printf("\n");
cg.printf("f_%s ", fname.c_str());
for (int i = 0; i < ac; ++i) {
cg.printf("v%d ", i);
}
if (varArgs) {
cg.printf("va ");
}
cg.indentBegin("=%s\n", ret ? " alloca (\\pres ->" : "");
for (int i = 0; i < ac; ++i) {
cg.indentBegin("withExportedVariant (toVariant v%d) (\\p%d ->\n", i, i);
}
if (varArgs) {
cg.indentBegin("withVParamList va (\\pva ->\n");
}
cg.indentBegin("do\n");
cg.printf("%sffi_%s", ret ? "t <- " : "", fname.c_str());
if (ret) {
cg.printf(" pres");
}
for (int i = 0; i < ac; ++i) {
cg.printf(" p%d", i);
}
if (varArgs) {
cg.printf(" pva");
}
if (ret) {
cg.printf("\n");
cg.printf("ppres <- peek pres\n");
cg.printf("buildVariant (fromIntegral t) ppres");
}
cg.indentEnd(""); // end do
if (varArgs) {
cg.indentEnd(")"); // end varargs
}
for (int i = 0; i < ac; ++i) {
cg.indentEnd(")"); // end wEV i
}
if (ret) {
cg.indentEnd(")"); // end alloca
} else {
cg.indentEnd("");
}
cg.printf("\n");
return;
}
void MethodStatement::outputCPPFFIStub(CodeGenerator &cg,
AnalysisResultPtr ar) {
FunctionScopePtr funcScope = m_funcScope.lock();
bool varArgs = funcScope->isVariableArgument();
bool ret = funcScope->getReturnType();
string fname = funcScope->getId();
bool inClass = !m_className.empty();
bool isStatic = !inClass || m_modifiers->isStatic();
if (inClass && m_modifiers->isAbstract()) {
return;
}
if (fname == "__lval" || fname == "__offsetget_lval") {
return;
}
if (ret) {
cg.printf("int");
} else {
cg.printf("void");
}
cg.printf(" %s%s%s(", Option::FFIFnPrefix,
(inClass ? (m_className + "_cls_").c_str() : ""), fname.c_str());
if (ret) {
cg.printf("void** res");
}
bool first = !ret;
if (!isStatic) {
// instance methods need one additional parameter for the target
if (first) {
first = false;
}
else {
cg.printf(", ");
}
cg.printf("Variant *target");
}
int ac = funcScope->getMaxParamCount();
for (int i = 0; i < ac; ++i) {
if (first) {
first = false;
} else {
cg.printf(", ");
}
cg.printf("Variant *a%d", i);
}
if (varArgs) {
if (!first) {
cg.printf(", ");
}
cg.printf("Variant *va");
}
cg.printf(")");
if (cg.getContext() == CodeGenerator::CppFFIDecl) {
cg.printf(";\n");
} else {
cg.indentBegin(" {\n");
if (ret) {
cg.printf("return hphp_ffi_exportVariant(");
}
if (!inClass) {
// simple function call
cg.printf("%s%s(", Option::FunctionPrefix, fname.c_str());
}
else if (isStatic) {
// static method call
cg.printf("%s%s::%s%s(", Option::ClassPrefix, m_className.c_str(),
Option::MethodPrefix, fname.c_str());
}
else {
// instance method call
cg.printf("dynamic_cast<%s%s *>(target->getObjectData())->",
Option::ClassPrefix, m_className.c_str());
cg.printf("%s%s(", Option::MethodPrefix, fname.c_str());
}
first = true;
if (varArgs) {
cg.printf("%d + (va->isNull() ? 0 : va->getArrayData()->size())", ac);
first = false;
}
for (int i = 0; i < ac; ++i) {
if (first) {
first = false;
} else {
cg.printf(", ");
}
cg.printf("*a%d", i);
}
if (varArgs) {
cg.printf(", va->toArray()");
}
if (ret) {
cg.printf("), res");
}
cg.printf(");\n");
cg.indentEnd("} /* function */\n");
}
return;
}
void MethodStatement::outputJavaFFICPPStub(CodeGenerator &cg,
AnalysisResultPtr ar) {
// TODO translate PHP namespace once that is supported
string packageName = Option::JavaFFIRootPackage;
FunctionScopePtr funcScope = m_funcScope.lock();
bool varArgs = funcScope->isVariableArgument();
bool ret = funcScope->getReturnType();
bool inClass = !m_className.empty();
bool isStatic = !inClass || m_modifiers->isStatic();
string fname = funcScope->getId();
int ac = funcScope->getMaxParamCount();
bool exposeNative = !(ac > 0 || varArgs || !isStatic || !ret && inClass);
if (inClass && m_modifiers->isAbstract()) {
// skip all the abstract methods, because hphp doesn't generate code
// for them
return;
}
if (fname == "__lval" || fname == "__offsetget_lval") return;
const char *clsName;
if (inClass) {
// uses capitalized original class name
ClassScopePtr cls = ar->findClass(m_className);
clsName = cls->getOriginalName();
}
else {
clsName = "HphpMain";
}
string mangledName = "Java." + packageName + "." + clsName + "." + fname
+ (exposeNative ? "" : "_native");
// all the existing "_" are replaced as "_1"
Util::replaceAll(mangledName, "_", "_1");
Util::replaceAll(mangledName, ".", "_");
cg.printf("JNIEXPORT %s JNICALL\n", ret ? "jobject" : "void");
cg.printf("%s(JNIEnv *env, %s target", mangledName.c_str(),
(isStatic ? "jclass" : "jobject"));
ostringstream args;
bool first = true;
if (!isStatic) {
// instance method also gets an additional argument, which is a Variant
// pointer to the target, encoded in int64
first = false;
cg.printf(", jlong targetPtr");
args << "(Variant *)targetPtr";
}
for (int i = 0; i < ac; i++) {
cg.printf(", jlong a%d", i);
if (first) first = false;
else args << ", ";
args << "(Variant *)a" << i;
}
if (varArgs) {
cg.printf(", jlong va");
if (!first) args << ", ";
args << "(Variant *)va";
}
if (cg.getContext() == CodeGenerator::JavaFFICppDecl) {
// java_stubs.h
cg.printf(");\n\n");
return;
}
cg.indentBegin(") {\n");
// support static/instance methods
if (ret) {
cg.printf("void *result;\n");
cg.printf("int kind = ");
cg.printf("%s%s%s(&result",
Option::FFIFnPrefix,
(inClass ? (m_className + "_cls_").c_str() : ""), fname.c_str());
if (!isStatic || ac > 0 || varArgs) cg.printf(", ");
}
else {
cg.printf("%s%s%s(", Option::FFIFnPrefix,
(inClass ? (m_className + "_cls_").c_str() : ""),
fname.c_str());
}
cg.printf("%s);\n", args.str().c_str());
if (ret) {
if (!inClass) {
// HphpMain extends hphp.Hphp.
cg.printf("jclass hphp = env->GetSuperclass(target);\n");
}
else {
cg.printf("jclass hphp = env->FindClass(\"hphp/Hphp\");\n");
}
cg.printf("return exportVariantToJava(env, hphp, result, kind);\n");
}
cg.indentEnd("} /* function */\n\n");
}
void FunctionStatement::outputCPPImpl(CodeGenerator &cg,
AnalysisResultPtr ar) {
CodeGenerator::Context context = cg.getContext();
FunctionScopePtr funcScope = m_funcScope.lock();
string fname = funcScope->getId(cg).c_str();
bool pseudoMain = funcScope->inPseudoMain();
string origFuncName = !pseudoMain ? funcScope->getOriginalName() :
("run_init::" + funcScope->getFileScope()->getName());
string funcSection;
if (outputFFI(cg, ar)) return;
if (context == CodeGenerator::NoContext) {
string rname = cg.formatLabel(m_name);
if (funcScope->isRedeclaring()) {
cg.printf("g->%s%s = &%s%s;\n", Option::CallInfoPrefix, m_name.c_str(),
Option::CallInfoPrefix, fname.c_str());
}
if (funcScope->isVolatile()) {
cg_printf("g->declareFunctionLit(");
cg_printString(m_name, ar);
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;
ar->pushScope(funcScope);
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);
ar->popScope();
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());
}
if (funcScope->isInlined()) cg_printf("inline ");
TypePtr type = funcScope->getReturnType();
if (type) {
type->outputCPPDecl(cg, ar);
} 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->getFileScope()->pseudoMainName().c_str());
} else {
cg_printf(" %s%s(", Option::FunctionPrefix, fname.c_str());
}
switch (context) {
case CodeGenerator::CppForwardDeclaration:
funcScope->outputCPPParamsDecl(cg, ar, m_params, true);
cg_printf(");\n");
if (funcScope->hasDirectInvoke()) {
cg_printf("Variant %s%s(void *extra, CArrRef params);\n",
Option::InvokePrefix, fname.c_str());
}
break;
case CodeGenerator::CppDeclaration:
case CodeGenerator::CppImplementation:
case CodeGenerator::CppPseudoMain:
{
funcScope->outputCPPParamsDecl(cg, ar, m_params, false);
cg_indentBegin(") {\n");
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->getFileScope()->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.setContext(context);
cg_indentEnd("} /* function */\n");
}
break;
default:
ASSERT(false);
}
ar->popScope();
}
