Function main

tests/runtime/v8/hello_fucking_google.cpp:33–231

static v8::UniquePersistent<v8::Promise::Resolver>                global_resolver;

int main(int argc, char* argv[])
{
    // Initialize V8.
    char Flags[] = "--expose-gc";
    v8::V8::SetFlagsFromString(Flags, sizeof(Flags));
    v8::V8::InitializeICUDefaultLocation(argv[0]);
    v8::V8::InitializeExternalStartupData(argv[0]);
    std::unique_ptr<v8::Platform> platform = v8::platform::NewDefaultPlatform();
    v8::V8::InitializePlatform(platform.get());
    v8::V8::Initialize();
    // Create a new Isolate and make it the current one.
    v8::Isolate::CreateParams create_params;
    create_params.array_buffer_allocator = v8::ArrayBuffer::Allocator::NewDefaultAllocator();
    v8::Isolate* isolate                 = v8::Isolate::New(create_params);
    {
        v8::Isolate::Scope isolate_scope(isolate);
        // Create a stack-allocated handle scope.
        v8::HandleScope handle_scope(isolate);
        // Create global template
        v8::Local<v8::ObjectTemplate> global_template = v8::ObjectTemplate::New(isolate);
        {

            // bind user data template
            static auto my_data_ctor_template = v8::FunctionTemplate::New(
            isolate, +[](const v8::FunctionCallbackInfo<v8::Value>& info) {
                v8::Isolate*           Isolate = info.GetIsolate();
                v8::Isolate::Scope     IsolateScope(Isolate);
                v8::HandleScope        HandleScope(Isolate);
                v8::Local<v8::Context> Context = Isolate->GetCurrentContext();
                v8::Context::Scope     ContextScope(Context);

                if (info.IsConstructCall())
                {
                    auto self          = info.This();
                    auto param_content = info[0];
                    auto param_times   = info[1];
                    auto new_data      = new MyData();
                    if (!param_content->IsUndefined())
                    {
                        new_data->content = *v8::String::Utf8Value(info.GetIsolate(), param_content);
                    }
                    if (!param_times->IsUndefined())
                    {
                        new_data->times = param_times->Uint32Value(Context).ToChecked();
                    }
                    self->SetInternalField(0, v8::External::New(info.GetIsolate(), new_data));
                    my_data_instances.try_emplace(new_data);
                    auto& ref = my_data_instances[new_data];
                    ref.Reset(Isolate, self);
                    ref.SetWeak<MyData>(
                    new_data,
                    +[](const v8::WeakCallbackInfo<MyData>& data) {
                        auto ptr = data.GetParameter();
                        printf("==========> call destruct <==========");
                        delete ptr;
                        my_data_instances.erase(my_data_instances.find(ptr));
                    },
                    v8::WeakCallbackType::kInternalFields);