mirror of
https://github.com/nodejs/node.git
synced 2026-11-09 15:11:11 -05:00
Joyee Cheung
44a5fe1457
Instead of treating config.gypi as a JavaScript file, specialize
the processing in js2c and make the serialized result a real JSON
string (with 'true' and 'false' converted to boolean values) so
we don't have to use a custom deserializer during bootstrap.
In addition, store the JSON string separately in NativeModuleLoader,
and keep it separate from the map of the builtin source code, so
we don't have to put it onto `NativeModule._source` and delete it
later, though we still preserve it in `process.binding('natives')`,
which we don't use anymore.
This patch also makes the map of builtin source code and the
config.gypi string available through side-effect-free getters
in C++.
PR-URL: https://github.com/nodejs/node/pull/24816
Reviewed-By: Gus Caplan <me@gus.host>
104 lines
3.1 KiB
C++
104 lines
3.1 KiB
C++
|
|
#ifndef SRC_NODE_UNION_BYTES_H_
|
|
#define SRC_NODE_UNION_BYTES_H_
|
|
|
|
#if defined(NODE_WANT_INTERNALS) && NODE_WANT_INTERNALS
|
|
|
|
// A union of const uint8_t* or const uint16_t* data that can be
|
|
// turned into external v8::String when given an isolate.
|
|
|
|
#include "env.h"
|
|
#include "v8.h"
|
|
|
|
namespace node {
|
|
|
|
class NonOwningExternalOneByteResource
|
|
: public v8::String::ExternalOneByteStringResource {
|
|
public:
|
|
explicit NonOwningExternalOneByteResource(const uint8_t* data, size_t length)
|
|
: data_(data), length_(length) {}
|
|
~NonOwningExternalOneByteResource() override = default;
|
|
|
|
const char* data() const override {
|
|
return reinterpret_cast<const char*>(data_);
|
|
}
|
|
size_t length() const override { return length_; }
|
|
|
|
private:
|
|
const uint8_t* data_;
|
|
size_t length_;
|
|
DISALLOW_COPY_AND_ASSIGN(NonOwningExternalOneByteResource);
|
|
};
|
|
|
|
class NonOwningExternalTwoByteResource
|
|
: public v8::String::ExternalStringResource {
|
|
public:
|
|
explicit NonOwningExternalTwoByteResource(const uint16_t* data, size_t length)
|
|
: data_(data), length_(length) {}
|
|
~NonOwningExternalTwoByteResource() override = default;
|
|
|
|
const uint16_t* data() const override { return data_; }
|
|
size_t length() const override { return length_; }
|
|
|
|
private:
|
|
const uint16_t* data_;
|
|
size_t length_;
|
|
DISALLOW_COPY_AND_ASSIGN(NonOwningExternalTwoByteResource);
|
|
};
|
|
|
|
// Similar to a v8::String, but it's independent from Isolates
|
|
// and can be materialized in Isolates as external Strings
|
|
// via ToStringChecked. The data pointers are owned by the caller.
|
|
class UnionBytes {
|
|
public:
|
|
UnionBytes(const uint16_t* data, size_t length)
|
|
: is_one_byte_(false), two_bytes_(data), length_(length) {}
|
|
UnionBytes(const uint8_t* data, size_t length)
|
|
: is_one_byte_(true), one_bytes_(data), length_(length) {}
|
|
|
|
UnionBytes(const UnionBytes&) = default;
|
|
UnionBytes& operator=(const UnionBytes&) = default;
|
|
UnionBytes(UnionBytes&&) = default;
|
|
UnionBytes& operator=(UnionBytes&&) = default;
|
|
|
|
bool is_one_byte() const { return is_one_byte_; }
|
|
const uint16_t* two_bytes_data() const {
|
|
CHECK(!is_one_byte_);
|
|
CHECK_NE(two_bytes_, nullptr);
|
|
return two_bytes_;
|
|
}
|
|
const uint8_t* one_bytes_data() const {
|
|
CHECK(is_one_byte_);
|
|
CHECK_NE(one_bytes_, nullptr);
|
|
return one_bytes_;
|
|
}
|
|
v8::Local<v8::String> ToStringChecked(v8::Isolate* isolate) const {
|
|
if (is_one_byte_) {
|
|
CHECK_NE(one_bytes_, nullptr);
|
|
NonOwningExternalOneByteResource* source =
|
|
new NonOwningExternalOneByteResource(one_bytes_, length_);
|
|
return v8::String::NewExternalOneByte(isolate, source).ToLocalChecked();
|
|
} else {
|
|
CHECK_NE(two_bytes_, nullptr);
|
|
NonOwningExternalTwoByteResource* source =
|
|
new NonOwningExternalTwoByteResource(two_bytes_, length_);
|
|
return v8::String::NewExternalTwoByte(isolate, source).ToLocalChecked();
|
|
}
|
|
}
|
|
size_t length() { return length_; }
|
|
|
|
private:
|
|
bool is_one_byte_;
|
|
union {
|
|
const uint8_t* one_bytes_;
|
|
const uint16_t* two_bytes_;
|
|
};
|
|
size_t length_;
|
|
};
|
|
|
|
} // namespace node
|
|
|
|
#endif // defined(NODE_WANT_INTERNALS) && NODE_WANT_INTERNALS
|
|
|
|
#endif // SRC_NODE_UNION_BYTES_H_
|