Use C/C to implement Node.js modules (1)_node.js

A pitfall that occurred a long time ago - using Node.js to reconstruct NBUT's Online Judge, including the evaluation side, also had to be reconstructed. (As for when it will be completed, don’t worry about it, (／‵Д′)／~ ╧╧

In short, what we have to do now is actually to use C/C to implement the Node.js module.

Preparation

If a worker wants to do his job well, he must first~~play a rogue~~ and sharpen his tools.

node-gyp

First you need a node-gyp module.

At any corner, execute:

Copy code The code is as follows:

$ npm install node-gyp -g

After a series of blahblahs, you are installed.

Python

　Then you need a python environment.

Go to the official website to get one yourself.

Note: According to node-gyp's GitHub, please make sure your python version is between 2.5.0 and 3.0.0.

Compilation environment

Well, I’m just too lazy to write it down in detail. Please go to node-gyp to see the compiler requirements. And pour it well.

Getting Started

Let me just talk about the introductory Hello World on the official website.

Hello World

Please prepare a C file, for example, call it ~~sb.cc~~ hello.cc.

Then let’s go step by step, first create the header file and define the namespace:

Copy code The code is as follows:

#include
#include
using namespace v8;

Main function

Next we write a function whose return value is Handle.

Copy code The code is as follows:

Handle Hello(const Arguments& args)
{
//... Waiting to be written
}

Then let me briefly analyze these things:

Handle

You must have integrity as a human being. I would like to state in advance that I refer to it from here (@fool).

V8 uses the Handle type to host JavaScript objects. Similar to C's std::sharedpointer, assignments between Handle types directly pass object references, but the difference is that V8 uses its own GC to manage the object life cycle, rather than intelligent Commonly used reference counting for pointers.

JavaScript types have corresponding custom types in C, such as String, Integer, Object, Date, Array, etc., which strictly abide by the inheritance relationship in JavaScript. When using these types in C, you must use Handle management to use the GC to manage their life cycle instead of using the native stack and heap.

This so-called Value can be seen from the various inheritance relationships in the header file v8.h of the V8 engine. It is actually the base class of various objects in JavaScript.

After understanding this matter, we can roughly understand the meaning of the above function declaration, which is that we write a Hello function that returns an indefinite type value.

Note: We can only return specific types, namely String, Integer, etc. under the management of Handle.

Arguments

This is the parameter passed into this function. We all know that in Node.js, the number of parameters is random. When these parameters are passed into C, they are converted into objects of this Arguments type.

We will talk about the specific usage later. Here you just need to understand what this is. (Why are you so careful? Because the examples in the official Node.js documentation are discussed separately. I am just talking about the first Hello World example now (´థ౪థ)σ

Contribution

Then we started to add bricks and tiles. Just two simple sentences:

Copy code The code is as follows:

Handle Hello(const Arguments& args)
{
HandleScope scope;
Return scope.Close(String::New("world"));
}

What do these two sentences mean? The rough meaning is to return a string "world" in Node.js.

HandleScope

The same reference comes from here.

The life cycle of Handle is different from that of C smart pointers. It does not exist within the scope of C semantics (that is, the part surrounded by {}), but needs to be manually specified through HandleScope. HandleScope can only be allocated on the stack. After the HandleScope object is declared, the life cycle of the Handle created subsequently is managed by HandleScope. After the HandleScope object is destructed, the Handle managed by it will be judged by the GC whether to be recycled.

So, we have to declare this Scope when we need to manage its life cycle. Okay, so why doesn't our code look like this?

Copy code The code is as follows:

Handle Hello(const Arguments& args)
{
HandleScope scope;
Return String::New("world");
}

Because when the function returns, the scope will be destructed and the Handles it manages will also be recycled, so this String will become meaningless.

So V8 came up with a magical idea - the HandleScope::Close(Handle Value) function! The purpose of this function is to close this Scope and transfer the parameters inside to the previous Scope for management, that is, the Scope before entering this function.

So there is our previous code scope.Close(String::New("world"));.

String::New

　This String class corresponds to the native string class in Node.js. Inherited from Value class. Similar to this, there is also:

•Array
•Integer
•Boolean
•Object
•Date
•Number
•Function
•...

Some of these things are inherited from Value, and some are inherited twice. We won’t do much research here. You can look at the V8 code (at least the header files) or read this manual.

And what about this New? You can see it here. Just create a new String object.

At this point, we have completed the analysis of this main function.

Export object

Let’s review it. If we write it in Node.js, how do we export functions or objects?

Copy code The code is as follows:

exports.hello = function() {}

So, how do we do this in C?

Initialization function

First, we write an initialization function:

Copy code The code is as follows:

void init(Handle