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"); }
/** * 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 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(); }