コード例 #1
0
ファイル: ext.cpp プロジェクト: HyeongKyu/hiphop-php
Variant EvalCreateFunction::InvokeImpl(VariableEnvironment &env,
                                       CArrRef params) {
  int size = params.size();
  if (size != 2) return invalid_function_call("create_function");
  Variant var = params.rvalAt(0);
  Variant body = params.rvalAt(1);

  vector<StaticStatementPtr> statics;
  Block::VariableIndices variableIndices;
  ostringstream fnStream;
  string id(RequestEvalState::unique());
  fnStream << "<?php function lambda_" << id << "(" << var.toString().data() <<
    ") {" << body.toString().data() << "}\n";
  StatementPtr bodyAst = Parser::ParseString(fnStream.str().c_str(), statics,
                                             variableIndices);
  if (!bodyAst) return false;
  ostringstream nameStream;
  nameStream << "$lambda_" << id;
  StatementListStatement *sl = bodyAst->cast<StatementListStatement>();
  FunctionStatement *f = sl->stmts()[0]->cast<FunctionStatement>();
  ASSERT(f);
  f->changeName(nameStream.str());
  SmartPtr<CodeContainer> cc(new StringCodeContainer(bodyAst));
  RequestEvalState::addCodeContainer(cc);
  f->eval(env);
  return f->name();
}
コード例 #2
0
void
SemanticAnalysis::analyzeShadowedFunctions(FunctionSymbol *sym)
{
    // We do not yet support overloading, so two functions with the same name
    // and a body are illegal. We consider natives to be implemented.
    FunctionStatement *impl = nullptr;

    // We support non-native implementations of a forwarded function.
    FunctionStatement *forward = nullptr;

    for (size_t i = 0; i < sym->shadows()->length(); i++) {
        FunctionStatement *stmt = sym->shadows()->at(i);
        switch (stmt->token()) {
        case TOK_FORWARD:
            if (forward) {
                cc_.report(stmt->loc(), rmsg::function_redeclared)
                        << stmt->name()
                        << (cc_.note(forward->loc(), rmsg::previous_location));
                continue;
            }
            forward = stmt;
            break;
        case TOK_NATIVE:
        case TOK_FUNCTION:
            if (impl) {
                cc_.report(stmt->loc(), rmsg::function_redeclared)
                        << stmt->name()
                        << (cc_.note(impl->loc(), rmsg::previous_location));
                continue;
            }
            impl = stmt;
            break;
        default:
            assert(false);
            break;
        }
    }

    // If we have both an impl and a forward, make sure they match.
    if (impl && forward)
        checkForwardedFunction(forward, impl);
}
コード例 #3
0
void
SemanticAnalysis::visitNameProxy(NameProxy *proxy)
{
    Symbol *binding = proxy->sym();
    switch (binding->kind()) {
    case Symbol::kType:
        cc_.report(proxy->loc(), rmsg::cannot_use_type_as_value)
                << binding->asType()->type();
        break;

    case Symbol::kConstant:
    {
        ConstantSymbol *sym = binding->toConstant();
        proxy->setOutput(sym->type(), VK::rvalue);
        break;
    }

    case Symbol::kFunction:
    {
        FunctionSymbol *sym = binding->toFunction();
        FunctionStatement *decl = sym->impl();
        if (!decl) {
            cc_.report(proxy->loc(), rmsg::function_has_no_impl)
                    << sym->name();
            break;
        }

        if (!decl->type())
            decl->setType(FunctionType::New(decl->signature()));

        // Function symbols are clvalues, since they are named.
        // :TODO:
        proxy->setOutput(decl->type(), VK::lvalue);
        break;
    }

    default:
        assert(false);
    }
}