mirrors/bun.sh
1
0
Fork 0
mirror of https://github.com/oven-sh/bun synced 2026-02-12 11:59:00 +00:00
Code Issues Packages Projects Releases Wiki Activity

cool

Browse Source 
Former-commit-id: a7214ab61c
This commit is contained in:
Jarred Sumner
2021-07-26 16:39:40 -07:00
parent 5354a44d6a
commit 84d7234f24
26 changed files with 1709 additions and 835 deletions
Download Patch File Download Diff File Expand all files Collapse all files

2
src/javascript/jsc/WebKit

Submodule src/javascript/jsc/WebKit updated: 7d49458124...4eb8a5a13b

38
src/javascript/jsc/bindings/SourceProvider.cpp Normal file
View File

@@ -0,0 +1,38 @@
#include "root.h"
#include <JavaScriptCore/SourceProvider.h>
#include <wtf/Lock.h>
namespace JSC {
// SourceProvider::SourceProvider(const SourceOrigin&, String&& sourceURL, const TextPosition& startPosition, SourceProviderSourceType) {
// }
// SourceProvider::SourceProvider(const SourceOrigin& sourceOrigin, String&& sourceURL, const TextPosition& startPosition, SourceProviderSourceType sourceType)
// : m_sourceType(sourceType)
// , m_sourceOrigin(sourceOrigin)
// , m_sourceURL(WTFMove(sourceURL))
// , m_startPosition(startPosition)
// {
// }
// SourceProvider::~SourceProvider()
// {
// }
// static Lock providerIdLock;
// void SourceProvider::getID()
// {
// Locker locker { providerIdLock };
// if (!m_id) {
// static intptr_t nextProviderID = 0;
// m_id = ++nextProviderID;
// RELEASE_ASSERT(m_id);
// }
// }
} // namespace JSC

40
src/javascript/jsc/bindings/ZigConsoleClient.cpp
View File

@@ -13,6 +13,7 @@ using JSGlobalObject = JSC__JSGlobalObject;
using String = WTF::String;
extern "C" {
JSC__JSValue Inspector__ScriptArguments__argumentAt(const Inspector__ScriptArguments* arg0, size_t i) {
return JSC::JSValue::encode(arg0->argumentAt(i));
}
@@ -29,57 +30,60 @@ bWTF__String Inspector__ScriptArguments__getFirstArgumentAsString(const Inspecto
bool Inspector__ScriptArguments__isEqual(const Inspector__ScriptArguments* arg0, const Inspector__ScriptArguments* arg1) {
return arg0->isEqual(*arg1);
}
void Inspector__ScriptArguments__release(Inspector__ScriptArguments* arg0) {
arg0->deref();
}
}
void Zig::ConsoleClient::messageWithTypeAndLevel(MessageType type, MessageLevel level, JSC::JSGlobalObject* globalObject, Ref<ScriptArguments>&& arguments) {
Zig__ConsoleClient__messageWithTypeAndLevel(static_cast<uint32_t>(type), static_cast<uint32_t>(level), globalObject, arguments.ptr());
Zig__ConsoleClient__messageWithTypeAndLevel(this->m_client, static_cast<uint32_t>(type), static_cast<uint32_t>(level), globalObject, arguments.ptr());
}
void Zig::ConsoleClient::count(JSGlobalObject* globalObject, const String& label)
{
const char* ptr = reinterpret_cast<const char*>(label.characters8());
Zig__ConsoleClient__count(globalObject, ptr, label.length());
auto ptr = label.characters8();
Zig__ConsoleClient__count(this->m_client, globalObject, ptr, label.length());
}
void Zig::ConsoleClient::countReset(JSGlobalObject* globalObject, const String& label)
{
const char* ptr = reinterpret_cast<const char*>(label.characters8());
Zig__ConsoleClient__countReset(globalObject, ptr, label.length());
auto ptr = label.characters8();
Zig__ConsoleClient__countReset(this->m_client, globalObject, ptr, label.length());
}
void Zig::ConsoleClient::profile(JSC::JSGlobalObject* globalObject, const String& label)
{
const char* ptr = reinterpret_cast<const char*>(label.characters8());
Zig__ConsoleClient__profile(globalObject, ptr, label.length());
auto ptr = label.characters8();
Zig__ConsoleClient__profile(this->m_client, globalObject, ptr, label.length());
}
void Zig::ConsoleClient::profileEnd(JSC::JSGlobalObject* globalObject, const String& label)
{
const char* ptr = reinterpret_cast<const char*>(label.characters8());
Zig__ConsoleClient__profileEnd(globalObject, ptr, label.length());
auto ptr = label.characters8();
Zig__ConsoleClient__profileEnd(this->m_client, globalObject, ptr, label.length());
}
void Zig::ConsoleClient::takeHeapSnapshot(JSC::JSGlobalObject* globalObject, const String& label)
{
const char* ptr = reinterpret_cast<const char*>(label.characters8());
Zig__ConsoleClient__takeHeapSnapshot(globalObject, ptr, label.length());
auto ptr = label.characters8();
Zig__ConsoleClient__takeHeapSnapshot(this->m_client, globalObject, ptr, label.length());
}
void Zig::ConsoleClient::time(JSGlobalObject* globalObject, const String& label)
{
const char* ptr = reinterpret_cast<const char*>(label.characters8());
Zig__ConsoleClient__time(globalObject, ptr, label.length());
auto ptr = label.characters8();
Zig__ConsoleClient__time(this->m_client, globalObject, ptr, label.length());
}
void Zig::ConsoleClient::timeLog(JSGlobalObject* globalObject, const String& label, Ref<ScriptArguments>&& arguments)
{
const char* ptr = reinterpret_cast<const char*>(label.characters8());
Zig__ConsoleClient__timeLog(globalObject, ptr, label.length(), arguments.ptr());
auto ptr = label.characters8();
Zig__ConsoleClient__timeLog(this->m_client, globalObject, ptr, label.length(), arguments.ptr());
}
void Zig::ConsoleClient::timeEnd(JSGlobalObject* globalObject, const String& label)
{
const char* ptr = reinterpret_cast<const char*>(label.characters8());
Zig__ConsoleClient__timeEnd(globalObject, ptr, label.length());
auto ptr = label.characters8();
Zig__ConsoleClient__timeEnd(this->m_client, globalObject, ptr, label.length());
}
void Zig::ConsoleClient::timeStamp(JSGlobalObject* globalObject, Ref<ScriptArguments>&& args)
{
Zig__ConsoleClient__timeStamp(globalObject, args.ptr());
Zig__ConsoleClient__timeStamp(this->m_client, globalObject, args.ptr());
}
void Zig::ConsoleClient::record(JSGlobalObject*, Ref<ScriptArguments>&&)
{

33
src/javascript/jsc/bindings/ZigConsoleClient.h
View File

@@ -18,8 +18,11 @@ namespace Zig {
class ConsoleClient final : public JSC::ConsoleClient {
WTF_MAKE_FAST_ALLOCATED;
public:
explicit ConsoleClient(InspectorConsoleAgent*);
~ConsoleClient() final { }
ConsoleClient(void* client) : JSC::ConsoleClient() {
m_client = client;
}
static bool logToSystemConsole();
static void setLogToSystemConsole(bool);
@@ -27,20 +30,22 @@ public:
void setDebuggerAgent(InspectorDebuggerAgent* agent) { m_debuggerAgent = agent; }
void setPersistentScriptProfilerAgent(InspectorScriptProfilerAgent* agent) { m_scriptProfilerAgent = agent; }
void* m_client;
private:
void messageWithTypeAndLevel(MessageType, MessageLevel, JSC::JSGlobalObject*, Ref<Inspector::ScriptArguments>&&) final;
void count(JSC::JSGlobalObject*, const String& label) final;
void countReset(JSC::JSGlobalObject*, const String& label) final;
void profile(JSC::JSGlobalObject*, const String& title) final;
void profileEnd(JSC::JSGlobalObject*, const String& title) final;
void takeHeapSnapshot(JSC::JSGlobalObject*, const String& title) final;
void time(JSC::JSGlobalObject*, const String& label) final;
void timeLog(JSC::JSGlobalObject*, const String& label, Ref<Inspector::ScriptArguments>&&) final;
void timeEnd(JSC::JSGlobalObject*, const String& label) final;
void timeStamp(JSC::JSGlobalObject*, Ref<Inspector::ScriptArguments>&&) final;
void record(JSC::JSGlobalObject*, Ref<Inspector::ScriptArguments>&&) final;
void recordEnd(JSC::JSGlobalObject*, Ref<Inspector::ScriptArguments>&&) final;
void screenshot(JSC::JSGlobalObject*, Ref<Inspector::ScriptArguments>&&) final;
void messageWithTypeAndLevel(MessageType, MessageLevel, JSC::JSGlobalObject*, Ref<Inspector::ScriptArguments>&&);
void count(JSC::JSGlobalObject*, const String& label);
void countReset(JSC::JSGlobalObject*, const String& label);
void profile(JSC::JSGlobalObject*, const String& title);
void profileEnd(JSC::JSGlobalObject*, const String& title);
void takeHeapSnapshot(JSC::JSGlobalObject*, const String& title);
void time(JSC::JSGlobalObject*, const String& label);
void timeLog(JSC::JSGlobalObject*, const String& label, Ref<Inspector::ScriptArguments>&&);
void timeEnd(JSC::JSGlobalObject*, const String& label);
void timeStamp(JSC::JSGlobalObject*, Ref<Inspector::ScriptArguments>&&);
void record(JSC::JSGlobalObject*, Ref<Inspector::ScriptArguments>&&);
void recordEnd(JSC::JSGlobalObject*, Ref<Inspector::ScriptArguments>&&);
void screenshot(JSC::JSGlobalObject*, Ref<Inspector::ScriptArguments>&&);
void warnUnimplemented(const String& method);
void internalAddMessage(MessageType, MessageLevel, JSC::JSGlobalObject*, Ref<Inspector::ScriptArguments>&&);

25
src/javascript/jsc/bindings/ZigGlobalObject.cpp
View File

@@ -25,6 +25,7 @@
#include <JavaScriptCore/WasmFaultSignalHandler.h>
#include <JavaScriptCore/JSCast.h>
#include <JavaScriptCore/InitializeThreading.h>
#include "ZigConsoleClient.h"
#include <JavaScriptCore/JSLock.h>
@@ -39,29 +40,31 @@ using SourceOrigin = JSC::SourceOrigin;
namespace JSCastingHelpers = JSC::JSCastingHelpers;
JSC__JSGlobalObject* Zig__GlobalObject__create(JSC__VM* arg0) {
extern "C" JSC__JSGlobalObject* Zig__GlobalObject__create(JSC__VM* arg0, void* console_client) {
auto client = makeUnique<Zig::ConsoleClient>(console_client);
// There are assertions that the apiLock is set while the JSGlobalObject is initialized.
if (arg0 != nullptr) {
JSC::VM& vm = reinterpret_cast<JSC__VM&>(arg0);
vm.apiLock().lock();
Zig::GlobalObject* globalObject = Zig::GlobalObject::create(vm, Zig::GlobalObject::createStructure(vm, JSC::jsNull()));
vm.apiLock().unlock();
Zig::GlobalObject* globalObject = Zig::GlobalObject::create(*arg0, Zig::GlobalObject::createStructure(*arg0, JSC::jsNull()));
JSC::JSLockHolder holder(globalObject);
globalObject->setConsoleClient(makeWeakPtr(*client));
return static_cast<JSC__JSGlobalObject*>(globalObject);
}
JSC::initialize();
JSC::VM& vm = JSC::VM::create(JSC::LargeHeap, nullptr);
vm.apiLock().lock();
JSC::VM& vm = JSC::VM::create(JSC::LargeHeap).leakRef();
#if ENABLE(WEBASSEMBLY)
JSC::Wasm::enableFastMemory();
#endif
JSC::JSLockHolder locker(vm);
auto globalObject = Zig::GlobalObject::create(vm, Zig::GlobalObject::createStructure(vm, JSC::jsNull()));
globalObject->setConsoleClient(makeWeakPtr(*client));
Zig::GlobalObject* globalObject = Zig::GlobalObject::create(vm, Zig::GlobalObject::createStructure(vm, JSC::jsNull()));
vm.apiLock().unlock();
return static_cast<JSC__JSGlobalObject*>(globalObject);
return globalObject;
}
namespace Zig {

8
src/javascript/jsc/bindings/ZigGlobalObject.h
View File

@@ -13,9 +13,13 @@ namespace JSC {
#include <JavaScriptCore/JSGlobalObject.h>
#include <JavaScriptCore/JSTypeInfo.h>
#include "ZigConsoleClient.h"
namespace Zig {
class GlobalObject final : public JSC::JSGlobalObject {
using Base = JSC::JSGlobalObject;
@@ -28,7 +32,7 @@ public:
template<typename CellType, JSC::SubspaceAccess mode>
static JSC::IsoSubspace* subspaceFor(JSC::VM& vm)
{
return vm.apiGlobalObjectSpace<mode>();
return vm.globalObjectSpace<mode>();
}
static GlobalObject* create(JSC::VM& vm, JSC::Structure* structure)
@@ -53,6 +57,8 @@ public:
static JSC::JSObject* moduleLoaderCreateImportMetaProperties(JSGlobalObject*, JSC::JSModuleLoader*, JSC::JSValue, JSC::JSModuleRecord*, JSC::JSValue);
static JSC::JSValue moduleLoaderEvaluate(JSGlobalObject*, JSC::JSModuleLoader*, JSC::JSValue, JSC::JSValue, JSC::JSValue, JSC::JSValue, JSC::JSValue);
static void promiseRejectionTracker(JSGlobalObject*, JSC::JSPromise*, JSC::JSPromiseRejectionOperation);
private:
GlobalObject(JSC::VM& vm, JSC::Structure* structure)

234
src/javascript/jsc/bindings/bindings.cpp
View File

@@ -2,7 +2,7 @@
#include "headers.h"
#include "root.h"
#include "helpers.h"
#include <JavaScriptCore/ExceptionScope.h>
#include <JavaScriptCore/JSObject.h>
@@ -23,8 +23,8 @@
#include <JavaScriptCore/JSString.h>
#include <JavaScriptCore/JSMap.h>
#include <JavaScriptCore/JSSet.h>
#include <JavaScriptCore/JSInternalPromise.h>
#include "helpers.h"
extern "C" {
@@ -42,7 +42,7 @@ JSC__JSObject* JSC__JSCell__getObject(JSC__JSCell* arg0) {
bWTF__String JSC__JSCell__getString(JSC__JSCell* arg0, JSC__JSGlobalObject* arg1) {
return Wrap<WTF__String, bWTF__String>::wrap(arg0->getString(arg1));
}
char JSC__JSCell__getType(JSC__JSCell* arg0) {
unsigned char JSC__JSCell__getType(JSC__JSCell* arg0) {
return arg0->type();
}
@@ -72,7 +72,9 @@ bWTF__String JSC__JSString__value(JSC__JSString* arg0, JSC__JSGlobalObject* arg1
#pragma mark - JSC::JSModuleLoader
// JSC__JSValue JSC__JSModuleLoader__dependencyKeysIfEvaluated(JSC__JSModuleLoader* arg0, JSC__JSGlobalObject* arg1, JSC__JSModuleRecord* arg2);
// JSC__JSValue JSC__JSModuleLoader__dependencyKeysIfEvaluated(JSC__JSModuleLoader* arg0, JSC__JSGlobalObject* arg1, JSC__JSModuleRecord* arg2) {
// arg2->depen
// }
bool JSC__JSModuleLoader__checkSyntax(JSC__JSGlobalObject* arg0, const JSC__SourceCode* arg1, bool arg2) {
JSC::ParserError error;
@@ -88,10 +90,11 @@ bool JSC__JSModuleLoader__checkSyntax(JSC__JSGlobalObject* arg0, const JSC__Sour
}
JSC__JSValue JSC__JSModuleLoader__evaluate(JSC__JSGlobalObject* arg0, const JSC__SourceCode* arg1, JSC__JSValue JSValue2, JSC__Exception** arg3) {
WTF::NakedPtr<JSC::Exception> returnedException;
auto val = JSC::JSValue::encode(JSC::evaluate(arg0, reinterpret_cast<const JSC__SourceCode&>(arg1), JSC::JSValue::decode(JSValue2), returnedException));
auto str2 = arg1->provider()->source();
auto val = JSC::evaluate(arg0, *arg1, JSC::JSValue::decode(JSValue2), returnedException);
auto str = val.toWTFString(arg0);
*arg3 = returnedException.get();
return val;
return JSC::JSValue::encode(val);
}
JSC__JSInternalPromise* JSC__JSModuleLoader__importModule(JSC__JSGlobalObject* arg0, const JSC__Identifier* arg1) {
return JSC::importModule(arg0, reinterpret_cast<JSC::Identifier&>(arg1), JSC::JSValue{}, JSC::JSValue{});
@@ -128,9 +131,7 @@ void JSC__JSPromise__rejectAsHandledException(JSC__JSPromise* arg0, JSC__JSGloba
JSC__JSPromise* JSC__JSPromise__rejectedPromise(JSC__JSGlobalObject* arg0, JSC__JSValue JSValue1) {
return JSC::JSPromise::rejectedPromise(arg0, JSC::JSValue::decode(JSValue1));
}
// void JSC__JSPromise__rejectException(JSC__JSPromise* arg0, JSC__JSGlobalObject* arg1, JSC__Exception* arg2) {
// JSC::JSPromise::rejec
// }
void JSC__JSPromise__rejectWithCaughtException(JSC__JSPromise* arg0, JSC__JSGlobalObject* arg1, bJSC__ThrowScope arg2) {
Wrap<JSC::ThrowScope, bJSC__ThrowScope> wrapped = Wrap<JSC::ThrowScope, bJSC__ThrowScope>(arg2);
@@ -158,6 +159,57 @@ bool JSC__JSPromise__isHandled(const JSC__JSPromise* arg0, JSC__VM* arg1) {
return arg0->isHandled(reinterpret_cast<JSC::VM&>(arg1));
}
#pragma mark - JSC::JSInternalPromise
JSC__JSInternalPromise* JSC__JSInternalPromise__create(JSC__JSGlobalObject* globalObject) {
JSC::VM& vm = globalObject->vm();
return JSC::JSInternalPromise::create(vm, globalObject->internalPromiseStructure());
}
void JSC__JSInternalPromise__reject(JSC__JSInternalPromise* arg0, JSC__JSGlobalObject* arg1, JSC__JSValue JSValue2) {
arg0->reject(arg1, JSC::JSValue::decode(JSValue2));
}
void JSC__JSInternalPromise__rejectAsHandled(JSC__JSInternalPromise* arg0, JSC__JSGlobalObject* arg1, JSC__JSValue JSValue2) {
arg0->rejectAsHandled(arg1, JSC::JSValue::decode(JSValue2));
}
void JSC__JSInternalPromise__rejectAsHandledException(JSC__JSInternalPromise* arg0, JSC__JSGlobalObject* arg1, JSC__Exception* arg2) {
arg0->rejectAsHandled(arg1,arg2);
}
JSC__JSInternalPromise* JSC__JSInternalPromise__rejectedPromise(JSC__JSGlobalObject* arg0, JSC__JSValue JSValue1) {
return reinterpret_cast<JSC::JSInternalPromise*>(JSC::JSInternalPromise::rejectedPromise(arg0, JSC::JSValue::decode(JSValue1)));
}
void JSC__JSInternalPromise__rejectWithCaughtException(JSC__JSInternalPromise* arg0, JSC__JSGlobalObject* arg1, bJSC__ThrowScope arg2) {
Wrap<JSC::ThrowScope, bJSC__ThrowScope> wrapped = Wrap<JSC::ThrowScope, bJSC__ThrowScope>(arg2);
arg0->rejectWithCaughtException(arg1, *wrapped.cpp);
}
void JSC__JSInternalPromise__resolve(JSC__JSInternalPromise* arg0, JSC__JSGlobalObject* arg1, JSC__JSValue JSValue2) {
arg0->resolve(arg1, JSC::JSValue::decode(JSValue2));
}
JSC__JSInternalPromise* JSC__JSInternalPromise__resolvedPromise(JSC__JSGlobalObject* arg0, JSC__JSValue JSValue1) {
return reinterpret_cast<JSC::JSInternalPromise*>(JSC::JSInternalPromise::resolvedPromise(arg0, JSC::JSValue::decode(JSValue1)));
}
JSC__JSValue JSC__JSInternalPromise__result(const JSC__JSInternalPromise* arg0, JSC__VM* arg1) {
return JSC::JSValue::encode(arg0->result(reinterpret_cast<JSC::VM&>(arg1)));
}
uint32_t JSC__JSInternalPromise__status(const JSC__JSInternalPromise* arg0, JSC__VM* arg1) {
switch (arg0->status(reinterpret_cast<JSC::VM&>(arg1))) {
case JSC::JSInternalPromise::Status::Pending: return 0;
case JSC::JSInternalPromise::Status::Fulfilled: return 1;
case JSC::JSInternalPromise::Status::Rejected: return 2;
default: return 255;
}
}
bool JSC__JSInternalPromise__isHandled(const JSC__JSInternalPromise* arg0, JSC__VM* arg1) {
return arg0->isHandled(reinterpret_cast<JSC::VM&>(arg1));
}
JSC__JSInternalPromise* JSC__JSInternalPromise__then(JSC__JSInternalPromise* arg0, JSC__JSGlobalObject* arg1, JSC__JSFunction* arg2, JSC__JSFunction* arg3) {
return arg0->then(arg1, arg2, arg3);
}
// bool JSC__JSPromise__isInternal(JSC__JSPromise* arg0, JSC__VM* arg1) {
// return arg0->inf
@@ -168,55 +220,89 @@ bool JSC__JSPromise__isHandled(const JSC__JSPromise* arg0, JSC__VM* arg1) {
bJSC__SourceOrigin JSC__SourceOrigin__fromURL(const WTF__URL* arg0) {
auto wrap = Wrap<JSC::SourceOrigin, bJSC__SourceOrigin>(JSC::SourceOrigin(reinterpret_cast<const WTF::URL&>(arg0)));
auto wrap = Wrap<JSC::SourceOrigin, bJSC__SourceOrigin>(JSC::SourceOrigin(*arg0));
return wrap.result;
}
#pragma mark - JSC::SourceCode
bJSC__SourceCode JSC__SourceCode__fromString(const WTF__String* arg0, const JSC__SourceOrigin* arg1, WTF__String* arg2, char SourceType3) {
auto wrap = Wrap<JSC::SourceCode, bJSC__SourceCode>(
JSC::makeSource(
reinterpret_cast<const WTF::String&>(arg0),
reinterpret_cast<const JSC::SourceOrigin&>(arg1),
arg2 == nullptr ? WTF::String() : *arg2,
WTF::TextPosition(),
SourceType3 == 0 ? JSC::SourceProviderSourceType::Program : JSC::SourceProviderSourceType::Module
));
// class StringSourceProvider : public JSC::SourceProvider {
// public:
// unsigned hash() const override
// {
// return m_source->hash();
// }
return wrap.result;
// StringView source() const override
// {
// return WTF::StringView(m_source);
// }
// ~StringSourceProvider() {
// }
// WTF::StringImpl *m_source;
// StringSourceProvider(const WTF::String& source, const JSC::SourceOrigin& sourceOrigin, WTF::String&& sourceURL, const WTF::TextPosition& startPosition, JSC::SourceProviderSourceType sourceType)
// : JSC::SourceProvider(sourceOrigin, WTFMove(sourceURL), startPosition, sourceType)
// , m_source(source.isNull() ? WTF::StringImpl::empty() : source.impl())
// {
// }
// };
class CustomStringProvider : public JSC::StringSourceProvider {
public: JS_EXPORT_PRIVATE CustomStringProvider(const WTF::String& source, const JSC::SourceOrigin& sourceOrigin, WTF::String&& sourceURL, const TextPosition& startPosition, JSC::SourceProviderSourceType sourceType)
: JSC::StringSourceProvider(source, sourceOrigin, WTFMove(sourceURL), startPosition, sourceType) {
}
};
void JSC__SourceCode__fromString(JSC__SourceCode* arg0, const WTF__String* arg1, const JSC__SourceOrigin* arg2, WTF__String* arg3, unsigned char SourceType4) {
arg1->impl()->ref();
auto source = CustomStringProvider(
*arg1,
JSC::SourceOrigin(WTF::URL()),
arg3 == nullptr ? WTF::String() : *arg3,
WTF::TextPosition(),
SourceType4 == 0 ? JSC::SourceProviderSourceType::Program : JSC::SourceProviderSourceType::Module
);
*arg0 = JSC::SourceCode(source, 1,0);
}
#pragma mark - JSC::JSFunction
JSC__JSValue JSC__JSFunction__callWithArguments(JSC__JSValue JSValue0, JSC__JSGlobalObject* arg1, JSC__JSValue* arg2, size_t arg3, JSC__Exception** arg4, char* arg5) {
JSC__JSValue JSC__JSFunction__callWithArguments(JSC__JSValue JSValue0, JSC__JSGlobalObject* arg1, JSC__JSValue* arg2, size_t arg3, JSC__Exception** arg4, const char* arg5) {
auto args = makeArgs(arg2, arg3);
return JSC::JSValue::encode(JSC::call(arg1, JSC::JSValue::decode(JSValue0), JSC::JSValue::decode(JSValue0), args, arg5));
}
JSC__JSValue JSC__JSFunction__callWithArgumentsAndThis(JSC__JSValue JSValue0, JSC__JSValue JSValue1, JSC__JSGlobalObject* arg2, JSC__JSValue* arg3, size_t arg4, JSC__Exception** arg5, char* arg6) {
JSC__JSValue JSC__JSFunction__callWithArgumentsAndThis(JSC__JSValue JSValue0, JSC__JSValue JSValue1, JSC__JSGlobalObject* arg2, JSC__JSValue* arg3, size_t arg4, JSC__Exception** arg5, const char* arg6) {
auto args = makeArgs(arg3, arg4);
return JSC::JSValue::encode(JSC::call(arg2, JSC::JSValue::decode(JSValue0), JSC::JSValue::decode(JSValue1), args, arg6));
}
JSC__JSValue JSC__JSFunction__callWithoutAnyArgumentsOrThis(JSC__JSValue JSValue0, JSC__JSGlobalObject* arg1, JSC__Exception** arg2, char* arg3) {
JSC__JSValue JSC__JSFunction__callWithoutAnyArgumentsOrThis(JSC__JSValue JSValue0, JSC__JSGlobalObject* arg1, JSC__Exception** arg2, const char* arg3) {
return JSC::JSValue::encode(JSC::call(arg1, JSC::JSValue::decode(JSValue0), JSC::JSValue::decode(JSValue0), JSC::ArgList(), arg3));
}
JSC__JSValue JSC__JSFunction__callWithThis(JSC__JSValue JSValue0, JSC__JSGlobalObject* arg1, JSC__JSValue JSValue2, JSC__Exception** arg3, char* arg4) {
JSC__JSValue JSC__JSFunction__callWithThis(JSC__JSValue JSValue0, JSC__JSGlobalObject* arg1, JSC__JSValue JSValue2, JSC__Exception** arg3, const char* arg4) {
return JSC::JSValue::encode(JSC::call(arg1, JSC::JSValue::decode(JSValue0), JSC::JSValue::decode(JSValue2), JSC::ArgList(), arg4));
}
JSC__JSValue JSC__JSFunction__constructWithArguments(JSC__JSValue JSValue0, JSC__JSGlobalObject* arg1, JSC__JSValue* arg2, size_t arg3, JSC__Exception** arg4, char* arg5) {
JSC__JSValue JSC__JSFunction__constructWithArguments(JSC__JSValue JSValue0, JSC__JSGlobalObject* arg1, JSC__JSValue* arg2, size_t arg3, JSC__Exception** arg4, const char* arg5) {
auto args = makeArgs(arg2, arg3);
return JSC::JSValue::encode(JSC::construct(arg1, JSC::JSValue::decode(JSValue0), args, arg5));
}
JSC__JSValue JSC__JSFunction__constructWithArgumentsAndNewTarget(JSC__JSValue JSValue0, JSC__JSValue JSValue1, JSC__JSGlobalObject* arg2, JSC__JSValue* arg3, size_t arg4, JSC__Exception** arg5, char* arg6) {
JSC__JSValue JSC__JSFunction__constructWithArgumentsAndNewTarget(JSC__JSValue JSValue0, JSC__JSValue JSValue1, JSC__JSGlobalObject* arg2, JSC__JSValue* arg3, size_t arg4, JSC__Exception** arg5, const char* arg6) {
auto args = makeArgs(arg3, arg4);
return JSC::JSValue::encode(JSC::construct(arg2, JSC::JSValue::decode(JSValue0), JSC::JSValue::decode(JSValue0), args, arg6));
}
JSC__JSValue JSC__JSFunction__constructWithNewTarget(JSC__JSValue JSValue0, JSC__JSGlobalObject* arg1, JSC__JSValue JSValue2, JSC__Exception** arg3, char* arg4) {
JSC__JSValue JSC__JSFunction__constructWithNewTarget(JSC__JSValue JSValue0, JSC__JSGlobalObject* arg1, JSC__JSValue JSValue2, JSC__Exception** arg3, const char* arg4) {
return JSC::JSValue::encode(JSC::construct(arg1, JSC::JSValue::decode(JSValue0), JSC::JSValue::decode(JSValue2), JSC::ArgList(), arg4));
}
JSC__JSValue JSC__JSFunction__constructWithoutAnyArgumentsOrNewTarget(JSC__JSValue JSValue0, JSC__JSGlobalObject* arg1, JSC__Exception** arg2, char* arg3) {
JSC__JSValue JSC__JSFunction__constructWithoutAnyArgumentsOrNewTarget(JSC__JSValue JSValue0, JSC__JSGlobalObject* arg1, JSC__Exception** arg2, const char* arg3) {
return JSC::JSValue::encode(JSC::construct(arg1, JSC::JSValue::decode(JSValue0), JSC::ArgList(), arg3));
}
@@ -233,7 +319,7 @@ JSC__JSFunction* JSC__JSFunction__createFromNative(JSC__JSGlobalObject* arg0, ui
}
// JSC__JSFunction* JSC__JSFunction__createFromSourceCode(
// JSC__JSGlobalObject* arg0,
// const char* arg1,
// const unsigned char* arg1,
// uint16_t arg2,
// JSC__JSValue arg3,
// uint16_t arg4,
@@ -262,7 +348,7 @@ bWTF__String JSC__JSFunction__displayName(JSC__JSFunction* arg0, JSC__VM* arg1)
return wrap.result;
};
bWTF__String JSC__JSFunction__getName(JSC__JSFunction* arg0, JSC__VM* arg1) {
auto wrap = Wrap<WTF::String, bWTF__String>(arg0->name(reinterpret_cast<JSC::VM&>(arg1)));
auto wrap = Wrap<WTF::String, bWTF__String>(arg0->name(reinterpret_cast<JSC::VM&>(arg1)));
return wrap.result;
};
bWTF__String JSC__JSFunction__calculatedDisplayName(JSC__JSFunction* arg0, JSC__VM* arg1) {
@@ -299,7 +385,7 @@ JSC__JSObject* JSC__JSGlobalObject__symbolPrototype(JSC__JSGlobalObject* arg0) {
JSC__VM* JSC__JSGlobalObject__vm(JSC__JSGlobalObject* arg0) {
return &arg0->vm();
};
// JSC__JSObject* JSC__JSGlobalObject__createError(JSC__JSGlobalObject* arg0, char ErrorType1, WTF__String* arg2) {};
// JSC__JSObject* JSC__JSGlobalObject__createError(JSC__JSGlobalObject* arg0, unsigned char ErrorType1, WTF__String* arg2) {};
// JSC__JSObject* JSC__JSGlobalObject__throwError(JSC__JSGlobalObject* arg0, JSC__JSObject* arg1) {};
@@ -341,7 +427,14 @@ bool JSC__JSValue__isBigInt32(JSC__JSValue JSValue0) { return JSC::JSValue::deco
bool JSC__JSValue__isBoolean(JSC__JSValue JSValue0) { return JSC::JSValue::decode(JSValue0).isBoolean(); }
bool JSC__JSValue__isCell(JSC__JSValue JSValue0) { return JSC::JSValue::decode(JSValue0).isCell(); }
bool JSC__JSValue__isCustomGetterSetter(JSC__JSValue JSValue0) { return JSC::JSValue::decode(JSValue0).isCustomGetterSetter(); }
// bool JSC__JSValue__isError(JSC__JSValue JSValue0) { return JSC::JSValue::decode(JSValue0).getPrototype() }
bool JSC__JSValue__isError(JSC__JSValue JSValue0) {
JSC::JSObject* obj = JSC::JSValue::decode(JSValue0).getObject();
return obj != nullptr && obj->isErrorInstance();
}
bool JSC__JSValue__isCallable(JSC__JSValue JSValue0, JSC__VM* arg1) {
return JSC::JSValue::decode(JSValue0).isCallable(reinterpret_cast<JSC::VM&>(arg1));
}
bool JSC__JSValue__isGetterSetter(JSC__JSValue JSValue0) { return JSC::JSValue::decode(JSValue0).isGetterSetter(); }
bool JSC__JSValue__isHeapBigInt(JSC__JSValue JSValue0) { return JSC::JSValue::decode(JSValue0).isHeapBigInt(); }
bool JSC__JSValue__isInt32AsAnyInt(JSC__JSValue JSValue0) { return JSC::JSValue::decode(JSValue0).isInt32AsAnyInt(); }
@@ -357,7 +450,7 @@ bool JSC__JSValue__isUndefinedOrNull(JSC__JSValue JSValue0) { return JSC::JSValu
JSC__JSValue JSC__JSValue__jsBoolean(bool arg0) { return JSC::JSValue::encode(JSC::jsBoolean(arg0)); };
JSC__JSValue JSC__JSValue__jsDoubleNumber(double arg0) {return JSC::JSValue::encode(JSC::jsNumber(arg0)); }
JSC__JSValue JSC__JSValue__jsNull() { return JSC::JSValue::encode(JSC::jsNull()); };
JSC__JSValue JSC__JSValue__jsNumberFromChar(char arg0) { return JSC::JSValue::encode(JSC::jsNumber(arg0));};
JSC__JSValue JSC__JSValue__jsNumberFromChar(unsigned char arg0) { return JSC::JSValue::encode(JSC::jsNumber(arg0));};
JSC__JSValue JSC__JSValue__jsNumberFromDouble(double arg0) { return JSC::JSValue::encode(JSC::jsNumber(arg0));};
JSC__JSValue JSC__JSValue__jsNumberFromInt32(int32_t arg0) { return JSC::JSValue::encode(JSC::jsNumber(arg0));};
JSC__JSValue JSC__JSValue__jsNumberFromInt64(int64_t arg0) { return JSC::JSValue::encode(JSC::jsNumber(arg0));};
@@ -389,7 +482,7 @@ JSC__JSString* JSC__JSValue__toStringOrNull(JSC__JSValue JSValue0, JSC__JSGlobal
}
bWTF__String JSC__JSValue__toWTFString(JSC__JSValue JSValue0, JSC__JSGlobalObject* arg1) {
JSC::JSValue value = JSC::JSValue::decode(JSValue0);
return Wrap<WTF::String, bWTF__String>(value.toWTFString(arg1));
return Wrap<WTF::String, bWTF__String>::wrap(value.toWTFString(arg1));
};
#pragma mark - JSC::PropertyName
@@ -413,7 +506,7 @@ const WTF__StringImpl* JSC__PropertyName__uid(JSC__PropertyName* arg0) {
JSC__JSLock* JSC__VM__apiLock(JSC__VM* arg0) {
return makeRefPtr((*arg0).apiLock()).leakRef();
}
JSC__VM* JSC__VM__create(char HeapType0) {
JSC__VM* JSC__VM__create(unsigned char HeapType0) {
JSC::VM* vm = &JSC::VM::create(HeapType0 == JSC::SmallHeap ? JSC::SmallHeap : JSC::LargeHeap).leakRef();
#if ENABLE(WEBASSEMBLY)
JSC::Wasm::enableFastMemory();
@@ -446,7 +539,7 @@ void JSC__VM__setExecutionForbidden(JSC__VM* arg0, bool arg1) {
(*arg0).setExecutionForbidden();
}
bool JSC__VM__throwError(JSC__VM* arg0, JSC__JSGlobalObject* arg1, JSC__ThrowScope* arg2, const char* arg3, size_t arg4) {
bool JSC__VM__throwError(JSC__VM* arg0, JSC__JSGlobalObject* arg1, JSC__ThrowScope* arg2, const unsigned char* arg3, size_t arg4) {
auto scope = arg2;
auto global = arg1;
const String& message = WTF::String(arg3, arg4);
@@ -458,7 +551,7 @@ bool JSC__VM__throwError(JSC__VM* arg0, JSC__JSGlobalObject* arg1, JSC__ThrowSco
void JSC__ThrowScope__clearException(JSC__ThrowScope* arg0) {
arg0->clearException();
};
bJSC__ThrowScope JSC__ThrowScope__declare(JSC__VM* arg0, char* arg1, char* arg2, size_t arg3) {
bJSC__ThrowScope JSC__ThrowScope__declare(JSC__VM* arg0, unsigned char* arg1, unsigned char* arg2, size_t arg3) {
Wrap<JSC::ThrowScope, bJSC__ThrowScope> wrapped = Wrap<JSC::ThrowScope, bJSC__ThrowScope>();
wrapped.cpp = new (wrapped.alignedBuffer()) JSC::ThrowScope(reinterpret_cast<JSC::VM&>(arg0));
return wrapped.result;
@@ -475,7 +568,7 @@ void JSC__ThrowScope__release(JSC__ThrowScope* arg0) {
void JSC__CatchScope__clearException(JSC__CatchScope* arg0) {
arg0->clearException();
}
bJSC__CatchScope JSC__CatchScope__declare(JSC__VM* arg0, char* arg1, char* arg2, size_t arg3) {
bJSC__CatchScope JSC__CatchScope__declare(JSC__VM* arg0, unsigned char* arg1, unsigned char* arg2, size_t arg3) {
JSC::CatchScope scope = JSC::CatchScope(reinterpret_cast<JSC::VM&>(arg0));
return cast<bJSC__CatchScope>(&scope);
}
@@ -507,13 +600,17 @@ JSC__JSValue JSC__CallFrame__uncheckedArgument(const JSC__CallFrame* arg0, uint1
#pragma mark - JSC::Identifier
void JSC__Identifier__deinit(const JSC__Identifier* arg0) {
}
bool JSC__Identifier__eqlIdent(const JSC__Identifier* arg0, const JSC__Identifier* arg1) {
return arg0 == arg1;
};
bool JSC__Identifier__eqlStringImpl(const JSC__Identifier* arg0, const WTF__StringImpl* arg1) {
return JSC::Identifier::equal(arg0->string().impl(), arg1);
};
bool JSC__Identifier__eqlUTF8(const JSC__Identifier* arg0, const char* arg1, size_t arg2) {
bool JSC__Identifier__eqlUTF8(const JSC__Identifier* arg0, const unsigned char* arg1, size_t arg2) {
return JSC::Identifier::equal(arg0->string().impl(), reinterpret_cast<const LChar*>(arg1), arg2);
};
bool JSC__Identifier__neqlIdent(const JSC__Identifier* arg0, const JSC__Identifier* arg1) {
@@ -523,7 +620,7 @@ bool JSC__Identifier__neqlStringImpl(const JSC__Identifier* arg0, const WTF__Str
return !JSC::Identifier::equal(arg0->string().impl(), arg1);
};
bJSC__Identifier JSC__Identifier__fromSlice(JSC__VM* arg0, const char* arg1, size_t arg2) {
bJSC__Identifier JSC__Identifier__fromSlice(JSC__VM* arg0, const unsigned char* arg1, size_t arg2) {
JSC::Identifier ident = JSC::Identifier::fromString(reinterpret_cast<JSC__VM&>(arg0), reinterpret_cast<const LChar*>(arg1), static_cast<int>(arg2));
return cast<bJSC__Identifier>(&ident);
};
@@ -563,8 +660,8 @@ const uint16_t* WTF__StringView__characters16(const WTF__StringView* arg0) {
WTF::StringView* view = (WTF::StringView*)arg0;
return reinterpret_cast<const uint16_t*>(view->characters16());
}
const char* WTF__StringView__characters8(const WTF__StringView* arg0) {
return reinterpret_cast<const char*>(arg0->characters8());
const unsigned char* WTF__StringView__characters8(const WTF__StringView* arg0) {
return reinterpret_cast<const unsigned char*>(arg0->characters8());
};
bool WTF__StringView__is16Bit(const WTF__StringView* arg0) {return !arg0->is8Bit(); };
@@ -577,13 +674,12 @@ size_t WTF__StringView__length(const WTF__StringView* arg0) {return arg0->length
const uint16_t* WTF__StringImpl__characters16(const WTF__StringImpl* arg0) {
return reinterpret_cast<const uint16_t*>(arg0->characters16());
}
const char* WTF__StringImpl__characters8(const WTF__StringImpl* arg0) {
return reinterpret_cast<const char*>(arg0->characters8());
const unsigned char* WTF__StringImpl__characters8(const WTF__StringImpl* arg0) {
return reinterpret_cast<const unsigned char*>(arg0->characters8());
}
bWTF__StringView WTF__StringView__from8Bit(const char* arg0, size_t arg1) {
WTF::StringView view = WTF::StringView(arg0, arg1);
return cast<bWTF__StringView>(&view);
void WTF__StringView__from8Bit(WTF__StringView* arg0, const unsigned char* arg1, size_t arg2) {
*arg0 = WTF::StringView(arg1, arg2);
}
bool WTF__StringImpl__is16Bit(const WTF__StringImpl* arg0) {
@@ -611,8 +707,8 @@ size_t WTF__StringImpl__length(const WTF__StringImpl* arg0) {
const uint16_t* WTF__ExternalStringImpl__characters16(const WTF__ExternalStringImpl* arg0) {
return reinterpret_cast<const uint16_t*>(arg0->characters16());
}
const char* WTF__ExternalStringImpl__characters8(const WTF__ExternalStringImpl* arg0) {
return reinterpret_cast<const char*>(arg0->characters8());
const unsigned char* WTF__ExternalStringImpl__characters8(const WTF__ExternalStringImpl* arg0) {
return reinterpret_cast<const unsigned char*>(arg0->characters8());
}
@@ -641,11 +737,11 @@ size_t WTF__ExternalStringImpl__length(const WTF__ExternalStringImpl* arg0) {
const uint16_t* WTF__String__characters16(WTF__String* arg0) {
return reinterpret_cast<const uint16_t*>(arg0->characters16());
};
const char* WTF__String__characters8(WTF__String* arg0) {
return reinterpret_cast<const char*>(arg0->characters8());
const unsigned char* WTF__String__characters8(WTF__String* arg0) {
return reinterpret_cast<const unsigned char*>(arg0->characters8());
};
bool WTF__String__eqlSlice(WTF__String* arg0, const char* arg1, size_t arg2) {
bool WTF__String__eqlSlice(WTF__String* arg0, const unsigned char* arg1, size_t arg2) {
return WTF::equal(arg0->impl(), reinterpret_cast<const LChar*>(arg1), arg2);
}
bool WTF__String__eqlString(WTF__String* arg0, const WTF__String* arg1) {
@@ -663,13 +759,12 @@ bool WTF__String__isStatic(WTF__String* arg0) {return arg0->impl()->isStatic();}
size_t WTF__String__length(WTF__String* arg0) {return arg0->length();}
bWTF__String WTF__String__createFromExternalString(bWTF__ExternalStringImpl arg0) {
WTF::ExternalStringImpl* external = cast<WTF::ExternalStringImpl*>(&arg0);
WTF::String string = WTF::String(external);
return ccast<bWTF__String>(&string);
auto external = Wrap<WTF::ExternalStringImpl, bWTF__ExternalStringImpl>(arg0);
return Wrap<WTF::String, bWTF__String>(WTF::String(external.cpp)).result;
};
bWTF__String WTF__String__createWithoutCopyingFromPtr(const char* arg0, size_t arg1) {
const WTF::String string = WTF::String(WTF::StringImpl::createWithoutCopying(reinterpret_cast<const LChar*>(arg0), arg1));
return ccast<bWTF__String>(&string);
void WTF__String__createWithoutCopyingFromPtr(WTF__String* str, unsigned char* arg0, size_t arg1) {
*str = WTF::String(arg0, arg1);
}
#pragma mark - WTF::URL
@@ -694,9 +789,10 @@ bWTF__StringView WTF__URL__fragmentIdentifierWithLeadingNumberSign(WTF__URL* arg
auto result = arg0->fragmentIdentifierWithLeadingNumberSign();
return cast<bWTF__StringView>(&result);
};
bWTF__URL WTF__URL__fromFileSystemPath(bWTF__StringView arg0) {
auto url = WTF::URL::fileURLWithFileSystemPath(cast<WTF::StringView>(&arg0));
return cast<bWTF__URL>(&url);
void WTF__URL__fromFileSystemPath(WTF::URL* result, bWTF__StringView arg0) {
Wrap<WTF::StringView, bWTF__StringView> fsPath = Wrap<WTF::StringView, bWTF__StringView>(&arg0);
*result = WTF::URL::fileURLWithFileSystemPath(*fsPath.cpp);
result->string().impl()->ref();
};
bWTF__URL WTF__URL__fromString(bWTF__String arg0, bWTF__String arg1) {
WTF::URL url= WTF::URL(WTF::URL(), cast<WTF::String>(&arg1));
@@ -762,25 +858,25 @@ bWTF__String WTF__URL__user(WTF__URL* arg0) {
};
void WTF__URL__setHost(WTF__URL* arg0, bWTF__StringView arg1) {
arg0->setHost(cast<WTF::StringView>(&arg1));
arg0->setHost(*Wrap<WTF::StringView, bWTF__StringView>::unwrap(&arg1));
};
void WTF__URL__setHostAndPort(WTF__URL* arg0, bWTF__StringView arg1) {
arg0->setHostAndPort(cast<WTF::StringView>(&arg1));
arg0->setHostAndPort(*Wrap<WTF::StringView, bWTF__StringView>::unwrap(&arg1));
};
void WTF__URL__setPassword(WTF__URL* arg0, bWTF__StringView arg1) {
arg0->setPassword(cast<WTF::StringView>(&arg1));
arg0->setPassword(*Wrap<WTF::StringView, bWTF__StringView>::unwrap(&arg1));
};
void WTF__URL__setPath(WTF__URL* arg0, bWTF__StringView arg1) {
arg0->setPath(cast<WTF::StringView>(&arg1));
arg0->setPath(*Wrap<WTF::StringView, bWTF__StringView>::unwrap(&arg1));
};
void WTF__URL__setProtocol(WTF__URL* arg0, bWTF__StringView arg1) {
arg0->setProtocol(cast<WTF::StringView>(&arg1));
arg0->setProtocol(*Wrap<WTF::StringView, bWTF__StringView>::unwrap(&arg1));
};
void WTF__URL__setQuery(WTF__URL* arg0, bWTF__StringView arg1) {
arg0->setQuery(cast<WTF::StringView>(&arg1));
arg0->setQuery(*Wrap<WTF::StringView, bWTF__StringView>::unwrap(&arg1));
};
void WTF__URL__setUser(WTF__URL* arg0, bWTF__StringView arg1) {
arg0->setUser(cast<WTF::StringView>(&arg1));
arg0->setUser(*Wrap<WTF::StringView, bWTF__StringView>::unwrap(&arg1));
};
}

595
src/javascript/jsc/bindings/bindings.zig
View File

File diff suppressed because it is too large Load Diff

212
src/javascript/jsc/bindings/exports.zig Normal file
View File

@@ -0,0 +1,212 @@
usingnamespace @import("./bindings.zig");
usingnamespace @import("./shared.zig");
pub const ZigGlobalObject = extern struct {
pub const shim = Shimmer("Zig", "GlobalObject", @This());
bytes: shim.Bytes,
pub const Type = *c_void;
pub const name = "Zig::GlobalObject";
pub const include = "\"ZigGlobalObject.h\"";
pub const namespace = shim.namespace;
pub const Interface: type = NewGlobalObject(std.meta.globalOption("JSGlobalObject", type) orelse struct {});
pub fn create(vm: ?*VM, console: *c_void) *JSGlobalObject {
return shim.cppFn("create", .{ vm, console });
}
pub fn import(global: *JSGlobalObject, loader: *JSModuleLoader, specifier: *JSString, referrer: JSValue, origin: *const SourceOrigin) callconv(.C) *JSInternalPromise {
// if (comptime is_bindgen) {
// unreachable;
// }
return @call(.{ .modifier = .always_inline }, Interface.import, .{ global, loader, specifier, referrer, origin });
}
pub fn resolve(global: *JSGlobalObject, loader: *JSModuleLoader, specifier: JSValue, value: JSValue, origin: *const SourceOrigin) callconv(.C) Identifier {
if (comptime is_bindgen) {
unreachable;
}
return @call(.{ .modifier = .always_inline }, Interface.resolve, .{ global, loader, specifier, value, origin });
}
pub fn fetch(global: *JSGlobalObject, loader: *JSModuleLoader, value1: JSValue, value2: JSValue, value3: JSValue) callconv(.C) *JSInternalPromise {
if (comptime is_bindgen) {
unreachable;
}
return @call(.{ .modifier = .always_inline }, Interface.fetch, .{ global, loader, value1, value2, value3 });
}
pub fn eval(global: *JSGlobalObject, loader: *JSModuleLoader, key: JSValue, moduleRecordValue: JSValue, scriptFetcher: JSValue, awaitedValue: JSValue, resumeMode: JSValue) callconv(.C) JSValue {
if (comptime is_bindgen) {
unreachable;
}
return @call(.{ .modifier = .always_inline }, Interface.eval, .{ global, loader, key, moduleRecordValue, scriptFetcher, awaitedValue, resumeMode });
}
pub fn promiseRejectionTracker(global: *JSGlobalObject, promise: *JSPromise, rejection: JSPromiseRejectionOperation) callconv(.C) JSValue {
if (comptime is_bindgen) {
unreachable;
}
return @call(.{ .modifier = .always_inline }, Interface.promiseRejectionTracker, .{ global, promise, rejection });
}
pub fn reportUncaughtException(global: *JSGlobalObject, exception: *Exception) callconv(.C) JSValue {
if (comptime is_bindgen) {
unreachable;
}
return @call(.{ .modifier = .always_inline }, Interface.reportUncaughtException, .{ global, exception });
}
pub fn createImportMetaProperties(global: *JSGlobalObject, loader: *JSModuleLoader, obj: JSValue, record: *JSModuleRecord, specifier: JSValue) callconv(.C) JSValue {
if (comptime is_bindgen) {
unreachable;
}
return @call(.{ .modifier = .always_inline }, Interface.createImportMetaProperties, .{ global, loader, obj, record, specifier });
}
pub const Export = shim.exportFunctions(.{
.@"import" = import,
.@"resolve" = resolve,
.@"fetch" = fetch,
.@"eval" = eval,
.@"promiseRejectionTracker" = promiseRejectionTracker,
.@"reportUncaughtException" = reportUncaughtException,
.@"createImportMetaProperties" = createImportMetaProperties,
});
pub const Extern = [_][]const u8{"create"};
comptime {
@export(import, .{ .name = Export[0].symbol_name });
@export(resolve, .{ .name = Export[1].symbol_name });
@export(fetch, .{ .name = Export[2].symbol_name });
@export(eval, .{ .name = Export[3].symbol_name });
@export(promiseRejectionTracker, .{ .name = Export[4].symbol_name });
@export(reportUncaughtException, .{ .name = Export[5].symbol_name });
@export(createImportMetaProperties, .{ .name = Export[6].symbol_name });
}
};
pub const ZigConsoleClient = struct {
pub const shim = Shimmer("Zig", "ConsoleClient", @This());
pub const Type = *c_void;
pub const name = "Zig::ConsoleClient";
pub const include = "\"ZigConsoleClient.h\"";
pub const namespace = shim.namespace;
pub const Counter = struct {
// if it turns out a hash table is a better idea we'll do that later
pub const Entry = struct {
hash: u32,
count: u32,
pub const List = std.MultiArrayList(Entry);
};
counts: Entry.List,
allocator: *std.mem.Allocator,
};
const BufferedWriter = std.io.BufferedWriter(4096, Output.WriterType);
error_writer: BufferedWriter,
writer: BufferedWriter,
pub fn init(allocator: *std.mem.Allocator) !*ZigConsoleClient {
var console = try allocator.create(ZigConsoleClient);
console.* = ZigConsoleClient{
.error_writer = BufferedWriter{ .unbuffered_writer = Output.errorWriter() },
.writer = BufferedWriter{ .unbuffered_writer = Output.writer() },
};
return console;
}
pub fn messageWithTypeAndLevel(
console_: ZigConsoleClient.Type,
message_type: u32,
message_level: u32,
global: *JSGlobalObject,
args: *ScriptArguments,
) callconv(.C) void {
var console = zigCast(ZigConsoleClient, console_);
var i: usize = 0;
const len = args.argumentCount();
defer args.release();
var writer = console.writer;
if (len == 1) {
var str = args.getFirstArgumentAsString();
_ = writer.unbuffered_writer.write(str.slice()) catch 0;
return;
}
defer writer.flush() catch {};
while (i < len) : (i += 1) {
var str = args.argumentAt(i).toWTFString(global);
_ = writer.write(str.slice()) catch 0;
}
}
pub fn count(console: ZigConsoleClient.Type, global: *JSGlobalObject, chars: [*]const u8, len: usize) callconv(.C) void {}
pub fn countReset(console: ZigConsoleClient.Type, global: *JSGlobalObject, chars: [*]const u8, len: usize) callconv(.C) void {}
pub fn time(console: ZigConsoleClient.Type, global: *JSGlobalObject, chars: [*]const u8, len: usize) callconv(.C) void {}
pub fn timeLog(console: ZigConsoleClient.Type, global: *JSGlobalObject, chars: [*]const u8, len: usize, args: *ScriptArguments) callconv(.C) void {}
pub fn timeEnd(console: ZigConsoleClient.Type, global: *JSGlobalObject, chars: [*]const u8, len: usize) callconv(.C) void {}
pub fn profile(console: ZigConsoleClient.Type, global: *JSGlobalObject, chars: [*]const u8, len: usize) callconv(.C) void {}
pub fn profileEnd(console: ZigConsoleClient.Type, global: *JSGlobalObject, chars: [*]const u8, len: usize) callconv(.C) void {}
pub fn takeHeapSnapshot(console: ZigConsoleClient.Type, global: *JSGlobalObject, chars: [*]const u8, len: usize) callconv(.C) void {}
pub fn timeStamp(console: ZigConsoleClient.Type, global: *JSGlobalObject, args: *ScriptArguments) callconv(.C) void {}
pub fn record(console: ZigConsoleClient.Type, global: *JSGlobalObject, args: *ScriptArguments) callconv(.C) void {}
pub fn recordEnd(console: ZigConsoleClient.Type, global: *JSGlobalObject, args: *ScriptArguments) callconv(.C) void {}
pub fn screenshot(console: ZigConsoleClient.Type, global: *JSGlobalObject, args: *ScriptArguments) callconv(.C) void {}
pub const Export = shim.exportFunctions(.{
.@"messageWithTypeAndLevel" = messageWithTypeAndLevel,
.@"count" = count,
.@"countReset" = countReset,
.@"time" = time,
.@"timeLog" = timeLog,
.@"timeEnd" = timeEnd,
.@"profile" = profile,
.@"profileEnd" = profileEnd,
.@"takeHeapSnapshot" = takeHeapSnapshot,
.@"timeStamp" = timeStamp,
.@"record" = record,
.@"recordEnd" = recordEnd,
.@"screenshot" = screenshot,
});
comptime {
@export(messageWithTypeAndLevel, .{
.name = Export[0].symbol_name,
});
@export(count, .{
.name = Export[1].symbol_name,
});
@export(countReset, .{
.name = Export[2].symbol_name,
});
@export(time, .{
.name = Export[3].symbol_name,
});
@export(timeLog, .{
.name = Export[4].symbol_name,
});
@export(timeEnd, .{
.name = Export[5].symbol_name,
});
@export(profile, .{
.name = Export[6].symbol_name,
});
@export(profileEnd, .{
.name = Export[7].symbol_name,
});
@export(takeHeapSnapshot, .{
.name = Export[8].symbol_name,
});
@export(timeStamp, .{
.name = Export[9].symbol_name,
});
@export(record, .{
.name = Export[10].symbol_name,
});
@export(recordEnd, .{
.name = Export[11].symbol_name,
});
@export(screenshot, .{
.name = Export[12].symbol_name,
});
}
};

132
src/javascript/jsc/bindings/header-gen.zig
View File

@@ -18,13 +18,19 @@ fn isCppObject(comptime Type: type) bool {
};
}
const ENABLE_REWRITE_RETURN = false;
pub fn cTypeLabel(comptime Type: type) ?[]const u8 {
return switch (comptime Type) {
void => "void",
*StaticExport.c_char => "char*",
*const StaticExport.c_char => "const char*",
StaticExport.c_char => "char",
*void => "void",
bool => "bool",
usize => "size_t",
isize => "int",
u8 => "char",
u8 => "unsigned char",
u16 => "uint16_t",
u32 => "uint32_t",
u64 => "uint64_t",
@@ -39,7 +45,7 @@ pub fn cTypeLabel(comptime Type: type) ?[]const u8 {
[*]bool => "bool*",
[*]usize => "size_t*",
[*]isize => "int*",
[*]u8 => "char*",
[*]u8 => "unsigned char*",
[*]u16 => "uint16_t*",
[*]u32 => "uint32_t*",
[*]u64 => "uint64_t*",
@@ -50,7 +56,7 @@ pub fn cTypeLabel(comptime Type: type) ?[]const u8 {
[*]const bool => "const bool*",
[*]const usize => "const size_t*",
[*]const isize => "const int*",
[*]const u8 => "const char*",
[*]const u8 => "const unsigned char*",
[*]const u16 => "const uint16_t*",
[*]const u32 => "const uint32_t*",
[*]const u64 => "const uint64_t*",
@@ -68,7 +74,9 @@ var impl_buffer = std.ArrayList(u8).init(std.heap.c_allocator);
var impl_writer = impl_buffer.writer();
var bufset = std.BufSet.init(std.heap.c_allocator);
var type_names = TypeNameMap.init(std.heap.c_allocator);
var opaque_types = std.BufSet.init(std.heap.c_allocator);
var size_map = std.StringHashMap(u32).init(std.heap.c_allocator);
var align_map = std.StringHashMap(u29).init(std.heap.c_allocator);
pub const C_Generator = struct {
filebase: []const u8,
@@ -99,8 +107,9 @@ pub const C_Generator = struct {
comptime func: FnDecl,
comptime meta: FnMeta,
comptime arg_names: []const []const u8,
comptime rewrite_return: bool,
) void {
switch (meta.calling_convention) {
switch (comptime meta.calling_convention) {
.Naked => self.write("__attribute__((naked)) "),
.Stdcall => self.write("__attribute__((stdcall)) "),
.Fastcall => self.write("__attribute__((fastcall)) "),
@@ -113,18 +122,33 @@ pub const C_Generator = struct {
.export_zig => self.write("ZIG_DECL "),
}
self.writeType(func.return_type);
if (comptime rewrite_return) {
self.writeType(void);
} else {
self.writeType(comptime func.return_type);
}
self.write(" " ++ name ++ "(");
if (comptime rewrite_return) {
self.writeType(comptime func.return_type);
self.write("_buf ret_value");
if (comptime meta.args.len > 0) {
self.write(", ");
}
}
inline for (meta.args) |arg, i| {
const ArgType = arg.arg_type.?;
const ArgType = comptime arg.arg_type.?;
switch (@typeInfo(ArgType)) {
.Fn => {
self.gen_closure(comptime arg.arg_type.?, comptime std.fmt.comptimePrint(" ArgFn{d}", .{i}));
},
else => {
self.writeType(arg.arg_type.?);
self.writeType(comptime arg.arg_type.?);
switch (@typeInfo(ArgType)) {
.Enum => {
self.write(comptime std.fmt.comptimePrint(" {s}{d}", .{ @typeName(ArgType), i }));
@@ -291,17 +315,26 @@ pub const C_Generator = struct {
type_names.put(comptime label, formatted_name) catch unreachable;
if (@typeInfo(TT) == .Struct and @hasField(TT, "bytes")) {
size_map.put(comptime formatted_name, @as(u32, TT.shim.byte_size)) catch unreachable;
align_map.put(comptime formatted_name, @as(u29, TT.shim.align_size)) catch unreachable;
} else if (@typeInfo(TT) == .Opaque) {
opaque_types.insert(comptime label) catch unreachable;
}
} else {
type_names.put(comptime TT.name, formatted_name) catch unreachable;
if (@typeInfo(TT) == .Struct and @hasField(TT, "bytes")) {
size_map.put(comptime formatted_name, @as(u32, TT.shim.byte_size)) catch unreachable;
align_map.put(comptime formatted_name, @as(u29, TT.shim.align_size)) catch unreachable;
} else if (@typeInfo(TT) == .Opaque) {
opaque_types.insert(comptime label) catch unreachable;
}
}
} else {
type_names.put(comptime TT.name, formatted_name) catch unreachable;
if (@typeInfo(TT) == .Struct and @hasField(TT, "bytes")) {
size_map.put(comptime formatted_name, @as(u32, TT.shim.byte_size)) catch unreachable;
align_map.put(comptime formatted_name, @as(u29, TT.shim.align_size)) catch unreachable;
} else if (@typeInfo(TT) == .Opaque) {
opaque_types.insert(comptime TT.name) catch unreachable;
}
}
@@ -460,6 +493,7 @@ pub fn HeaderGen(comptime import: type, comptime fname: []const u8) type {
comptime static_export.Decl().data.Fn,
comptime fn_meta,
comptime std.mem.zeroes([]const []const u8),
false,
);
}
@@ -494,13 +528,13 @@ pub fn HeaderGen(comptime import: type, comptime fname: []const u8) type {
},
.Fn => |func| {
// if (func.) {
const fn_meta = @typeInfo(func.name).Fn;
// blocked by https://github.com/ziglang/zig/issues/8259
gen.gen_func(
prefix ++ "__" ++ name,
func,
fn_meta,
&.{},
comptime prefix ++ "__" ++ name,
comptime func,
comptime func,
comptime &.{},
comptime ENABLE_REWRITE_RETURN and @typeInfo(fn_meta.return_type) == .Struct,
);
},
else => {},
@@ -508,13 +542,13 @@ pub fn HeaderGen(comptime import: type, comptime fname: []const u8) type {
},
.Fn => |func| {
// if (func.) {
const fn_meta = @typeInfo(func.fn_type).Fn;
// blocked by https://github.com/ziglang/zig/issues/8259
gen.gen_func(
prefix ++ "__" ++ name,
func,
fn_meta,
&.{},
comptime prefix ++ "__" ++ name,
comptime func,
comptime @typeInfo(func.fn_type).Fn,
comptime &.{},
comptime ENABLE_REWRITE_RETURN and @typeInfo(func.return_type) == .Struct,
);
},
else => {},
@@ -573,7 +607,7 @@ pub fn HeaderGen(comptime import: type, comptime fname: []const u8) type {
.Type => |Type| {
@setEvalBranchQuota(99999);
const is_container_type = switch (@typeInfo(Type)) {
.Opaque, .Struct => true,
.Opaque, .Struct, .Enum => true,
else => false,
};
if (is_container_type and (@hasDecl(Type, "Extern") or @hasDecl(Type, "Export"))) {
@@ -653,13 +687,17 @@ pub fn HeaderGen(comptime import: type, comptime fname: []const u8) type {
};
gen.direction = C_Generator.Direction.export_zig;
inline for (ExportLIst) |static_export| {
processStaticExport(
self,
file,
&gen,
comptime static_export,
);
if (ExportLIst.len > 0) {
gen.write("\n#ifdef __cplusplus\n\n");
inline for (ExportLIst) |static_export| {
processStaticExport(
self,
file,
&gen,
comptime static_export,
);
}
gen.write("\n#endif\n");
}
}
}
@@ -683,17 +721,41 @@ pub fn HeaderGen(comptime import: type, comptime fname: []const u8) type {
const NamespaceMap = std.StringArrayHashMap(std.BufMap);
var namespaces = NamespaceMap.init(std.heap.c_allocator);
var size_iter = size_map.iterator();
while (size_iter.next()) |size| {
file_writer.print(" typedef struct b{s} {{ unsigned char bytes[{d}]; }} b{s};\n", .{
size.key_ptr.*,
// align_map.get(size.key_ptr.*).?,
size.value_ptr.*,
size.key_ptr.*,
}) catch unreachable;
file_writer.print(" typedef char* b{s}_buf;\n", .{
size.key_ptr.*,
}) catch unreachable;
}
file_writer.writeAll("\n#ifndef __cplusplus\n") catch unreachable;
while (iter.next()) |entry| {
const key = entry.key_ptr.*;
const value = entry.value_ptr.*;
if (std.mem.indexOfScalar(u8, entry.key_ptr.*, ':')) |namespace_start| {
const namespace = entry.key_ptr.*[0..namespace_start];
file_writer.print(" typedef struct {s} {s}; // {s}\n", .{
value,
value,
key,
}) catch unreachable;
if (opaque_types.contains(entry.key_ptr.*)) {
file_writer.print(" typedef struct {s} {s}; // {s}\n", .{
value,
value,
key,
}) catch unreachable;
} else {
file_writer.print(" typedef b{s} {s}; // {s}\n", .{
value,
value,
key,
}) catch unreachable;
}
if (!namespaces.contains(namespace)) {
namespaces.put(namespace, std.BufMap.init(std.heap.c_allocator)) catch unreachable;
}
@@ -713,14 +775,6 @@ pub fn HeaderGen(comptime import: type, comptime fname: []const u8) type {
}
file_writer.writeAll("\n#endif\n") catch unreachable;
var size_iter = size_map.iterator();
while (size_iter.next()) |size| {
file_writer.print(" typedef struct b{s} {{ char bytes[{d}]; }} b{s};\n", .{
size.key_ptr.*,
size.value_ptr.*,
size.key_ptr.*,
}) catch unreachable;
}
file_writer.writeAll("\n#ifdef __cplusplus\n") catch unreachable;

56
src/javascript/jsc/bindings/headers-cpp.h
View File

@@ -1,4 +1,4 @@
//-- AUTOGENERATED FILE -- 1627163531
//-- AUTOGENERATED FILE -- 1627342675
#pragma once
#include <stddef.h>
@@ -39,30 +39,6 @@ extern "C" const size_t JSC__JSString_object_align_ = alignof(JSC::JSString);
extern "C" const size_t Inspector__ScriptArguments_object_size_ = sizeof(Inspector::ScriptArguments);
extern "C" const size_t Inspector__ScriptArguments_object_align_ = alignof(Inspector::ScriptArguments);
#ifndef INCLUDED__ZigGlobalObject_h_
#define INCLUDED__ZigGlobalObject_h_
#include "ZigGlobalObject.h"
#endif
extern "C" const size_t Zig__GlobalObject_object_size_ = sizeof(Zig::GlobalObject);
extern "C" const size_t Zig__GlobalObject_object_align_ = alignof(Zig::GlobalObject);
#ifndef INCLUDED__ZigConsoleClient_h_
#define INCLUDED__ZigConsoleClient_h_
#include "ZigConsoleClient.h"
#endif
extern "C" const size_t Zig__ConsoleClient_object_size_ = sizeof(Zig::ConsoleClient);
extern "C" const size_t Zig__ConsoleClient_object_align_ = alignof(Zig::ConsoleClient);
#ifndef INCLUDED__DefaultGlobal_h_
#define INCLUDED__DefaultGlobal_h_
#include "DefaultGlobal.h"
#endif
extern "C" const size_t Wundle__DefaultGlobal_object_size_ = sizeof(Wundle::DefaultGlobal);
extern "C" const size_t Wundle__DefaultGlobal_object_align_ = alignof(Wundle::DefaultGlobal);
#ifndef INCLUDED__JavaScriptCore_JSModuleLoader_h_
#define INCLUDED__JavaScriptCore_JSModuleLoader_h_
#include <JavaScriptCore/JSModuleLoader.h>
@@ -143,6 +119,14 @@ extern "C" const size_t WTF__URL_object_align_ = alignof(WTF::URL);
extern "C" const size_t WTF__String_object_size_ = sizeof(WTF::String);
extern "C" const size_t WTF__String_object_align_ = alignof(WTF::String);
#ifndef INCLUDED__JavaScriptCore_JSValue_h_
#define INCLUDED__JavaScriptCore_JSValue_h_
#include <JavaScriptCore/JSValue.h>
#endif
extern "C" const size_t JSC__JSValue_object_size_ = sizeof(JSC::JSValue);
extern "C" const size_t JSC__JSValue_object_align_ = alignof(JSC::JSValue);
#ifndef INCLUDED__JavaScriptCore_PropertyName_h_
#define INCLUDED__JavaScriptCore_PropertyName_h_
#include <JavaScriptCore/PropertyName.h>
@@ -223,8 +207,24 @@ extern "C" const size_t WTF__ExternalStringImpl_object_align_ = alignof(WTF::Ext
extern "C" const size_t WTF__StringView_object_size_ = sizeof(WTF::StringView);
extern "C" const size_t WTF__StringView_object_align_ = alignof(WTF::StringView);
const size_t sizes[26] = {sizeof(JSC::JSObject), sizeof(JSC::JSCell), sizeof(JSC::JSString), sizeof(Inspector::ScriptArguments), sizeof(Zig::GlobalObject), sizeof(Wundle::DefaultGlobal), sizeof(JSC::JSModuleLoader), sizeof(JSC::JSModuleRecord), sizeof(JSC::JSPromise), sizeof(JSC::JSInternalPromise), sizeof(JSC::SourceOrigin), sizeof(JSC::SourceCode), sizeof(JSC::JSFunction), sizeof(JSC::JSGlobalObject), sizeof(WTF::URL), sizeof(WTF::String), sizeof(JSC::PropertyName), sizeof(JSC::Exception), sizeof(JSC::VM), sizeof(JSC::ThrowScope), sizeof(JSC::CatchScope), sizeof(JSC::CallFrame), sizeof(JSC::Identifier), sizeof(WTF::StringImpl), sizeof(WTF::ExternalStringImpl), sizeof(WTF::StringView)};
#ifndef INCLUDED__ZigGlobalObject_h_
#define INCLUDED__ZigGlobalObject_h_
#include "ZigGlobalObject.h"
#endif
const char* names[26] = {"JSC__JSObject", "JSC__JSCell", "JSC__JSString", "Inspector__ScriptArguments", "Zig__GlobalObject", "Wundle__DefaultGlobal", "JSC__JSModuleLoader", "JSC__JSModuleRecord", "JSC__JSPromise", "JSC__JSInternalPromise", "JSC__SourceOrigin", "JSC__SourceCode", "JSC__JSFunction", "JSC__JSGlobalObject", "WTF__URL", "WTF__String", "JSC__PropertyName", "JSC__Exception", "JSC__VM", "JSC__ThrowScope", "JSC__CatchScope", "JSC__CallFrame", "JSC__Identifier", "WTF__StringImpl", "WTF__ExternalStringImpl", "WTF__StringView"};
extern "C" const size_t Zig__GlobalObject_object_size_ = sizeof(Zig::GlobalObject);
extern "C" const size_t Zig__GlobalObject_object_align_ = alignof(Zig::GlobalObject);
const size_t aligns[26] = {alignof(JSC::JSObject), alignof(JSC::JSCell), alignof(JSC::JSString), alignof(Inspector::ScriptArguments), alignof(Zig::GlobalObject), alignof(Wundle::DefaultGlobal), alignof(JSC::JSModuleLoader), alignof(JSC::JSModuleRecord), alignof(JSC::JSPromise), alignof(JSC::JSInternalPromise), alignof(JSC::SourceOrigin), alignof(JSC::SourceCode), alignof(JSC::JSFunction), alignof(JSC::JSGlobalObject), alignof(WTF::URL), alignof(WTF::String), alignof(JSC::PropertyName), alignof(JSC::Exception), alignof(JSC::VM), alignof(JSC::ThrowScope), alignof(JSC::CatchScope), alignof(JSC::CallFrame), alignof(JSC::Identifier), alignof(WTF::StringImpl), alignof(WTF::ExternalStringImpl), alignof(WTF::StringView)};
#ifndef INCLUDED__ZigConsoleClient_h_
#define INCLUDED__ZigConsoleClient_h_
#include "ZigConsoleClient.h"
#endif
extern "C" const size_t Zig__ConsoleClient_object_size_ = sizeof(Zig::ConsoleClient);
extern "C" const size_t Zig__ConsoleClient_object_align_ = alignof(Zig::ConsoleClient);
const size_t sizes[26] = {sizeof(JSC::JSObject), sizeof(JSC::JSCell), sizeof(JSC::JSString), sizeof(Inspector::ScriptArguments), sizeof(JSC::JSModuleLoader), sizeof(JSC::JSModuleRecord), sizeof(JSC::JSPromise), sizeof(JSC::JSInternalPromise), sizeof(JSC::SourceOrigin), sizeof(JSC::SourceCode), sizeof(JSC::JSFunction), sizeof(JSC::JSGlobalObject), sizeof(WTF::URL), sizeof(WTF::String), sizeof(JSC::JSValue), sizeof(JSC::PropertyName), sizeof(JSC::Exception), sizeof(JSC::VM), sizeof(JSC::ThrowScope), sizeof(JSC::CatchScope), sizeof(JSC::CallFrame), sizeof(JSC::Identifier), sizeof(WTF::StringImpl), sizeof(WTF::ExternalStringImpl), sizeof(WTF::StringView), sizeof(Zig::GlobalObject)};
const char* names[26] = {"JSC__JSObject", "JSC__JSCell", "JSC__JSString", "Inspector__ScriptArguments", "JSC__JSModuleLoader", "JSC__JSModuleRecord", "JSC__JSPromise", "JSC__JSInternalPromise", "JSC__SourceOrigin", "JSC__SourceCode", "JSC__JSFunction", "JSC__JSGlobalObject", "WTF__URL", "WTF__String", "JSC__JSValue", "JSC__PropertyName", "JSC__Exception", "JSC__VM", "JSC__ThrowScope", "JSC__CatchScope", "JSC__CallFrame", "JSC__Identifier", "WTF__StringImpl", "WTF__ExternalStringImpl", "WTF__StringView", "Zig__GlobalObject"};
const size_t aligns[26] = {alignof(JSC::JSObject), alignof(JSC::JSCell), alignof(JSC::JSString), alignof(Inspector::ScriptArguments), alignof(JSC::JSModuleLoader), alignof(JSC::JSModuleRecord), alignof(JSC::JSPromise), alignof(JSC::JSInternalPromise), alignof(JSC::SourceOrigin), alignof(JSC::SourceCode), alignof(JSC::JSFunction), alignof(JSC::JSGlobalObject), alignof(WTF::URL), alignof(WTF::String), alignof(JSC::JSValue), alignof(JSC::PropertyName), alignof(JSC::Exception), alignof(JSC::VM), alignof(JSC::ThrowScope), alignof(JSC::CatchScope), alignof(JSC::CallFrame), alignof(JSC::Identifier), alignof(WTF::StringImpl), alignof(WTF::ExternalStringImpl), alignof(WTF::StringView), alignof(Zig::GlobalObject)};

317
src/javascript/jsc/bindings/headers.h
View File

@@ -1,4 +1,4 @@
//-- AUTOGENERATED FILE -- 1627163531
//-- AUTOGENERATED FILE -- 1627342675
#pragma once
#include <stddef.h>
@@ -14,81 +14,103 @@
#define CPP_DECL AUTO_EXTERN_C
#define CPP_SIZE AUTO_EXTERN_C
typedef struct bJSC__JSModuleRecord { unsigned char bytes[216]; } bJSC__JSModuleRecord;
typedef char* bJSC__JSModuleRecord_buf;
typedef struct bJSC__ThrowScope { unsigned char bytes[8]; } bJSC__ThrowScope;
typedef char* bJSC__ThrowScope_buf;
typedef struct bJSC__PropertyName { unsigned char bytes[8]; } bJSC__PropertyName;
typedef char* bJSC__PropertyName_buf;
typedef struct bJSC__CallFrame { unsigned char bytes[8]; } bJSC__CallFrame;
typedef char* bJSC__CallFrame_buf;
typedef struct bJSC__CatchScope { unsigned char bytes[8]; } bJSC__CatchScope;
typedef char* bJSC__CatchScope_buf;
typedef struct bWTF__String { unsigned char bytes[8]; } bWTF__String;
typedef char* bWTF__String_buf;
typedef struct bWTF__StringView { unsigned char bytes[16]; } bWTF__StringView;
typedef char* bWTF__StringView_buf;
typedef struct bJSC__JSModuleLoader { unsigned char bytes[16]; } bJSC__JSModuleLoader;
typedef char* bJSC__JSModuleLoader_buf;
typedef struct bJSC__Exception { unsigned char bytes[40]; } bJSC__Exception;
typedef char* bJSC__Exception_buf;
typedef struct bJSC__VM { unsigned char bytes[48824]; } bJSC__VM;
typedef char* bJSC__VM_buf;
typedef struct bJSC__JSString { unsigned char bytes[16]; } bJSC__JSString;
typedef char* bJSC__JSString_buf;
typedef struct bJSC__SourceOrigin { unsigned char bytes[48]; } bJSC__SourceOrigin;
typedef char* bJSC__SourceOrigin_buf;
typedef struct bWTF__ExternalStringImpl { unsigned char bytes[32]; } bWTF__ExternalStringImpl;
typedef char* bWTF__ExternalStringImpl_buf;
typedef struct bWTF__StringImpl { unsigned char bytes[24]; } bWTF__StringImpl;
typedef char* bWTF__StringImpl_buf;
typedef struct bJSC__JSPromise { unsigned char bytes[32]; } bJSC__JSPromise;
typedef char* bJSC__JSPromise_buf;
typedef struct bJSC__SourceCode { unsigned char bytes[24]; } bJSC__SourceCode;
typedef char* bJSC__SourceCode_buf;
typedef struct bWTF__URL { unsigned char bytes[40]; } bWTF__URL;
typedef char* bWTF__URL_buf;
typedef struct bJSC__JSFunction { unsigned char bytes[32]; } bJSC__JSFunction;
typedef char* bJSC__JSFunction_buf;
typedef struct bJSC__JSGlobalObject { unsigned char bytes[2400]; } bJSC__JSGlobalObject;
typedef char* bJSC__JSGlobalObject_buf;
typedef struct bJSC__JSCell { unsigned char bytes[8]; } bJSC__JSCell;
typedef char* bJSC__JSCell_buf;
typedef struct bJSC__JSLock { unsigned char bytes[40]; } bJSC__JSLock;
typedef char* bJSC__JSLock_buf;
typedef struct bInspector__ScriptArguments { unsigned char bytes[32]; } bInspector__ScriptArguments;
typedef char* bInspector__ScriptArguments_buf;
typedef struct bJSC__JSInternalPromise { unsigned char bytes[32]; } bJSC__JSInternalPromise;
typedef char* bJSC__JSInternalPromise_buf;
typedef struct bJSC__JSObject { unsigned char bytes[16]; } bJSC__JSObject;
typedef char* bJSC__JSObject_buf;
typedef struct bJSC__Identifier { unsigned char bytes[8]; } bJSC__Identifier;
typedef char* bJSC__Identifier_buf;
#ifndef __cplusplus
typedef struct JSC__RegExpPrototype JSC__RegExpPrototype; // JSC::RegExpPrototype
typedef struct JSC__GeneratorPrototype JSC__GeneratorPrototype; // JSC::GeneratorPrototype
typedef struct JSC__ArrayIteratorPrototype JSC__ArrayIteratorPrototype; // JSC::ArrayIteratorPrototype
typedef struct JSC__StringPrototype JSC__StringPrototype; // JSC::StringPrototype
typedef struct WTF__StringView WTF__StringView; // WTF::StringView
typedef bWTF__StringView WTF__StringView; // WTF::StringView
typedef struct JSC__JSPromisePrototype JSC__JSPromisePrototype; // JSC::JSPromisePrototype
typedef struct JSC__CatchScope JSC__CatchScope; // JSC::CatchScope
typedef struct JSC__ThrowScope JSC__ThrowScope; // JSC::ThrowScope
typedef struct JSC__PropertyName JSC__PropertyName; // JSC::PropertyName
typedef struct JSC__JSObject JSC__JSObject; // JSC::JSObject
typedef struct WTF__ExternalStringImpl WTF__ExternalStringImpl; // WTF::ExternalStringImpl
typedef bJSC__CatchScope JSC__CatchScope; // JSC::CatchScope
typedef bJSC__ThrowScope JSC__ThrowScope; // JSC::ThrowScope
typedef bJSC__PropertyName JSC__PropertyName; // JSC::PropertyName
typedef bJSC__JSObject JSC__JSObject; // JSC::JSObject
typedef bWTF__ExternalStringImpl WTF__ExternalStringImpl; // WTF::ExternalStringImpl
typedef struct JSC__AsyncIteratorPrototype JSC__AsyncIteratorPrototype; // JSC::AsyncIteratorPrototype
typedef struct WTF__StringImpl WTF__StringImpl; // WTF::StringImpl
typedef struct JSC__JSLock JSC__JSLock; // JSC::JSLock
typedef struct JSC__JSModuleLoader JSC__JSModuleLoader; // JSC::JSModuleLoader
typedef struct JSC__VM JSC__VM; // JSC::VM
typedef bWTF__StringImpl WTF__StringImpl; // WTF::StringImpl
typedef bJSC__JSLock JSC__JSLock; // JSC::JSLock
typedef bJSC__JSModuleLoader JSC__JSModuleLoader; // JSC::JSModuleLoader
typedef bJSC__VM JSC__VM; // JSC::VM
typedef struct JSC__AsyncGeneratorPrototype JSC__AsyncGeneratorPrototype; // JSC::AsyncGeneratorPrototype
typedef struct JSC__AsyncGeneratorFunctionPrototype JSC__AsyncGeneratorFunctionPrototype; // JSC::AsyncGeneratorFunctionPrototype
typedef struct JSC__JSGlobalObject JSC__JSGlobalObject; // JSC::JSGlobalObject
typedef struct Wundle__DefaultGlobal Wundle__DefaultGlobal; // Wundle::DefaultGlobal
typedef struct JSC__JSFunction JSC__JSFunction; // JSC::JSFunction
typedef bJSC__JSGlobalObject JSC__JSGlobalObject; // JSC::JSGlobalObject
typedef bJSC__JSFunction JSC__JSFunction; // JSC::JSFunction
typedef struct JSC__ArrayPrototype JSC__ArrayPrototype; // JSC::ArrayPrototype
typedef struct JSC__Identifier JSC__Identifier; // JSC::Identifier
typedef struct JSC__JSPromise JSC__JSPromise; // JSC::JSPromise
typedef struct JSC__AsyncFunctionPrototype JSC__AsyncFunctionPrototype; // JSC::AsyncFunctionPrototype
typedef bJSC__Identifier JSC__Identifier; // JSC::Identifier
typedef bJSC__JSPromise JSC__JSPromise; // JSC::JSPromise
typedef struct JSC__SetIteratorPrototype JSC__SetIteratorPrototype; // JSC::SetIteratorPrototype
typedef struct JSC__SourceCode JSC__SourceCode; // JSC::SourceCode
typedef struct JSC__JSCell JSC__JSCell; // JSC::JSCell
typedef bJSC__SourceCode JSC__SourceCode; // JSC::SourceCode
typedef bJSC__JSCell JSC__JSCell; // JSC::JSCell
typedef struct JSC__BigIntPrototype JSC__BigIntPrototype; // JSC::BigIntPrototype
typedef struct JSC__GeneratorFunctionPrototype JSC__GeneratorFunctionPrototype; // JSC::GeneratorFunctionPrototype
typedef struct JSC__SourceOrigin JSC__SourceOrigin; // JSC::SourceOrigin
typedef struct JSC__JSModuleRecord JSC__JSModuleRecord; // JSC::JSModuleRecord
typedef struct WTF__String WTF__String; // WTF::String
typedef struct WTF__URL WTF__URL; // WTF::URL
typedef bJSC__SourceOrigin JSC__SourceOrigin; // JSC::SourceOrigin
typedef bJSC__JSModuleRecord JSC__JSModuleRecord; // JSC::JSModuleRecord
typedef bWTF__String WTF__String; // WTF::String
typedef bWTF__URL WTF__URL; // WTF::URL
typedef int64_t JSC__JSValue;
typedef struct JSC__IteratorPrototype JSC__IteratorPrototype; // JSC::IteratorPrototype
typedef struct JSC__JSInternalPromise JSC__JSInternalPromise; // JSC::JSInternalPromise
typedef bJSC__JSInternalPromise JSC__JSInternalPromise; // JSC::JSInternalPromise
typedef struct JSC__FunctionPrototype JSC__FunctionPrototype; // JSC::FunctionPrototype
typedef struct Inspector__ScriptArguments Inspector__ScriptArguments; // Inspector::ScriptArguments
typedef struct JSC__Exception JSC__Exception; // JSC::Exception
typedef struct JSC__JSString JSC__JSString; // JSC::JSString
typedef struct Zig__ConsoleClient Zig__ConsoleClient; // Zig::ConsoleClient
typedef bInspector__ScriptArguments Inspector__ScriptArguments; // Inspector::ScriptArguments
typedef bJSC__Exception JSC__Exception; // JSC::Exception
typedef bJSC__JSString JSC__JSString; // JSC::JSString
typedef struct JSC__ObjectPrototype JSC__ObjectPrototype; // JSC::ObjectPrototype
typedef struct JSC__CallFrame JSC__CallFrame; // JSC::CallFrame
typedef bJSC__CallFrame JSC__CallFrame; // JSC::CallFrame
typedef struct JSC__MapIteratorPrototype JSC__MapIteratorPrototype; // JSC::MapIteratorPrototype
#endif
typedef struct bJSC__JSModuleRecord { char bytes[344]; } bJSC__JSModuleRecord;
typedef struct bJSC__ThrowScope { char bytes[8]; } bJSC__ThrowScope;
typedef struct bJSC__PropertyName { char bytes[8]; } bJSC__PropertyName;
typedef struct bJSC__CallFrame { char bytes[8]; } bJSC__CallFrame;
typedef struct bJSC__CatchScope { char bytes[8]; } bJSC__CatchScope;
typedef struct bWTF__String { char bytes[8]; } bWTF__String;
typedef struct bWTF__StringView { char bytes[24]; } bWTF__StringView;
typedef struct bJSC__JSModuleLoader { char bytes[16]; } bJSC__JSModuleLoader;
typedef struct bJSC__SourceOrigin { char bytes[48]; } bJSC__SourceOrigin;
typedef struct bJSC__VM { char bytes[49080]; } bJSC__VM;
typedef struct bJSC__JSString { char bytes[16]; } bJSC__JSString;
typedef struct bJSC__Exception { char bytes[40]; } bJSC__Exception;
typedef struct bWTF__ExternalStringImpl { char bytes[32]; } bWTF__ExternalStringImpl;
typedef struct bWTF__StringImpl { char bytes[24]; } bWTF__StringImpl;
typedef struct bJSC__SourceCode { char bytes[24]; } bJSC__SourceCode;
typedef struct bJSC__JSPromise { char bytes[32]; } bJSC__JSPromise;
typedef struct bWTF__URL { char bytes[40]; } bWTF__URL;
typedef struct bJSC__JSFunction { char bytes[32]; } bJSC__JSFunction;
typedef struct bJSC__JSGlobalObject { char bytes[2464]; } bJSC__JSGlobalObject;
typedef struct bJSC__JSCell { char bytes[8]; } bJSC__JSCell;
typedef struct bJSC__JSLock { char bytes[40]; } bJSC__JSLock;
typedef struct bInspector__ScriptArguments { char bytes[32]; } bInspector__ScriptArguments;
typedef struct bWundle__DefaultGlobal { char bytes[2464]; } bWundle__DefaultGlobal;
typedef struct bJSC__JSInternalPromise { char bytes[32]; } bJSC__JSInternalPromise;
typedef struct bJSC__JSObject { char bytes[16]; } bJSC__JSObject;
typedef struct bJSC__Identifier { char bytes[8]; } bJSC__Identifier;
#ifdef __cplusplus
namespace JSC {
@@ -136,15 +158,9 @@
class StringView;
class ExternalStringImpl;
}
namespace Wundle {
class DefaultGlobal;
}
namespace Inspector {
class ScriptArguments;
}
namespace Zig {
class ConsoleClient;
}
typedef int64_t JSC__JSValue;
using JSC__JSCell = JSC::JSCell;
@@ -188,9 +204,7 @@
using WTF__String = WTF::String;
using WTF__StringView = WTF::StringView;
using WTF__ExternalStringImpl = WTF::ExternalStringImpl;
using Wundle__DefaultGlobal = Wundle::DefaultGlobal;
using Inspector__ScriptArguments = Inspector::ScriptArguments;
using Zig__ConsoleClient = Zig::ConsoleClient;
#endif
@@ -205,7 +219,7 @@ CPP_DECL bool JSC__JSObject__putAtIndex(JSC__JSObject* arg0, JSC__JSGlobalObject
CPP_DECL JSC__JSObject* JSC__JSCell__getObject(JSC__JSCell* arg0);
CPP_DECL bWTF__String JSC__JSCell__getString(JSC__JSCell* arg0, JSC__JSGlobalObject* arg1);
CPP_DECL char JSC__JSCell__getType(JSC__JSCell* arg0);
CPP_DECL unsigned char JSC__JSCell__getType(JSC__JSCell* arg0);
#pragma mark - JSC::JSString
@@ -215,7 +229,7 @@ CPP_DECL bool JSC__JSString__eql(const JSC__JSString* arg0, JSC__JSGlobalObject*
CPP_DECL bool JSC__JSString__is8Bit(const JSC__JSString* arg0);
CPP_DECL size_t JSC__JSString__length(const JSC__JSString* arg0);
CPP_DECL JSC__JSObject* JSC__JSString__toObject(JSC__JSString* arg0, JSC__JSGlobalObject* arg1);
CPP_DECL bWTF__String JSC__JSString__value(JSC__JSString* arg0, JSC__JSGlobalObject* arg1);
CPP_DECL void JSC__JSString__value(bWTF__String arg0, JSC__JSString* arg1, JSC__JSGlobalObject* arg2);
#pragma mark - Inspector::ScriptArguments
@@ -225,42 +239,9 @@ CPP_DECL bWTF__String Inspector__ScriptArguments__getFirstArgumentAsString(const
CPP_DECL bool Inspector__ScriptArguments__isEqual(const Inspector__ScriptArguments* arg0, const Inspector__ScriptArguments* arg1);
CPP_DECL void Inspector__ScriptArguments__release(Inspector__ScriptArguments* arg0);
#pragma mark - Zig::GlobalObject
CPP_DECL JSC__JSGlobalObject* Zig__GlobalObject__create(JSC__VM* arg0, Zig__ConsoleClient* arg1);
ZIG_DECL JSC__JSValue Zig__GlobalObject__createImportMetaProperties(JSC__JSGlobalObject* arg0, JSC__JSModuleLoader* arg1, JSC__JSValue JSValue2, JSC__JSModuleRecord* arg3, JSC__JSValue JSValue4);
ZIG_DECL JSC__JSValue Zig__GlobalObject__eval(JSC__JSGlobalObject* arg0, JSC__JSModuleLoader* arg1, JSC__JSValue JSValue2, JSC__JSValue JSValue3, JSC__JSValue JSValue4, JSC__JSValue JSValue5, JSC__JSValue JSValue6);
ZIG_DECL JSC__JSInternalPromise* Zig__GlobalObject__fetch(JSC__JSGlobalObject* arg0, JSC__JSModuleLoader* arg1, JSC__JSValue JSValue2, JSC__JSValue JSValue3, JSC__JSValue JSValue4);
ZIG_DECL JSC__JSInternalPromise* Zig__GlobalObject__import(JSC__JSGlobalObject* arg0, JSC__JSModuleLoader* arg1, JSC__JSString* arg2, JSC__JSValue JSValue3, const JSC__SourceOrigin* arg4);
ZIG_DECL JSC__JSValue Zig__GlobalObject__promiseRejectionTracker(JSC__JSGlobalObject* arg0, JSC__JSPromise* arg1, uint32_t JSPromiseRejectionOperation2);
ZIG_DECL JSC__JSValue Zig__GlobalObject__reportUncaughtException(JSC__JSGlobalObject* arg0, JSC__Exception* arg1);
ZIG_DECL bJSC__Identifier Zig__GlobalObject__resolve(JSC__JSGlobalObject* arg0, JSC__JSModuleLoader* arg1, JSC__JSValue JSValue2, JSC__JSValue JSValue3, const JSC__SourceOrigin* arg4);
#pragma mark - Zig::ConsoleClient
ZIG_DECL void Zig__ConsoleClient__count(JSC__JSGlobalObject* arg0, const char* arg1, size_t arg2);
ZIG_DECL void Zig__ConsoleClient__countReset(JSC__JSGlobalObject* arg0, const char* arg1, size_t arg2);
ZIG_DECL void Zig__ConsoleClient__messageWithTypeAndLevel(uint32_t arg0, uint32_t arg1, JSC__JSGlobalObject* arg2, Inspector__ScriptArguments* arg3);
ZIG_DECL void Zig__ConsoleClient__profile(JSC__JSGlobalObject* arg0, const char* arg1, size_t arg2);
ZIG_DECL void Zig__ConsoleClient__profileEnd(JSC__JSGlobalObject* arg0, const char* arg1, size_t arg2);
ZIG_DECL void Zig__ConsoleClient__record(JSC__JSGlobalObject* arg0, Inspector__ScriptArguments* arg1);
ZIG_DECL void Zig__ConsoleClient__recordEnd(JSC__JSGlobalObject* arg0, Inspector__ScriptArguments* arg1);
ZIG_DECL void Zig__ConsoleClient__screenshot(JSC__JSGlobalObject* arg0, Inspector__ScriptArguments* arg1);
ZIG_DECL void Zig__ConsoleClient__takeHeapSnapshot(JSC__JSGlobalObject* arg0, const char* arg1, size_t arg2);
ZIG_DECL void Zig__ConsoleClient__time(JSC__JSGlobalObject* arg0, const char* arg1, size_t arg2);
ZIG_DECL void Zig__ConsoleClient__timeEnd(JSC__JSGlobalObject* arg0, const char* arg1, size_t arg2);
ZIG_DECL void Zig__ConsoleClient__timeLog(JSC__JSGlobalObject* arg0, const char* arg1, size_t arg2, Inspector__ScriptArguments* arg3);
ZIG_DECL void Zig__ConsoleClient__timeStamp(JSC__JSGlobalObject* arg0, Inspector__ScriptArguments* arg1);
#pragma mark - Wundle::DefaultGlobal
CPP_DECL Wundle__DefaultGlobal* Wundle__DefaultGlobal__create(Wundle__DefaultGlobal* arg0, void* arg1);
CPP_DECL void* Wundle__DefaultGlobal__getWrapper(Wundle__DefaultGlobal* arg0);
#pragma mark - JSC::JSModuleLoader
CPP_DECL bool JSC__JSModuleLoader__checkSyntax(JSC__JSGlobalObject* arg0, const JSC__SourceCode* arg1, bool arg2);
CPP_DECL JSC__JSValue JSC__JSModuleLoader__dependencyKeysIfEvaluated(JSC__JSModuleLoader* arg0, JSC__JSGlobalObject* arg1, JSC__JSModuleRecord* arg2);
CPP_DECL JSC__JSValue JSC__JSModuleLoader__evaluate(JSC__JSGlobalObject* arg0, const JSC__SourceCode* arg1, JSC__JSValue JSValue2, JSC__Exception** arg3);
CPP_DECL JSC__JSInternalPromise* JSC__JSModuleLoader__importModule(JSC__JSGlobalObject* arg0, const JSC__Identifier* arg1);
CPP_DECL JSC__JSValue JSC__JSModuleLoader__linkAndEvaluateModule(JSC__JSGlobalObject* arg0, const JSC__Identifier* arg1);
@@ -278,7 +259,6 @@ CPP_DECL void JSC__JSPromise__reject(JSC__JSPromise* arg0, JSC__JSGlobalObject*
CPP_DECL void JSC__JSPromise__rejectAsHandled(JSC__JSPromise* arg0, JSC__JSGlobalObject* arg1, JSC__JSValue JSValue2);
CPP_DECL void JSC__JSPromise__rejectAsHandledException(JSC__JSPromise* arg0, JSC__JSGlobalObject* arg1, JSC__Exception* arg2);
CPP_DECL JSC__JSPromise* JSC__JSPromise__rejectedPromise(JSC__JSGlobalObject* arg0, JSC__JSValue JSValue1);
CPP_DECL void JSC__JSPromise__rejectException(JSC__JSPromise* arg0, JSC__JSGlobalObject* arg1, JSC__Exception* arg2);
CPP_DECL void JSC__JSPromise__rejectWithCaughtException(JSC__JSPromise* arg0, JSC__JSGlobalObject* arg1, bJSC__ThrowScope arg2);
CPP_DECL void JSC__JSPromise__resolve(JSC__JSPromise* arg0, JSC__JSGlobalObject* arg1, JSC__JSValue JSValue2);
CPP_DECL JSC__JSPromise* JSC__JSPromise__resolvedPromise(JSC__JSGlobalObject* arg0, JSC__JSValue JSValue1);
@@ -293,7 +273,6 @@ CPP_DECL void JSC__JSInternalPromise__reject(JSC__JSInternalPromise* arg0, JSC__
CPP_DECL void JSC__JSInternalPromise__rejectAsHandled(JSC__JSInternalPromise* arg0, JSC__JSGlobalObject* arg1, JSC__JSValue JSValue2);
CPP_DECL void JSC__JSInternalPromise__rejectAsHandledException(JSC__JSInternalPromise* arg0, JSC__JSGlobalObject* arg1, JSC__Exception* arg2);
CPP_DECL JSC__JSInternalPromise* JSC__JSInternalPromise__rejectedPromise(JSC__JSGlobalObject* arg0, JSC__JSValue JSValue1);
CPP_DECL void JSC__JSInternalPromise__rejectException(JSC__JSInternalPromise* arg0, JSC__JSGlobalObject* arg1, JSC__Exception* arg2);
CPP_DECL void JSC__JSInternalPromise__rejectWithCaughtException(JSC__JSInternalPromise* arg0, JSC__JSGlobalObject* arg1, bJSC__ThrowScope arg2);
CPP_DECL void JSC__JSInternalPromise__resolve(JSC__JSInternalPromise* arg0, JSC__JSGlobalObject* arg1, JSC__JSValue JSValue2);
CPP_DECL JSC__JSInternalPromise* JSC__JSInternalPromise__resolvedPromise(JSC__JSGlobalObject* arg0, JSC__JSValue JSValue1);
@@ -307,21 +286,21 @@ CPP_DECL bJSC__SourceOrigin JSC__SourceOrigin__fromURL(const WTF__URL* arg0);
#pragma mark - JSC::SourceCode
CPP_DECL bJSC__SourceCode JSC__SourceCode__fromString(const WTF__String* arg0, const JSC__SourceOrigin* arg1, WTF__String* arg2, char SourceType3);
CPP_DECL void JSC__SourceCode__fromString(JSC__SourceCode* arg0, const WTF__String* arg1, const JSC__SourceOrigin* arg2, WTF__String* arg3, unsigned char SourceType4);
#pragma mark - JSC::JSFunction
CPP_DECL bWTF__String JSC__JSFunction__calculatedDisplayName(JSC__JSFunction* arg0, JSC__VM* arg1);
CPP_DECL JSC__JSValue JSC__JSFunction__callWithArguments(JSC__JSValue JSValue0, JSC__JSGlobalObject* arg1, JSC__JSValue* arg2, size_t arg3, JSC__Exception** arg4, char* arg5);
CPP_DECL JSC__JSValue JSC__JSFunction__callWithArgumentsAndThis(JSC__JSValue JSValue0, JSC__JSValue JSValue1, JSC__JSGlobalObject* arg2, JSC__JSValue* arg3, size_t arg4, JSC__Exception** arg5, char* arg6);
CPP_DECL JSC__JSValue JSC__JSFunction__callWithoutAnyArgumentsOrThis(JSC__JSValue JSValue0, JSC__JSGlobalObject* arg1, JSC__Exception** arg2, char* arg3);
CPP_DECL JSC__JSValue JSC__JSFunction__callWithThis(JSC__JSValue JSValue0, JSC__JSGlobalObject* arg1, JSC__JSValue JSValue2, JSC__Exception** arg3, char* arg4);
CPP_DECL JSC__JSValue JSC__JSFunction__constructWithArguments(JSC__JSValue JSValue0, JSC__JSGlobalObject* arg1, JSC__JSValue* arg2, size_t arg3, JSC__Exception** arg4, char* arg5);
CPP_DECL JSC__JSValue JSC__JSFunction__constructWithArgumentsAndNewTarget(JSC__JSValue JSValue0, JSC__JSValue JSValue1, JSC__JSGlobalObject* arg2, JSC__JSValue* arg3, size_t arg4, JSC__Exception** arg5, char* arg6);
CPP_DECL JSC__JSValue JSC__JSFunction__constructWithNewTarget(JSC__JSValue JSValue0, JSC__JSGlobalObject* arg1, JSC__JSValue JSValue2, JSC__Exception** arg3, char* arg4);
CPP_DECL JSC__JSValue JSC__JSFunction__constructWithoutAnyArgumentsOrNewTarget(JSC__JSValue JSValue0, JSC__JSGlobalObject* arg1, JSC__Exception** arg2, char* arg3);
CPP_DECL JSC__JSValue JSC__JSFunction__callWithArguments(JSC__JSValue JSValue0, JSC__JSGlobalObject* arg1, JSC__JSValue* arg2, size_t arg3, JSC__Exception** arg4, const char* arg5);
CPP_DECL JSC__JSValue JSC__JSFunction__callWithArgumentsAndThis(JSC__JSValue JSValue0, JSC__JSValue JSValue1, JSC__JSGlobalObject* arg2, JSC__JSValue* arg3, size_t arg4, JSC__Exception** arg5, const char* arg6);
CPP_DECL JSC__JSValue JSC__JSFunction__callWithoutAnyArgumentsOrThis(JSC__JSValue JSValue0, JSC__JSGlobalObject* arg1, JSC__Exception** arg2, const char* arg3);
CPP_DECL JSC__JSValue JSC__JSFunction__callWithThis(JSC__JSValue JSValue0, JSC__JSGlobalObject* arg1, JSC__JSValue JSValue2, JSC__Exception** arg3, const char* arg4);
CPP_DECL JSC__JSValue JSC__JSFunction__constructWithArguments(JSC__JSValue JSValue0, JSC__JSGlobalObject* arg1, JSC__JSValue* arg2, size_t arg3, JSC__Exception** arg4, const char* arg5);
CPP_DECL JSC__JSValue JSC__JSFunction__constructWithArgumentsAndNewTarget(JSC__JSValue JSValue0, JSC__JSValue JSValue1, JSC__JSGlobalObject* arg2, JSC__JSValue* arg3, size_t arg4, JSC__Exception** arg5, const char* arg6);
CPP_DECL JSC__JSValue JSC__JSFunction__constructWithNewTarget(JSC__JSValue JSValue0, JSC__JSGlobalObject* arg1, JSC__JSValue JSValue2, JSC__Exception** arg3, const char* arg4);
CPP_DECL JSC__JSValue JSC__JSFunction__constructWithoutAnyArgumentsOrNewTarget(JSC__JSValue JSValue0, JSC__JSGlobalObject* arg1, JSC__Exception** arg2, const char* arg3);
CPP_DECL JSC__JSFunction* JSC__JSFunction__createFromNative(JSC__JSGlobalObject* arg0, uint16_t arg1, const WTF__String* arg2, void* arg3, JSC__JSValue (* ArgFn4)(void* arg0, JSC__JSGlobalObject* arg1, JSC__CallFrame* arg2));
CPP_DECL JSC__JSFunction* JSC__JSFunction__createFromSourceCode(JSC__JSGlobalObject* arg0, const char* arg1, uint16_t arg2, JSC__JSValue* arg3, uint16_t arg4, const JSC__SourceCode* arg5, JSC__SourceOrigin* arg6, JSC__JSObject** arg7);
CPP_DECL JSC__JSFunction* JSC__JSFunction__createFromSourceCode(JSC__JSGlobalObject* arg0, const unsigned char* arg1, uint16_t arg2, JSC__JSValue* arg3, uint16_t arg4, const JSC__SourceCode* arg5, JSC__SourceOrigin* arg6, JSC__JSObject** arg7);
CPP_DECL bWTF__String JSC__JSFunction__displayName(JSC__JSFunction* arg0, JSC__VM* arg1);
CPP_DECL bWTF__String JSC__JSFunction__getName(JSC__JSFunction* arg0, JSC__VM* arg1);
@@ -335,7 +314,6 @@ CPP_DECL JSC__AsyncGeneratorPrototype* JSC__JSGlobalObject__asyncGeneratorProtot
CPP_DECL JSC__AsyncIteratorPrototype* JSC__JSGlobalObject__asyncIteratorPrototype(JSC__JSGlobalObject* arg0);
CPP_DECL JSC__BigIntPrototype* JSC__JSGlobalObject__bigIntPrototype(JSC__JSGlobalObject* arg0);
CPP_DECL JSC__JSObject* JSC__JSGlobalObject__booleanPrototype(JSC__JSGlobalObject* arg0);
CPP_DECL JSC__JSObject* JSC__JSGlobalObject__createError(JSC__JSGlobalObject* arg0, char ErrorType1, WTF__String* arg2);
CPP_DECL JSC__JSObject* JSC__JSGlobalObject__datePrototype(JSC__JSGlobalObject* arg0);
CPP_DECL JSC__JSObject* JSC__JSGlobalObject__errorPrototype(JSC__JSGlobalObject* arg0);
CPP_DECL JSC__FunctionPrototype* JSC__JSGlobalObject__functionPrototype(JSC__JSGlobalObject* arg0);
@@ -352,7 +330,6 @@ CPP_DECL JSC__RegExpPrototype* JSC__JSGlobalObject__regExpPrototype(JSC__JSGloba
CPP_DECL JSC__SetIteratorPrototype* JSC__JSGlobalObject__setIteratorPrototype(JSC__JSGlobalObject* arg0);
CPP_DECL JSC__StringPrototype* JSC__JSGlobalObject__stringPrototype(JSC__JSGlobalObject* arg0);
CPP_DECL JSC__JSObject* JSC__JSGlobalObject__symbolPrototype(JSC__JSGlobalObject* arg0);
CPP_DECL JSC__JSObject* JSC__JSGlobalObject__throwError(JSC__JSGlobalObject* arg0, JSC__JSObject* arg1);
CPP_DECL JSC__VM* JSC__JSGlobalObject__vm(JSC__JSGlobalObject* arg0);
#pragma mark - WTF::URL
@@ -362,7 +339,7 @@ CPP_DECL bWTF__StringView WTF__URL__encodedUser(WTF__URL* arg0);
CPP_DECL bWTF__String WTF__URL__fileSystemPath(WTF__URL* arg0);
CPP_DECL bWTF__StringView WTF__URL__fragmentIdentifier(WTF__URL* arg0);
CPP_DECL bWTF__StringView WTF__URL__fragmentIdentifierWithLeadingNumberSign(WTF__URL* arg0);
CPP_DECL bWTF__URL WTF__URL__fromFileSystemPath(bWTF__StringView arg0);
CPP_DECL void WTF__URL__fromFileSystemPath(WTF__URL* arg0, bWTF__StringView arg1);
CPP_DECL bWTF__URL WTF__URL__fromString(bWTF__String arg0, bWTF__String arg1);
CPP_DECL bWTF__StringView WTF__URL__host(WTF__URL* arg0);
CPP_DECL bWTF__String WTF__URL__hostAndPort(WTF__URL* arg0);
@@ -390,10 +367,10 @@ CPP_DECL bWTF__String WTF__URL__user(WTF__URL* arg0);
#pragma mark - WTF::String
CPP_DECL const uint16_t* WTF__String__characters16(WTF__String* arg0);
CPP_DECL const char* WTF__String__characters8(WTF__String* arg0);
CPP_DECL const unsigned char* WTF__String__characters8(WTF__String* arg0);
CPP_DECL bWTF__String WTF__String__createFromExternalString(bWTF__ExternalStringImpl arg0);
CPP_DECL bWTF__String WTF__String__createWithoutCopyingFromPtr(const char* arg0, size_t arg1);
CPP_DECL bool WTF__String__eqlSlice(WTF__String* arg0, const char* arg1, size_t arg2);
CPP_DECL void WTF__String__createWithoutCopyingFromPtr(WTF__String* arg0, unsigned char* arg1, size_t arg2);
CPP_DECL bool WTF__String__eqlSlice(WTF__String* arg0, const unsigned char* arg1, size_t arg2);
CPP_DECL bool WTF__String__eqlString(WTF__String* arg0, const WTF__String* arg1);
CPP_DECL const WTF__StringImpl* WTF__String__impl(WTF__String* arg0);
CPP_DECL bool WTF__String__is16Bit(WTF__String* arg0);
@@ -403,6 +380,54 @@ CPP_DECL bool WTF__String__isExternal(WTF__String* arg0);
CPP_DECL bool WTF__String__isStatic(WTF__String* arg0);
CPP_DECL size_t WTF__String__length(WTF__String* arg0);
#pragma mark - JSC::JSValue
CPP_DECL JSC__JSCell* JSC__JSValue__asCell(JSC__JSValue JSValue0);
CPP_DECL double JSC__JSValue__asNumber(JSC__JSValue JSValue0);
CPP_DECL bJSC__JSObject JSC__JSValue__asObject(JSC__JSValue JSValue0);
CPP_DECL JSC__JSString* JSC__JSValue__asString(JSC__JSValue JSValue0);
CPP_DECL bool JSC__JSValue__eqlCell(JSC__JSValue JSValue0, JSC__JSCell* arg1);
CPP_DECL bool JSC__JSValue__eqlValue(JSC__JSValue JSValue0, JSC__JSValue JSValue1);
CPP_DECL JSC__JSValue JSC__JSValue__getPrototype(JSC__JSValue JSValue0, JSC__JSGlobalObject* arg1);
CPP_DECL bool JSC__JSValue__isAnyInt(JSC__JSValue JSValue0);
CPP_DECL bool JSC__JSValue__isBigInt(JSC__JSValue JSValue0);
CPP_DECL bool JSC__JSValue__isBigInt32(JSC__JSValue JSValue0);
CPP_DECL bool JSC__JSValue__isBoolean(JSC__JSValue JSValue0);
CPP_DECL bool JSC__JSValue__isCallable(JSC__JSValue JSValue0, JSC__VM* arg1);
CPP_DECL bool JSC__JSValue__isCell(JSC__JSValue JSValue0);
CPP_DECL bool JSC__JSValue__isCustomGetterSetter(JSC__JSValue JSValue0);
CPP_DECL bool JSC__JSValue__isError(JSC__JSValue JSValue0);
CPP_DECL bool JSC__JSValue__isGetterSetter(JSC__JSValue JSValue0);
CPP_DECL bool JSC__JSValue__isHeapBigInt(JSC__JSValue JSValue0);
CPP_DECL bool JSC__JSValue__isInt32AsAnyInt(JSC__JSValue JSValue0);
CPP_DECL bool JSC__JSValue__isNull(JSC__JSValue JSValue0);
CPP_DECL bool JSC__JSValue__isNumber(JSC__JSValue JSValue0);
CPP_DECL bool JSC__JSValue__isObject(JSC__JSValue JSValue0);
CPP_DECL bool JSC__JSValue__isPrimitive(JSC__JSValue JSValue0);
CPP_DECL bool JSC__JSValue__isString(JSC__JSValue JSValue0);
CPP_DECL bool JSC__JSValue__isSymbol(JSC__JSValue JSValue0);
CPP_DECL bool JSC__JSValue__isUInt32AsAnyInt(JSC__JSValue JSValue0);
CPP_DECL bool JSC__JSValue__isUndefined(JSC__JSValue JSValue0);
CPP_DECL bool JSC__JSValue__isUndefinedOrNull(JSC__JSValue JSValue0);
CPP_DECL JSC__JSValue JSC__JSValue__jsBoolean(bool arg0);
CPP_DECL JSC__JSValue JSC__JSValue__jsDoubleNumber(double arg0);
CPP_DECL JSC__JSValue JSC__JSValue__jsNull();
CPP_DECL JSC__JSValue JSC__JSValue__jsNumberFromChar(unsigned char arg0);
CPP_DECL JSC__JSValue JSC__JSValue__jsNumberFromDouble(double arg0);
CPP_DECL JSC__JSValue JSC__JSValue__jsNumberFromInt32(int32_t arg0);
CPP_DECL JSC__JSValue JSC__JSValue__jsNumberFromInt64(int64_t arg0);
CPP_DECL JSC__JSValue JSC__JSValue__jsNumberFromU16(uint16_t arg0);
CPP_DECL JSC__JSValue JSC__JSValue__jsNumberFromUint64(uint64_t arg0);
CPP_DECL JSC__JSValue JSC__JSValue__jsTDZValue();
CPP_DECL JSC__JSValue JSC__JSValue__jsUndefined();
CPP_DECL JSC__JSObject* JSC__JSValue__toObject(JSC__JSValue JSValue0, JSC__JSGlobalObject* arg1);
CPP_DECL bJSC__Identifier JSC__JSValue__toPropertyKey(JSC__JSValue JSValue0, JSC__JSGlobalObject* arg1);
CPP_DECL JSC__JSValue JSC__JSValue__toPropertyKeyValue(JSC__JSValue JSValue0, JSC__JSGlobalObject* arg1);
CPP_DECL JSC__JSString* JSC__JSValue__toString(JSC__JSValue JSValue0, JSC__JSGlobalObject* arg1);
CPP_DECL JSC__JSString* JSC__JSValue__toString(JSC__JSValue JSValue0, JSC__JSGlobalObject* arg1);
CPP_DECL JSC__JSString* JSC__JSValue__toStringOrNull(JSC__JSValue JSValue0, JSC__JSGlobalObject* arg1);
CPP_DECL bWTF__String JSC__JSValue__toWTFString(JSC__JSValue JSValue0, JSC__JSGlobalObject* arg1);
#pragma mark - JSC::PropertyName
CPP_DECL bool JSC__PropertyName__eqlToIdentifier(JSC__PropertyName* arg0, const JSC__Identifier* arg1);
@@ -412,30 +437,30 @@ CPP_DECL const WTF__StringImpl* JSC__PropertyName__uid(JSC__PropertyName* arg0);
#pragma mark - JSC::Exception
CPP_DECL JSC__Exception* JSC__Exception__create(JSC__JSGlobalObject* arg0, JSC__JSObject* arg1, char StackCaptureAction2);
CPP_DECL JSC__Exception* JSC__Exception__create(JSC__JSGlobalObject* arg0, JSC__JSObject* arg1, unsigned char StackCaptureAction2);
#pragma mark - JSC::VM
CPP_DECL JSC__JSLock* JSC__VM__apiLock(JSC__VM* arg0);
CPP_DECL JSC__VM* JSC__VM__create(char HeapType0);
CPP_DECL JSC__VM* JSC__VM__create(unsigned char HeapType0);
CPP_DECL void JSC__VM__deinit(JSC__VM* arg0, JSC__JSGlobalObject* arg1);
CPP_DECL void JSC__VM__drainMicrotasks(JSC__VM* arg0);
CPP_DECL bool JSC__VM__executionForbidden(JSC__VM* arg0);
CPP_DECL bool JSC__VM__isEntered(JSC__VM* arg0);
CPP_DECL void JSC__VM__setExecutionForbidden(JSC__VM* arg0, bool arg1);
CPP_DECL bool JSC__VM__throwError(JSC__VM* arg0, JSC__JSGlobalObject* arg1, JSC__ThrowScope* arg2, const char* arg3, size_t arg4);
CPP_DECL bool JSC__VM__throwError(JSC__VM* arg0, JSC__JSGlobalObject* arg1, JSC__ThrowScope* arg2, const unsigned char* arg3, size_t arg4);
#pragma mark - JSC::ThrowScope
CPP_DECL void JSC__ThrowScope__clearException(JSC__ThrowScope* arg0);
CPP_DECL bJSC__ThrowScope JSC__ThrowScope__declare(JSC__VM* arg0, char* arg1, char* arg2, size_t arg3);
CPP_DECL bJSC__ThrowScope JSC__ThrowScope__declare(JSC__VM* arg0, unsigned char* arg1, unsigned char* arg2, size_t arg3);
CPP_DECL JSC__Exception* JSC__ThrowScope__exception(JSC__ThrowScope* arg0);
CPP_DECL void JSC__ThrowScope__release(JSC__ThrowScope* arg0);
#pragma mark - JSC::CatchScope
CPP_DECL void JSC__CatchScope__clearException(JSC__CatchScope* arg0);
CPP_DECL bJSC__CatchScope JSC__CatchScope__declare(JSC__VM* arg0, char* arg1, char* arg2, size_t arg3);
CPP_DECL bJSC__CatchScope JSC__CatchScope__declare(JSC__VM* arg0, unsigned char* arg1, unsigned char* arg2, size_t arg3);
CPP_DECL JSC__Exception* JSC__CatchScope__exception(JSC__CatchScope* arg0);
#pragma mark - JSC::CallFrame
@@ -454,10 +479,9 @@ CPP_DECL JSC__JSValue JSC__CallFrame__uncheckedArgument(const JSC__CallFrame* ar
CPP_DECL void JSC__Identifier__deinit(const JSC__Identifier* arg0);
CPP_DECL bool JSC__Identifier__eqlIdent(const JSC__Identifier* arg0, const JSC__Identifier* arg1);
CPP_DECL bool JSC__Identifier__eqlStringImpl(const JSC__Identifier* arg0, const WTF__StringImpl* arg1);
CPP_DECL bool JSC__Identifier__eqlUTF8(const JSC__Identifier* arg0, const char* arg1, size_t arg2);
CPP_DECL bJSC__Identifier JSC__Identifier__fromSlice(JSC__VM* arg0, const char* arg1, size_t arg2);
CPP_DECL bool JSC__Identifier__eqlUTF8(const JSC__Identifier* arg0, const unsigned char* arg1, size_t arg2);
CPP_DECL bJSC__Identifier JSC__Identifier__fromSlice(JSC__VM* arg0, const unsigned char* arg1, size_t arg2);
CPP_DECL bJSC__Identifier JSC__Identifier__fromString(JSC__VM* arg0, const WTF__String* arg1);
CPP_DECL bJSC__Identifier JSC__Identifier__fromUid(JSC__VM* arg0, const WTF__StringImpl* arg1);
CPP_DECL bool JSC__Identifier__isEmpty(const JSC__Identifier* arg0);
CPP_DECL bool JSC__Identifier__isNull(const JSC__Identifier* arg0);
CPP_DECL bool JSC__Identifier__isPrivateName(const JSC__Identifier* arg0);
@@ -470,7 +494,7 @@ CPP_DECL bWTF__String JSC__Identifier__toString(const JSC__Identifier* arg0);
#pragma mark - WTF::StringImpl
CPP_DECL const uint16_t* WTF__StringImpl__characters16(const WTF__StringImpl* arg0);
CPP_DECL const char* WTF__StringImpl__characters8(const WTF__StringImpl* arg0);
CPP_DECL const unsigned char* WTF__StringImpl__characters8(const WTF__StringImpl* arg0);
CPP_DECL bool WTF__StringImpl__is16Bit(const WTF__StringImpl* arg0);
CPP_DECL bool WTF__StringImpl__is8Bit(const WTF__StringImpl* arg0);
CPP_DECL bool WTF__StringImpl__isEmpty(const WTF__StringImpl* arg0);
@@ -481,8 +505,8 @@ CPP_DECL size_t WTF__StringImpl__length(const WTF__StringImpl* arg0);
#pragma mark - WTF::ExternalStringImpl
CPP_DECL const uint16_t* WTF__ExternalStringImpl__characters16(const WTF__ExternalStringImpl* arg0);
CPP_DECL const char* WTF__ExternalStringImpl__characters8(const WTF__ExternalStringImpl* arg0);
CPP_DECL bWTF__ExternalStringImpl WTF__ExternalStringImpl__create(const char* arg0, size_t arg1, void (* ArgFn2)(void* arg0, char* arg1, size_t arg2));
CPP_DECL const unsigned char* WTF__ExternalStringImpl__characters8(const WTF__ExternalStringImpl* arg0);
CPP_DECL bWTF__ExternalStringImpl WTF__ExternalStringImpl__create(const unsigned char* arg0, size_t arg1, void (* ArgFn2)(void* arg0, unsigned char* arg1, size_t arg2));
CPP_DECL bool WTF__ExternalStringImpl__is16Bit(const WTF__ExternalStringImpl* arg0);
CPP_DECL bool WTF__ExternalStringImpl__is8Bit(const WTF__ExternalStringImpl* arg0);
CPP_DECL bool WTF__ExternalStringImpl__isEmpty(const WTF__ExternalStringImpl* arg0);
@@ -491,9 +515,46 @@ CPP_DECL size_t WTF__ExternalStringImpl__length(const WTF__ExternalStringImpl* a
#pragma mark - WTF::StringView
CPP_DECL const uint16_t* WTF__StringView__characters16(const WTF__StringView* arg0);
CPP_DECL const char* WTF__StringView__characters8(const WTF__StringView* arg0);
CPP_DECL bWTF__StringView WTF__StringView__from8Bit(const char* arg0, size_t arg1);
CPP_DECL const unsigned char* WTF__StringView__characters8(const WTF__StringView* arg0);
CPP_DECL void WTF__StringView__from8Bit(WTF__StringView* arg0, const unsigned char* arg1, size_t arg2);
CPP_DECL bool WTF__StringView__is16Bit(const WTF__StringView* arg0);
CPP_DECL bool WTF__StringView__is8Bit(const WTF__StringView* arg0);
CPP_DECL bool WTF__StringView__isEmpty(const WTF__StringView* arg0);
CPP_DECL size_t WTF__StringView__length(const WTF__StringView* arg0);
#pragma mark - Zig::GlobalObject
CPP_DECL JSC__JSGlobalObject* Zig__GlobalObject__create(JSC__VM* arg0, void* arg1);
#ifdef __cplusplus
ZIG_DECL JSC__JSValue Zig__GlobalObject__createImportMetaProperties(JSC__JSGlobalObject* arg0, JSC__JSModuleLoader* arg1, JSC__JSValue JSValue2, JSC__JSModuleRecord* arg3, JSC__JSValue JSValue4);
ZIG_DECL JSC__JSValue Zig__GlobalObject__eval(JSC__JSGlobalObject* arg0, JSC__JSModuleLoader* arg1, JSC__JSValue JSValue2, JSC__JSValue JSValue3, JSC__JSValue JSValue4, JSC__JSValue JSValue5, JSC__JSValue JSValue6);
ZIG_DECL JSC__JSInternalPromise* Zig__GlobalObject__fetch(JSC__JSGlobalObject* arg0, JSC__JSModuleLoader* arg1, JSC__JSValue JSValue2, JSC__JSValue JSValue3, JSC__JSValue JSValue4);
ZIG_DECL JSC__JSInternalPromise* Zig__GlobalObject__import(JSC__JSGlobalObject* arg0, JSC__JSModuleLoader* arg1, JSC__JSString* arg2, JSC__JSValue JSValue3, const JSC__SourceOrigin* arg4);
ZIG_DECL JSC__JSValue Zig__GlobalObject__promiseRejectionTracker(JSC__JSGlobalObject* arg0, JSC__JSPromise* arg1, uint32_t JSPromiseRejectionOperation2);
ZIG_DECL JSC__JSValue Zig__GlobalObject__reportUncaughtException(JSC__JSGlobalObject* arg0, JSC__Exception* arg1);
ZIG_DECL bJSC__Identifier Zig__GlobalObject__resolve(JSC__JSGlobalObject* arg0, JSC__JSModuleLoader* arg1, JSC__JSValue JSValue2, JSC__JSValue JSValue3, const JSC__SourceOrigin* arg4);
#endif
#pragma mark - Zig::ConsoleClient
#ifdef __cplusplus
ZIG_DECL void Zig__ConsoleClient__count(void* arg0, JSC__JSGlobalObject* arg1, const unsigned char* arg2, size_t arg3);
ZIG_DECL void Zig__ConsoleClient__countReset(void* arg0, JSC__JSGlobalObject* arg1, const unsigned char* arg2, size_t arg3);
ZIG_DECL void Zig__ConsoleClient__messageWithTypeAndLevel(void* arg0, uint32_t arg1, uint32_t arg2, JSC__JSGlobalObject* arg3, Inspector__ScriptArguments* arg4);
ZIG_DECL void Zig__ConsoleClient__profile(void* arg0, JSC__JSGlobalObject* arg1, const unsigned char* arg2, size_t arg3);
ZIG_DECL void Zig__ConsoleClient__profileEnd(void* arg0, JSC__JSGlobalObject* arg1, const unsigned char* arg2, size_t arg3);
ZIG_DECL void Zig__ConsoleClient__record(void* arg0, JSC__JSGlobalObject* arg1, Inspector__ScriptArguments* arg2);
ZIG_DECL void Zig__ConsoleClient__recordEnd(void* arg0, JSC__JSGlobalObject* arg1, Inspector__ScriptArguments* arg2);
ZIG_DECL void Zig__ConsoleClient__screenshot(void* arg0, JSC__JSGlobalObject* arg1, Inspector__ScriptArguments* arg2);
ZIG_DECL void Zig__ConsoleClient__takeHeapSnapshot(void* arg0, JSC__JSGlobalObject* arg1, const unsigned char* arg2, size_t arg3);
ZIG_DECL void Zig__ConsoleClient__time(void* arg0, JSC__JSGlobalObject* arg1, const unsigned char* arg2, size_t arg3);
ZIG_DECL void Zig__ConsoleClient__timeEnd(void* arg0, JSC__JSGlobalObject* arg1, const unsigned char* arg2, size_t arg3);
ZIG_DECL void Zig__ConsoleClient__timeLog(void* arg0, JSC__JSGlobalObject* arg1, const unsigned char* arg2, size_t arg3, Inspector__ScriptArguments* arg4);
ZIG_DECL void Zig__ConsoleClient__timeStamp(void* arg0, JSC__JSGlobalObject* arg1, Inspector__ScriptArguments* arg2);
#endif

563
src/javascript/jsc/bindings/headers.zig Normal file
View File

@@ -0,0 +1,563 @@
pub usingnamespace @import("std").zig.c_builtins;
pub const ptrdiff_t = c_long;
pub const wchar_t = c_int;
pub const max_align_t = c_longdouble;
pub const int_least8_t = i8;
pub const int_least16_t = i16;
pub const int_least32_t = i32;
pub const int_least64_t = i64;
pub const uint_least8_t = u8;
pub const uint_least16_t = u16;
pub const uint_least32_t = u32;
pub const uint_least64_t = u64;
pub const int_fast8_t = i8;
pub const int_fast16_t = i16;
pub const int_fast32_t = i32;
pub const int_fast64_t = i64;
pub const uint_fast8_t = u8;
pub const uint_fast16_t = u16;
pub const uint_fast32_t = u32;
pub const uint_fast64_t = u64;
pub const __int8_t = i8;
pub const __uint8_t = u8;
pub const __int16_t = c_short;
pub const __uint16_t = c_ushort;
pub const __int32_t = c_int;
pub const __uint32_t = c_uint;
pub const __int64_t = c_longlong;
pub const __uint64_t = c_ulonglong;
pub const __darwin_intptr_t = c_long;
pub const __darwin_natural_t = c_uint;
pub const __darwin_ct_rune_t = c_int;
pub const __mbstate_t = extern union {
__mbstate8: [128]u8,
_mbstateL: c_longlong,
};
pub const __darwin_mbstate_t = __mbstate_t;
pub const __darwin_ptrdiff_t = c_long;
pub const __darwin_size_t = c_ulong;
pub const struct___va_list_tag = extern struct {
gp_offset: c_uint,
fp_offset: c_uint,
overflow_arg_area: ?*c_void,
reg_save_area: ?*c_void,
};
pub const __builtin_va_list = [1]struct___va_list_tag;
pub const __darwin_va_list = __builtin_va_list;
pub const __darwin_wchar_t = c_int;
pub const __darwin_rune_t = __darwin_wchar_t;
pub const __darwin_wint_t = c_int;
pub const __darwin_clock_t = c_ulong;
pub const __darwin_socklen_t = __uint32_t;
pub const __darwin_ssize_t = c_long;
pub const __darwin_time_t = c_long;
pub const __darwin_blkcnt_t = __int64_t;
pub const __darwin_blksize_t = __int32_t;
pub const __darwin_dev_t = __int32_t;
pub const __darwin_fsblkcnt_t = c_uint;
pub const __darwin_fsfilcnt_t = c_uint;
pub const __darwin_gid_t = __uint32_t;
pub const __darwin_id_t = __uint32_t;
pub const __darwin_ino64_t = __uint64_t;
pub const __darwin_ino_t = __darwin_ino64_t;
pub const __darwin_mach_port_name_t = __darwin_natural_t;
pub const __darwin_mach_port_t = __darwin_mach_port_name_t;
pub const __darwin_mode_t = __uint16_t;
pub const __darwin_off_t = __int64_t;
pub const __darwin_pid_t = __int32_t;
pub const __darwin_sigset_t = __uint32_t;
pub const __darwin_suseconds_t = __int32_t;
pub const __darwin_uid_t = __uint32_t;
pub const __darwin_useconds_t = __uint32_t;
pub const __darwin_uuid_t = [16]u8;
pub const __darwin_uuid_string_t = [37]u8;
pub const struct___darwin_pthread_handler_rec = extern struct {
__routine: ?fn (?*c_void) callconv(.C) void,
__arg: ?*c_void,
__next: [*c]struct___darwin_pthread_handler_rec,
};
pub const struct__opaque_pthread_attr_t = extern struct {
__sig: c_long,
__opaque: [56]u8,
};
pub const struct__opaque_pthread_cond_t = extern struct {
__sig: c_long,
__opaque: [40]u8,
};
pub const struct__opaque_pthread_condattr_t = extern struct {
__sig: c_long,
__opaque: [8]u8,
};
pub const struct__opaque_pthread_mutex_t = extern struct {
__sig: c_long,
__opaque: [56]u8,
};
pub const struct__opaque_pthread_mutexattr_t = extern struct {
__sig: c_long,
__opaque: [8]u8,
};
pub const struct__opaque_pthread_once_t = extern struct {
__sig: c_long,
__opaque: [8]u8,
};
pub const struct__opaque_pthread_rwlock_t = extern struct {
__sig: c_long,
__opaque: [192]u8,
};
pub const struct__opaque_pthread_rwlockattr_t = extern struct {
__sig: c_long,
__opaque: [16]u8,
};
pub const struct__opaque_pthread_t = extern struct {
__sig: c_long,
__cleanup_stack: [*c]struct___darwin_pthread_handler_rec,
__opaque: [8176]u8,
};
pub const __darwin_pthread_attr_t = struct__opaque_pthread_attr_t;
pub const __darwin_pthread_cond_t = struct__opaque_pthread_cond_t;
pub const __darwin_pthread_condattr_t = struct__opaque_pthread_condattr_t;
pub const __darwin_pthread_key_t = c_ulong;
pub const __darwin_pthread_mutex_t = struct__opaque_pthread_mutex_t;
pub const __darwin_pthread_mutexattr_t = struct__opaque_pthread_mutexattr_t;
pub const __darwin_pthread_once_t = struct__opaque_pthread_once_t;
pub const __darwin_pthread_rwlock_t = struct__opaque_pthread_rwlock_t;
pub const __darwin_pthread_rwlockattr_t = struct__opaque_pthread_rwlockattr_t;
pub const __darwin_pthread_t = [*c]struct__opaque_pthread_t;
pub const u_int8_t = u8;
pub const u_int16_t = c_ushort;
pub const u_int32_t = c_uint;
pub const u_int64_t = c_ulonglong;
pub const register_t = i64;
pub const user_addr_t = u_int64_t;
pub const user_size_t = u_int64_t;
pub const user_ssize_t = i64;
pub const user_long_t = i64;
pub const user_ulong_t = u_int64_t;
pub const user_time_t = i64;
pub const user_off_t = i64;
pub const syscall_arg_t = u_int64_t;
pub const intmax_t = c_long;
pub const uintmax_t = c_ulong;
pub const struct_bJSC__JSModuleRecord = extern struct {
bytes: [216]u8,
};
pub const bJSC__JSModuleRecord = struct_bJSC__JSModuleRecord;
pub const bJSC__JSModuleRecord_buf = [*c]u8;
pub const struct_bJSC__ThrowScope = extern struct {
bytes: [8]u8,
};
pub const bJSC__ThrowScope = struct_bJSC__ThrowScope;
pub const bJSC__ThrowScope_buf = [*c]u8;
pub const struct_bJSC__PropertyName = extern struct {
bytes: [8]u8,
};
pub const bJSC__PropertyName = struct_bJSC__PropertyName;
pub const bJSC__PropertyName_buf = [*c]u8;
pub const struct_bJSC__CallFrame = extern struct {
bytes: [8]u8,
};
pub const bJSC__CallFrame = struct_bJSC__CallFrame;
pub const bJSC__CallFrame_buf = [*c]u8;
pub const struct_bJSC__CatchScope = extern struct {
bytes: [8]u8,
};
pub const bJSC__CatchScope = struct_bJSC__CatchScope;
pub const bJSC__CatchScope_buf = [*c]u8;
pub const struct_bWTF__String = extern struct {
bytes: [8]u8,
};
pub const bWTF__String = struct_bWTF__String;
pub const bWTF__String_buf = [*c]u8;
pub const struct_bWTF__StringView = extern struct {
bytes: [16]u8,
};
pub const bWTF__StringView = struct_bWTF__StringView;
pub const bWTF__StringView_buf = [*c]u8;
pub const struct_bJSC__JSModuleLoader = extern struct {
bytes: [16]u8,
};
pub const bJSC__JSModuleLoader = struct_bJSC__JSModuleLoader;
pub const bJSC__JSModuleLoader_buf = [*c]u8;
pub const struct_bJSC__Exception = extern struct {
bytes: [40]u8,
};
pub const bJSC__Exception = struct_bJSC__Exception;
pub const bJSC__Exception_buf = [*c]u8;
pub const struct_bJSC__VM = extern struct {
bytes: [48824]u8,
};
pub const bJSC__VM = struct_bJSC__VM;
pub const bJSC__VM_buf = [*c]u8;
pub const struct_bJSC__JSString = extern struct {
bytes: [16]u8,
};
pub const bJSC__JSString = struct_bJSC__JSString;
pub const bJSC__JSString_buf = [*c]u8;
pub const struct_bJSC__SourceOrigin = extern struct {
bytes: [48]u8,
};
pub const bJSC__SourceOrigin = struct_bJSC__SourceOrigin;
pub const bJSC__SourceOrigin_buf = [*c]u8;
pub const struct_bWTF__ExternalStringImpl = extern struct {
bytes: [32]u8,
};
pub const bWTF__ExternalStringImpl = struct_bWTF__ExternalStringImpl;
pub const bWTF__ExternalStringImpl_buf = [*c]u8;
pub const struct_bWTF__StringImpl = extern struct {
bytes: [24]u8,
};
pub const bWTF__StringImpl = struct_bWTF__StringImpl;
pub const bWTF__StringImpl_buf = [*c]u8;
pub const struct_bJSC__JSPromise = extern struct {
bytes: [32]u8,
};
pub const bJSC__JSPromise = struct_bJSC__JSPromise;
pub const bJSC__JSPromise_buf = [*c]u8;
pub const struct_bJSC__SourceCode = extern struct {
bytes: [24]u8,
};
pub const bJSC__SourceCode = struct_bJSC__SourceCode;
pub const bJSC__SourceCode_buf = [*c]u8;
pub const struct_bWTF__URL = extern struct {
bytes: [40]u8,
};
pub const bWTF__URL = struct_bWTF__URL;
pub const bWTF__URL_buf = [*c]u8;
pub const struct_bJSC__JSFunction = extern struct {
bytes: [32]u8,
};
pub const bJSC__JSFunction = struct_bJSC__JSFunction;
pub const bJSC__JSFunction_buf = [*c]u8;
pub const struct_bJSC__JSGlobalObject = extern struct {
bytes: [2400]u8,
};
pub const bJSC__JSGlobalObject = struct_bJSC__JSGlobalObject;
pub const bJSC__JSGlobalObject_buf = [*c]u8;
pub const struct_bJSC__JSCell = extern struct {
bytes: [8]u8,
};
pub const bJSC__JSCell = struct_bJSC__JSCell;
pub const bJSC__JSCell_buf = [*c]u8;
pub const struct_bJSC__JSLock = extern struct {
bytes: [40]u8,
};
pub const bJSC__JSLock = struct_bJSC__JSLock;
pub const bJSC__JSLock_buf = [*c]u8;
pub const struct_bInspector__ScriptArguments = extern struct {
bytes: [32]u8,
};
pub const bInspector__ScriptArguments = struct_bInspector__ScriptArguments;
pub const bInspector__ScriptArguments_buf = [*c]u8;
pub const struct_bJSC__JSInternalPromise = extern struct {
bytes: [32]u8,
};
pub const bJSC__JSInternalPromise = struct_bJSC__JSInternalPromise;
pub const bJSC__JSInternalPromise_buf = [*c]u8;
pub const struct_bJSC__JSObject = extern struct {
bytes: [16]u8,
};
pub const bJSC__JSObject = struct_bJSC__JSObject;
pub const bJSC__JSObject_buf = [*c]u8;
pub const struct_bJSC__Identifier = extern struct {
bytes: [8]u8,
};
pub const bJSC__Identifier = struct_bJSC__Identifier;
pub const bJSC__Identifier_buf = [*c]u8;
pub const struct_JSC__RegExpPrototype = opaque {};
pub const JSC__RegExpPrototype = struct_JSC__RegExpPrototype;
pub const struct_JSC__GeneratorPrototype = opaque {};
pub const JSC__GeneratorPrototype = struct_JSC__GeneratorPrototype;
pub const struct_JSC__ArrayIteratorPrototype = opaque {};
pub const JSC__ArrayIteratorPrototype = struct_JSC__ArrayIteratorPrototype;
pub const struct_JSC__StringPrototype = opaque {};
pub const JSC__StringPrototype = struct_JSC__StringPrototype;
pub const WTF__StringView = bWTF__StringView;
pub const struct_JSC__JSPromisePrototype = opaque {};
pub const JSC__JSPromisePrototype = struct_JSC__JSPromisePrototype;
pub const JSC__CatchScope = bJSC__CatchScope;
pub const JSC__ThrowScope = bJSC__ThrowScope;
pub const JSC__PropertyName = bJSC__PropertyName;
pub const JSC__JSObject = bJSC__JSObject;
pub const WTF__ExternalStringImpl = bWTF__ExternalStringImpl;
pub const struct_JSC__AsyncIteratorPrototype = opaque {};
pub const JSC__AsyncIteratorPrototype = struct_JSC__AsyncIteratorPrototype;
pub const WTF__StringImpl = bWTF__StringImpl;
pub const JSC__JSLock = bJSC__JSLock;
pub const JSC__JSModuleLoader = bJSC__JSModuleLoader;
pub const JSC__VM = bJSC__VM;
pub const struct_JSC__AsyncGeneratorPrototype = opaque {};
pub const JSC__AsyncGeneratorPrototype = struct_JSC__AsyncGeneratorPrototype;
pub const struct_JSC__AsyncGeneratorFunctionPrototype = opaque {};
pub const JSC__AsyncGeneratorFunctionPrototype = struct_JSC__AsyncGeneratorFunctionPrototype;
pub const JSC__JSGlobalObject = bJSC__JSGlobalObject;
pub const JSC__JSFunction = bJSC__JSFunction;
pub const struct_JSC__ArrayPrototype = opaque {};
pub const JSC__ArrayPrototype = struct_JSC__ArrayPrototype;
pub const struct_JSC__AsyncFunctionPrototype = opaque {};
pub const JSC__AsyncFunctionPrototype = struct_JSC__AsyncFunctionPrototype;
pub const JSC__Identifier = bJSC__Identifier;
pub const JSC__JSPromise = bJSC__JSPromise;
pub const struct_JSC__SetIteratorPrototype = opaque {};
pub const JSC__SetIteratorPrototype = struct_JSC__SetIteratorPrototype;
pub const JSC__SourceCode = bJSC__SourceCode;
pub const JSC__JSCell = bJSC__JSCell;
pub const struct_JSC__BigIntPrototype = opaque {};
pub const JSC__BigIntPrototype = struct_JSC__BigIntPrototype;
pub const struct_JSC__GeneratorFunctionPrototype = opaque {};
pub const JSC__GeneratorFunctionPrototype = struct_JSC__GeneratorFunctionPrototype;
pub const JSC__SourceOrigin = bJSC__SourceOrigin;
pub const JSC__JSModuleRecord = bJSC__JSModuleRecord;
pub const WTF__String = bWTF__String;
pub const WTF__URL = bWTF__URL;
pub const JSC__JSValue = i64;
pub const struct_JSC__IteratorPrototype = opaque {};
pub const JSC__IteratorPrototype = struct_JSC__IteratorPrototype;
pub const JSC__JSInternalPromise = bJSC__JSInternalPromise;
pub const struct_JSC__FunctionPrototype = opaque {};
pub const JSC__FunctionPrototype = struct_JSC__FunctionPrototype;
pub const Inspector__ScriptArguments = bInspector__ScriptArguments;
pub const JSC__Exception = bJSC__Exception;
pub const JSC__JSString = bJSC__JSString;
pub const struct_JSC__ObjectPrototype = opaque {};
pub const JSC__ObjectPrototype = struct_JSC__ObjectPrototype;
pub const JSC__CallFrame = bJSC__CallFrame;
pub const struct_JSC__MapIteratorPrototype = opaque {};
pub const JSC__MapIteratorPrototype = struct_JSC__MapIteratorPrototype;
pub extern fn JSC__JSObject__getArrayLength(arg0: [*c]JSC__JSObject) usize;
pub extern fn JSC__JSObject__getAtIndex(arg0: [*c]JSC__JSObject, arg1: [*c]JSC__JSGlobalObject, arg2: [*c]JSC__PropertyName, arg3: u32) JSC__JSValue;
pub extern fn JSC__JSObject__putAtIndex(arg0: [*c]JSC__JSObject, arg1: [*c]JSC__JSGlobalObject, arg2: [*c]JSC__PropertyName, arg3: u32) bool;
pub extern fn JSC__JSCell__getObject(arg0: [*c]JSC__JSCell) [*c]JSC__JSObject;
pub extern fn JSC__JSCell__getString(arg0: [*c]JSC__JSCell, arg1: [*c]JSC__JSGlobalObject) bWTF__String;
pub extern fn JSC__JSCell__getType(arg0: [*c]JSC__JSCell) u8;
pub extern fn JSC__JSString__createFromOwnedString(arg0: [*c]JSC__VM, arg1: [*c]const WTF__String) [*c]JSC__JSString;
pub extern fn JSC__JSString__createFromString(arg0: [*c]JSC__VM, arg1: [*c]const WTF__String) [*c]JSC__JSString;
pub extern fn JSC__JSString__eql(arg0: [*c]const JSC__JSString, arg1: [*c]JSC__JSGlobalObject, arg2: [*c]JSC__JSString) bool;
pub extern fn JSC__JSString__is8Bit(arg0: [*c]const JSC__JSString) bool;
pub extern fn JSC__JSString__length(arg0: [*c]const JSC__JSString) usize;
pub extern fn JSC__JSString__toObject(arg0: [*c]JSC__JSString, arg1: [*c]JSC__JSGlobalObject) [*c]JSC__JSObject;
pub extern fn JSC__JSString__value(arg0: bWTF__String, arg1: [*c]JSC__JSString, arg2: [*c]JSC__JSGlobalObject) void;
pub extern fn Inspector__ScriptArguments__argumentAt(arg0: [*c]const Inspector__ScriptArguments, arg1: usize) JSC__JSValue;
pub extern fn Inspector__ScriptArguments__argumentCount(arg0: [*c]const Inspector__ScriptArguments) usize;
pub extern fn Inspector__ScriptArguments__getFirstArgumentAsString(arg0: [*c]const Inspector__ScriptArguments) bWTF__String;
pub extern fn Inspector__ScriptArguments__isEqual(arg0: [*c]const Inspector__ScriptArguments, arg1: [*c]const Inspector__ScriptArguments) bool;
pub extern fn Inspector__ScriptArguments__release(arg0: [*c]Inspector__ScriptArguments) void;
pub extern fn JSC__JSModuleLoader__checkSyntax(arg0: [*c]JSC__JSGlobalObject, arg1: [*c]const JSC__SourceCode, arg2: bool) bool;
pub extern fn JSC__JSModuleLoader__evaluate(arg0: [*c]JSC__JSGlobalObject, arg1: [*c]const JSC__SourceCode, JSValue2: JSC__JSValue, arg3: [*c][*c]JSC__Exception) JSC__JSValue;
pub extern fn JSC__JSModuleLoader__importModule(arg0: [*c]JSC__JSGlobalObject, arg1: [*c]const JSC__Identifier) [*c]JSC__JSInternalPromise;
pub extern fn JSC__JSModuleLoader__linkAndEvaluateModule(arg0: [*c]JSC__JSGlobalObject, arg1: [*c]const JSC__Identifier) JSC__JSValue;
pub extern fn JSC__JSModuleLoader__loadAndEvaluateModule(arg0: [*c]JSC__JSGlobalObject, arg1: [*c]const WTF__String) [*c]JSC__JSInternalPromise;
pub extern fn JSC__JSModuleLoader__loadAndEvaluateModuleEntryPoint(arg0: [*c]JSC__JSGlobalObject, arg1: [*c]const JSC__SourceCode) [*c]JSC__JSInternalPromise;
pub extern fn JSC__JSModuleRecord__sourceCode(arg0: [*c]JSC__JSModuleRecord) bJSC__SourceCode;
pub extern fn JSC__JSPromise__isHandled(arg0: [*c]const JSC__JSPromise, arg1: [*c]JSC__VM) bool;
pub extern fn JSC__JSPromise__reject(arg0: [*c]JSC__JSPromise, arg1: [*c]JSC__JSGlobalObject, JSValue2: JSC__JSValue) void;
pub extern fn JSC__JSPromise__rejectAsHandled(arg0: [*c]JSC__JSPromise, arg1: [*c]JSC__JSGlobalObject, JSValue2: JSC__JSValue) void;
pub extern fn JSC__JSPromise__rejectAsHandledException(arg0: [*c]JSC__JSPromise, arg1: [*c]JSC__JSGlobalObject, arg2: [*c]JSC__Exception) void;
pub extern fn JSC__JSPromise__rejectedPromise(arg0: [*c]JSC__JSGlobalObject, JSValue1: JSC__JSValue) [*c]JSC__JSPromise;
pub extern fn JSC__JSPromise__rejectWithCaughtException(arg0: [*c]JSC__JSPromise, arg1: [*c]JSC__JSGlobalObject, arg2: bJSC__ThrowScope) void;
pub extern fn JSC__JSPromise__resolve(arg0: [*c]JSC__JSPromise, arg1: [*c]JSC__JSGlobalObject, JSValue2: JSC__JSValue) void;
pub extern fn JSC__JSPromise__resolvedPromise(arg0: [*c]JSC__JSGlobalObject, JSValue1: JSC__JSValue) [*c]JSC__JSPromise;
pub extern fn JSC__JSPromise__result(arg0: [*c]const JSC__JSPromise, arg1: [*c]JSC__VM) JSC__JSValue;
pub extern fn JSC__JSPromise__status(arg0: [*c]const JSC__JSPromise, arg1: [*c]JSC__VM) u32;
pub extern fn JSC__JSInternalPromise__create(arg0: [*c]JSC__JSGlobalObject) [*c]JSC__JSInternalPromise;
pub extern fn JSC__JSInternalPromise__isHandled(arg0: [*c]const JSC__JSInternalPromise, arg1: [*c]JSC__VM) bool;
pub extern fn JSC__JSInternalPromise__reject(arg0: [*c]JSC__JSInternalPromise, arg1: [*c]JSC__JSGlobalObject, JSValue2: JSC__JSValue) void;
pub extern fn JSC__JSInternalPromise__rejectAsHandled(arg0: [*c]JSC__JSInternalPromise, arg1: [*c]JSC__JSGlobalObject, JSValue2: JSC__JSValue) void;
pub extern fn JSC__JSInternalPromise__rejectAsHandledException(arg0: [*c]JSC__JSInternalPromise, arg1: [*c]JSC__JSGlobalObject, arg2: [*c]JSC__Exception) void;
pub extern fn JSC__JSInternalPromise__rejectedPromise(arg0: [*c]JSC__JSGlobalObject, JSValue1: JSC__JSValue) [*c]JSC__JSInternalPromise;
pub extern fn JSC__JSInternalPromise__rejectWithCaughtException(arg0: [*c]JSC__JSInternalPromise, arg1: [*c]JSC__JSGlobalObject, arg2: bJSC__ThrowScope) void;
pub extern fn JSC__JSInternalPromise__resolve(arg0: [*c]JSC__JSInternalPromise, arg1: [*c]JSC__JSGlobalObject, JSValue2: JSC__JSValue) void;
pub extern fn JSC__JSInternalPromise__resolvedPromise(arg0: [*c]JSC__JSGlobalObject, JSValue1: JSC__JSValue) [*c]JSC__JSInternalPromise;
pub extern fn JSC__JSInternalPromise__result(arg0: [*c]const JSC__JSInternalPromise, arg1: [*c]JSC__VM) JSC__JSValue;
pub extern fn JSC__JSInternalPromise__status(arg0: [*c]const JSC__JSInternalPromise, arg1: [*c]JSC__VM) u32;
pub extern fn JSC__JSInternalPromise__then(arg0: [*c]JSC__JSInternalPromise, arg1: [*c]JSC__JSGlobalObject, arg2: [*c]JSC__JSFunction, arg3: [*c]JSC__JSFunction) [*c]JSC__JSInternalPromise;
pub extern fn JSC__SourceOrigin__fromURL(arg0: [*c]const WTF__URL) bJSC__SourceOrigin;
pub extern fn JSC__SourceCode__fromString(arg0: [*c]JSC__SourceCode, arg1: [*c]const WTF__String, arg2: [*c]const JSC__SourceOrigin, arg3: [*c]WTF__String, SourceType4: u8) void;
pub extern fn JSC__JSFunction__calculatedDisplayName(arg0: [*c]JSC__JSFunction, arg1: [*c]JSC__VM) bWTF__String;
pub extern fn JSC__JSFunction__callWithArguments(JSValue0: JSC__JSValue, arg1: [*c]JSC__JSGlobalObject, arg2: [*c]JSC__JSValue, arg3: usize, arg4: [*c][*c]JSC__Exception, arg5: [*c]const u8) JSC__JSValue;
pub extern fn JSC__JSFunction__callWithArgumentsAndThis(JSValue0: JSC__JSValue, JSValue1: JSC__JSValue, arg2: [*c]JSC__JSGlobalObject, arg3: [*c]JSC__JSValue, arg4: usize, arg5: [*c][*c]JSC__Exception, arg6: [*c]const u8) JSC__JSValue;
pub extern fn JSC__JSFunction__callWithoutAnyArgumentsOrThis(JSValue0: JSC__JSValue, arg1: [*c]JSC__JSGlobalObject, arg2: [*c][*c]JSC__Exception, arg3: [*c]const u8) JSC__JSValue;
pub extern fn JSC__JSFunction__callWithThis(JSValue0: JSC__JSValue, arg1: [*c]JSC__JSGlobalObject, JSValue2: JSC__JSValue, arg3: [*c][*c]JSC__Exception, arg4: [*c]const u8) JSC__JSValue;
pub extern fn JSC__JSFunction__constructWithArguments(JSValue0: JSC__JSValue, arg1: [*c]JSC__JSGlobalObject, arg2: [*c]JSC__JSValue, arg3: usize, arg4: [*c][*c]JSC__Exception, arg5: [*c]const u8) JSC__JSValue;
pub extern fn JSC__JSFunction__constructWithArgumentsAndNewTarget(JSValue0: JSC__JSValue, JSValue1: JSC__JSValue, arg2: [*c]JSC__JSGlobalObject, arg3: [*c]JSC__JSValue, arg4: usize, arg5: [*c][*c]JSC__Exception, arg6: [*c]const u8) JSC__JSValue;
pub extern fn JSC__JSFunction__constructWithNewTarget(JSValue0: JSC__JSValue, arg1: [*c]JSC__JSGlobalObject, JSValue2: JSC__JSValue, arg3: [*c][*c]JSC__Exception, arg4: [*c]const u8) JSC__JSValue;
pub extern fn JSC__JSFunction__constructWithoutAnyArgumentsOrNewTarget(JSValue0: JSC__JSValue, arg1: [*c]JSC__JSGlobalObject, arg2: [*c][*c]JSC__Exception, arg3: [*c]const u8) JSC__JSValue;
pub extern fn JSC__JSFunction__createFromNative(arg0: [*c]JSC__JSGlobalObject, arg1: u16, arg2: [*c]const WTF__String, arg3: ?*c_void, ArgFn4: ?fn (?*c_void, [*c]JSC__JSGlobalObject, [*c]JSC__CallFrame) callconv(.C) JSC__JSValue) [*c]JSC__JSFunction;
pub extern fn JSC__JSFunction__createFromSourceCode(arg0: [*c]JSC__JSGlobalObject, arg1: [*c]const u8, arg2: u16, arg3: [*c]JSC__JSValue, arg4: u16, arg5: [*c]const JSC__SourceCode, arg6: [*c]JSC__SourceOrigin, arg7: [*c][*c]JSC__JSObject) [*c]JSC__JSFunction;
pub extern fn JSC__JSFunction__displayName(arg0: [*c]JSC__JSFunction, arg1: [*c]JSC__VM) bWTF__String;
pub extern fn JSC__JSFunction__getName(arg0: [*c]JSC__JSFunction, arg1: [*c]JSC__VM) bWTF__String;
pub extern fn JSC__JSGlobalObject__arrayIteratorPrototype(arg0: [*c]JSC__JSGlobalObject) ?*JSC__ArrayIteratorPrototype;
pub extern fn JSC__JSGlobalObject__arrayPrototype(arg0: [*c]JSC__JSGlobalObject) ?*JSC__ArrayPrototype;
pub extern fn JSC__JSGlobalObject__asyncFunctionPrototype(arg0: [*c]JSC__JSGlobalObject) ?*JSC__AsyncFunctionPrototype;
pub extern fn JSC__JSGlobalObject__asyncGeneratorFunctionPrototype(arg0: [*c]JSC__JSGlobalObject) ?*JSC__AsyncGeneratorFunctionPrototype;
pub extern fn JSC__JSGlobalObject__asyncGeneratorPrototype(arg0: [*c]JSC__JSGlobalObject) ?*JSC__AsyncGeneratorPrototype;
pub extern fn JSC__JSGlobalObject__asyncIteratorPrototype(arg0: [*c]JSC__JSGlobalObject) ?*JSC__AsyncIteratorPrototype;
pub extern fn JSC__JSGlobalObject__bigIntPrototype(arg0: [*c]JSC__JSGlobalObject) ?*JSC__BigIntPrototype;
pub extern fn JSC__JSGlobalObject__booleanPrototype(arg0: [*c]JSC__JSGlobalObject) [*c]JSC__JSObject;
pub extern fn JSC__JSGlobalObject__datePrototype(arg0: [*c]JSC__JSGlobalObject) [*c]JSC__JSObject;
pub extern fn JSC__JSGlobalObject__errorPrototype(arg0: [*c]JSC__JSGlobalObject) [*c]JSC__JSObject;
pub extern fn JSC__JSGlobalObject__functionPrototype(arg0: [*c]JSC__JSGlobalObject) ?*JSC__FunctionPrototype;
pub extern fn JSC__JSGlobalObject__generatorFunctionPrototype(arg0: [*c]JSC__JSGlobalObject) ?*JSC__GeneratorFunctionPrototype;
pub extern fn JSC__JSGlobalObject__generatorPrototype(arg0: [*c]JSC__JSGlobalObject) ?*JSC__GeneratorPrototype;
pub extern fn JSC__JSGlobalObject__iteratorPrototype(arg0: [*c]JSC__JSGlobalObject) ?*JSC__IteratorPrototype;
pub extern fn JSC__JSGlobalObject__jsSetPrototype(arg0: [*c]JSC__JSGlobalObject) [*c]JSC__JSObject;
pub extern fn JSC__JSGlobalObject__mapIteratorPrototype(arg0: [*c]JSC__JSGlobalObject) ?*JSC__MapIteratorPrototype;
pub extern fn JSC__JSGlobalObject__mapPrototype(arg0: [*c]JSC__JSGlobalObject) [*c]JSC__JSObject;
pub extern fn JSC__JSGlobalObject__numberPrototype(arg0: [*c]JSC__JSGlobalObject) [*c]JSC__JSObject;
pub extern fn JSC__JSGlobalObject__objectPrototype(arg0: [*c]JSC__JSGlobalObject) ?*JSC__ObjectPrototype;
pub extern fn JSC__JSGlobalObject__promisePrototype(arg0: [*c]JSC__JSGlobalObject) ?*JSC__JSPromisePrototype;
pub extern fn JSC__JSGlobalObject__regExpPrototype(arg0: [*c]JSC__JSGlobalObject) ?*JSC__RegExpPrototype;
pub extern fn JSC__JSGlobalObject__setIteratorPrototype(arg0: [*c]JSC__JSGlobalObject) ?*JSC__SetIteratorPrototype;
pub extern fn JSC__JSGlobalObject__stringPrototype(arg0: [*c]JSC__JSGlobalObject) ?*JSC__StringPrototype;
pub extern fn JSC__JSGlobalObject__symbolPrototype(arg0: [*c]JSC__JSGlobalObject) [*c]JSC__JSObject;
pub extern fn JSC__JSGlobalObject__vm(arg0: [*c]JSC__JSGlobalObject) [*c]JSC__VM;
pub extern fn WTF__URL__encodedPassword(arg0: [*c]WTF__URL) bWTF__StringView;
pub extern fn WTF__URL__encodedUser(arg0: [*c]WTF__URL) bWTF__StringView;
pub extern fn WTF__URL__fileSystemPath(arg0: [*c]WTF__URL) bWTF__String;
pub extern fn WTF__URL__fragmentIdentifier(arg0: [*c]WTF__URL) bWTF__StringView;
pub extern fn WTF__URL__fragmentIdentifierWithLeadingNumberSign(arg0: [*c]WTF__URL) bWTF__StringView;
pub extern fn WTF__URL__fromFileSystemPath(arg0: [*c]WTF__URL, arg1: bWTF__StringView) void;
pub extern fn WTF__URL__fromString(arg0: bWTF__String, arg1: bWTF__String) bWTF__URL;
pub extern fn WTF__URL__host(arg0: [*c]WTF__URL) bWTF__StringView;
pub extern fn WTF__URL__hostAndPort(arg0: [*c]WTF__URL) bWTF__String;
pub extern fn WTF__URL__isEmpty(arg0: [*c]const WTF__URL) bool;
pub extern fn WTF__URL__isValid(arg0: [*c]const WTF__URL) bool;
pub extern fn WTF__URL__lastPathComponent(arg0: [*c]WTF__URL) bWTF__StringView;
pub extern fn WTF__URL__password(arg0: [*c]WTF__URL) bWTF__String;
pub extern fn WTF__URL__path(arg0: [*c]WTF__URL) bWTF__StringView;
pub extern fn WTF__URL__protocol(arg0: [*c]WTF__URL) bWTF__StringView;
pub extern fn WTF__URL__protocolHostAndPort(arg0: [*c]WTF__URL) bWTF__String;
pub extern fn WTF__URL__query(arg0: [*c]WTF__URL) bWTF__StringView;
pub extern fn WTF__URL__queryWithLeadingQuestionMark(arg0: [*c]WTF__URL) bWTF__StringView;
pub extern fn WTF__URL__setHost(arg0: [*c]WTF__URL, arg1: bWTF__StringView) void;
pub extern fn WTF__URL__setHostAndPort(arg0: [*c]WTF__URL, arg1: bWTF__StringView) void;
pub extern fn WTF__URL__setPassword(arg0: [*c]WTF__URL, arg1: bWTF__StringView) void;
pub extern fn WTF__URL__setPath(arg0: [*c]WTF__URL, arg1: bWTF__StringView) void;
pub extern fn WTF__URL__setProtocol(arg0: [*c]WTF__URL, arg1: bWTF__StringView) void;
pub extern fn WTF__URL__setQuery(arg0: [*c]WTF__URL, arg1: bWTF__StringView) void;
pub extern fn WTF__URL__setUser(arg0: [*c]WTF__URL, arg1: bWTF__StringView) void;
pub extern fn WTF__URL__stringWithoutFragmentIdentifier(arg0: [*c]WTF__URL) bWTF__String;
pub extern fn WTF__URL__stringWithoutQueryOrFragmentIdentifier(arg0: [*c]WTF__URL) bWTF__StringView;
pub extern fn WTF__URL__truncatedForUseAsBase(arg0: [*c]WTF__URL) bWTF__URL;
pub extern fn WTF__URL__user(arg0: [*c]WTF__URL) bWTF__String;
pub extern fn WTF__String__characters16(arg0: [*c]WTF__String) [*c]const u16;
pub extern fn WTF__String__characters8(arg0: [*c]WTF__String) [*c]const u8;
pub extern fn WTF__String__createFromExternalString(arg0: bWTF__ExternalStringImpl) bWTF__String;
pub extern fn WTF__String__createWithoutCopyingFromPtr(arg0: [*c]WTF__String, arg1: [*c]u8, arg2: usize) void;
pub extern fn WTF__String__eqlSlice(arg0: [*c]WTF__String, arg1: [*c]const u8, arg2: usize) bool;
pub extern fn WTF__String__eqlString(arg0: [*c]WTF__String, arg1: [*c]const WTF__String) bool;
pub extern fn WTF__String__impl(arg0: [*c]WTF__String) [*c]const WTF__StringImpl;
pub extern fn WTF__String__is16Bit(arg0: [*c]WTF__String) bool;
pub extern fn WTF__String__is8Bit(arg0: [*c]WTF__String) bool;
pub extern fn WTF__String__isEmpty(arg0: [*c]WTF__String) bool;
pub extern fn WTF__String__isExternal(arg0: [*c]WTF__String) bool;
pub extern fn WTF__String__isStatic(arg0: [*c]WTF__String) bool;
pub extern fn WTF__String__length(arg0: [*c]WTF__String) usize;
pub extern fn JSC__JSValue__asCell(JSValue0: JSC__JSValue) [*c]JSC__JSCell;
pub extern fn JSC__JSValue__asNumber(JSValue0: JSC__JSValue) f64;
pub extern fn JSC__JSValue__asObject(JSValue0: JSC__JSValue) bJSC__JSObject;
pub extern fn JSC__JSValue__asString(JSValue0: JSC__JSValue) [*c]JSC__JSString;
pub extern fn JSC__JSValue__eqlCell(JSValue0: JSC__JSValue, arg1: [*c]JSC__JSCell) bool;
pub extern fn JSC__JSValue__eqlValue(JSValue0: JSC__JSValue, JSValue1: JSC__JSValue) bool;
pub extern fn JSC__JSValue__getPrototype(JSValue0: JSC__JSValue, arg1: [*c]JSC__JSGlobalObject) JSC__JSValue;
pub extern fn JSC__JSValue__isAnyInt(JSValue0: JSC__JSValue) bool;
pub extern fn JSC__JSValue__isBigInt(JSValue0: JSC__JSValue) bool;
pub extern fn JSC__JSValue__isBigInt32(JSValue0: JSC__JSValue) bool;
pub extern fn JSC__JSValue__isBoolean(JSValue0: JSC__JSValue) bool;
pub extern fn JSC__JSValue__isCallable(JSValue0: JSC__JSValue, arg1: [*c]JSC__VM) bool;
pub extern fn JSC__JSValue__isCell(JSValue0: JSC__JSValue) bool;
pub extern fn JSC__JSValue__isCustomGetterSetter(JSValue0: JSC__JSValue) bool;
pub extern fn JSC__JSValue__isError(JSValue0: JSC__JSValue) bool;
pub extern fn JSC__JSValue__isGetterSetter(JSValue0: JSC__JSValue) bool;
pub extern fn JSC__JSValue__isHeapBigInt(JSValue0: JSC__JSValue) bool;
pub extern fn JSC__JSValue__isInt32AsAnyInt(JSValue0: JSC__JSValue) bool;
pub extern fn JSC__JSValue__isNull(JSValue0: JSC__JSValue) bool;
pub extern fn JSC__JSValue__isNumber(JSValue0: JSC__JSValue) bool;
pub extern fn JSC__JSValue__isObject(JSValue0: JSC__JSValue) bool;
pub extern fn JSC__JSValue__isPrimitive(JSValue0: JSC__JSValue) bool;
pub extern fn JSC__JSValue__isString(JSValue0: JSC__JSValue) bool;
pub extern fn JSC__JSValue__isSymbol(JSValue0: JSC__JSValue) bool;
pub extern fn JSC__JSValue__isUInt32AsAnyInt(JSValue0: JSC__JSValue) bool;
pub extern fn JSC__JSValue__isUndefined(JSValue0: JSC__JSValue) bool;
pub extern fn JSC__JSValue__isUndefinedOrNull(JSValue0: JSC__JSValue) bool;
pub extern fn JSC__JSValue__jsBoolean(arg0: bool) JSC__JSValue;
pub extern fn JSC__JSValue__jsDoubleNumber(arg0: f64) JSC__JSValue;
pub extern fn JSC__JSValue__jsNull(...) JSC__JSValue;
pub extern fn JSC__JSValue__jsNumberFromChar(arg0: u8) JSC__JSValue;
pub extern fn JSC__JSValue__jsNumberFromDouble(arg0: f64) JSC__JSValue;
pub extern fn JSC__JSValue__jsNumberFromInt32(arg0: i32) JSC__JSValue;
pub extern fn JSC__JSValue__jsNumberFromInt64(arg0: i64) JSC__JSValue;
pub extern fn JSC__JSValue__jsNumberFromU16(arg0: u16) JSC__JSValue;
pub extern fn JSC__JSValue__jsNumberFromUint64(arg0: u64) JSC__JSValue;
pub extern fn JSC__JSValue__jsTDZValue(...) JSC__JSValue;
pub extern fn JSC__JSValue__jsUndefined(...) JSC__JSValue;
pub extern fn JSC__JSValue__toObject(JSValue0: JSC__JSValue, arg1: [*c]JSC__JSGlobalObject) [*c]JSC__JSObject;
pub extern fn JSC__JSValue__toPropertyKey(JSValue0: JSC__JSValue, arg1: [*c]JSC__JSGlobalObject) bJSC__Identifier;
pub extern fn JSC__JSValue__toPropertyKeyValue(JSValue0: JSC__JSValue, arg1: [*c]JSC__JSGlobalObject) JSC__JSValue;
pub extern fn JSC__JSValue__toString(JSValue0: JSC__JSValue, arg1: [*c]JSC__JSGlobalObject) [*c]JSC__JSString;
pub extern fn JSC__JSValue__toStringOrNull(JSValue0: JSC__JSValue, arg1: [*c]JSC__JSGlobalObject) [*c]JSC__JSString;
pub extern fn JSC__JSValue__toWTFString(JSValue0: JSC__JSValue, arg1: [*c]JSC__JSGlobalObject) bWTF__String;
pub extern fn JSC__PropertyName__eqlToIdentifier(arg0: [*c]JSC__PropertyName, arg1: [*c]const JSC__Identifier) bool;
pub extern fn JSC__PropertyName__eqlToPropertyName(arg0: [*c]JSC__PropertyName, arg1: [*c]const JSC__PropertyName) bool;
pub extern fn JSC__PropertyName__publicName(arg0: [*c]JSC__PropertyName) [*c]const WTF__StringImpl;
pub extern fn JSC__PropertyName__uid(arg0: [*c]JSC__PropertyName) [*c]const WTF__StringImpl;
pub extern fn JSC__Exception__create(arg0: [*c]JSC__JSGlobalObject, arg1: [*c]JSC__JSObject, StackCaptureAction2: u8) [*c]JSC__Exception;
pub extern fn JSC__VM__apiLock(arg0: [*c]JSC__VM) [*c]JSC__JSLock;
pub extern fn JSC__VM__create(HeapType0: u8) [*c]JSC__VM;
pub extern fn JSC__VM__deinit(arg0: [*c]JSC__VM, arg1: [*c]JSC__JSGlobalObject) void;
pub extern fn JSC__VM__drainMicrotasks(arg0: [*c]JSC__VM) void;
pub extern fn JSC__VM__executionForbidden(arg0: [*c]JSC__VM) bool;
pub extern fn JSC__VM__isEntered(arg0: [*c]JSC__VM) bool;
pub extern fn JSC__VM__setExecutionForbidden(arg0: [*c]JSC__VM, arg1: bool) void;
pub extern fn JSC__VM__throwError(arg0: [*c]JSC__VM, arg1: [*c]JSC__JSGlobalObject, arg2: [*c]JSC__ThrowScope, arg3: [*c]const u8, arg4: usize) bool;
pub extern fn JSC__ThrowScope__clearException(arg0: [*c]JSC__ThrowScope) void;
pub extern fn JSC__ThrowScope__declare(arg0: [*c]JSC__VM, arg1: [*c]u8, arg2: [*c]u8, arg3: usize) bJSC__ThrowScope;
pub extern fn JSC__ThrowScope__exception(arg0: [*c]JSC__ThrowScope) [*c]JSC__Exception;
pub extern fn JSC__ThrowScope__release(arg0: [*c]JSC__ThrowScope) void;
pub extern fn JSC__CatchScope__clearException(arg0: [*c]JSC__CatchScope) void;
pub extern fn JSC__CatchScope__declare(arg0: [*c]JSC__VM, arg1: [*c]u8, arg2: [*c]u8, arg3: usize) bJSC__CatchScope;
pub extern fn JSC__CatchScope__exception(arg0: [*c]JSC__CatchScope) [*c]JSC__Exception;
pub extern fn JSC__CallFrame__argument(arg0: [*c]const JSC__CallFrame, arg1: u16) JSC__JSValue;
pub extern fn JSC__CallFrame__argumentsCount(arg0: [*c]const JSC__CallFrame) usize;
pub extern fn JSC__CallFrame__jsCallee(arg0: [*c]const JSC__CallFrame) [*c]JSC__JSObject;
pub extern fn JSC__CallFrame__newTarget(arg0: [*c]const JSC__CallFrame) JSC__JSValue;
pub extern fn JSC__CallFrame__setNewTarget(arg0: [*c]JSC__CallFrame, JSValue1: JSC__JSValue) JSC__JSValue;
pub extern fn JSC__CallFrame__setThisValue(arg0: [*c]JSC__CallFrame, JSValue1: JSC__JSValue) JSC__JSValue;
pub extern fn JSC__CallFrame__thisValue(arg0: [*c]const JSC__CallFrame) JSC__JSValue;
pub extern fn JSC__CallFrame__uncheckedArgument(arg0: [*c]const JSC__CallFrame, arg1: u16) JSC__JSValue;
pub extern fn JSC__Identifier__deinit(arg0: [*c]const JSC__Identifier) void;
pub extern fn JSC__Identifier__eqlIdent(arg0: [*c]const JSC__Identifier, arg1: [*c]const JSC__Identifier) bool;
pub extern fn JSC__Identifier__eqlStringImpl(arg0: [*c]const JSC__Identifier, arg1: [*c]const WTF__StringImpl) bool;
pub extern fn JSC__Identifier__eqlUTF8(arg0: [*c]const JSC__Identifier, arg1: [*c]const u8, arg2: usize) bool;
pub extern fn JSC__Identifier__fromSlice(arg0: [*c]JSC__VM, arg1: [*c]const u8, arg2: usize) bJSC__Identifier;
pub extern fn JSC__Identifier__fromString(arg0: [*c]JSC__VM, arg1: [*c]const WTF__String) bJSC__Identifier;
pub extern fn JSC__Identifier__isEmpty(arg0: [*c]const JSC__Identifier) bool;
pub extern fn JSC__Identifier__isNull(arg0: [*c]const JSC__Identifier) bool;
pub extern fn JSC__Identifier__isPrivateName(arg0: [*c]const JSC__Identifier) bool;
pub extern fn JSC__Identifier__isSymbol(arg0: [*c]const JSC__Identifier) bool;
pub extern fn JSC__Identifier__length(arg0: [*c]const JSC__Identifier) usize;
pub extern fn JSC__Identifier__neqlIdent(arg0: [*c]const JSC__Identifier, arg1: [*c]const JSC__Identifier) bool;
pub extern fn JSC__Identifier__neqlStringImpl(arg0: [*c]const JSC__Identifier, arg1: [*c]const WTF__StringImpl) bool;
pub extern fn JSC__Identifier__toString(arg0: [*c]const JSC__Identifier) bWTF__String;
pub extern fn WTF__StringImpl__characters16(arg0: [*c]const WTF__StringImpl) [*c]const u16;
pub extern fn WTF__StringImpl__characters8(arg0: [*c]const WTF__StringImpl) [*c]const u8;
pub extern fn WTF__StringImpl__is16Bit(arg0: [*c]const WTF__StringImpl) bool;
pub extern fn WTF__StringImpl__is8Bit(arg0: [*c]const WTF__StringImpl) bool;
pub extern fn WTF__StringImpl__isEmpty(arg0: [*c]const WTF__StringImpl) bool;
pub extern fn WTF__StringImpl__isExternal(arg0: [*c]const WTF__StringImpl) bool;
pub extern fn WTF__StringImpl__isStatic(arg0: [*c]const WTF__StringImpl) bool;
pub extern fn WTF__StringImpl__length(arg0: [*c]const WTF__StringImpl) usize;
pub extern fn WTF__ExternalStringImpl__characters16(arg0: [*c]const WTF__ExternalStringImpl) [*c]const u16;
pub extern fn WTF__ExternalStringImpl__characters8(arg0: [*c]const WTF__ExternalStringImpl) [*c]const u8;
pub extern fn WTF__ExternalStringImpl__create(arg0: [*c]const u8, arg1: usize, ArgFn2: ?fn (?*c_void, [*c]u8, usize) callconv(.C) void) bWTF__ExternalStringImpl;
pub extern fn WTF__ExternalStringImpl__is16Bit(arg0: [*c]const WTF__ExternalStringImpl) bool;
pub extern fn WTF__ExternalStringImpl__is8Bit(arg0: [*c]const WTF__ExternalStringImpl) bool;
pub extern fn WTF__ExternalStringImpl__isEmpty(arg0: [*c]const WTF__ExternalStringImpl) bool;
pub extern fn WTF__ExternalStringImpl__length(arg0: [*c]const WTF__ExternalStringImpl) usize;
pub extern fn WTF__StringView__characters16(arg0: [*c]const WTF__StringView) [*c]const u16;
pub extern fn WTF__StringView__characters8(arg0: [*c]const WTF__StringView) [*c]const u8;
pub extern fn WTF__StringView__from8Bit(arg0: [*c]WTF__StringView, arg1: [*c]const u8, arg2: usize) void;
pub extern fn WTF__StringView__is16Bit(arg0: [*c]const WTF__StringView) bool;
pub extern fn WTF__StringView__is8Bit(arg0: [*c]const WTF__StringView) bool;
pub extern fn WTF__StringView__isEmpty(arg0: [*c]const WTF__StringView) bool;
pub extern fn WTF__StringView__length(arg0: [*c]const WTF__StringView) usize;
pub extern fn Zig__GlobalObject__create(arg0: [*c]JSC__VM, arg1: ?*c_void) [*c]JSC__JSGlobalObject;

25
src/javascript/jsc/bindings/helpers.h
View File

@@ -6,6 +6,7 @@
#include <JavaScriptCore/VM.h>
template<class CppType, typename ZigType>
class Wrap {
public:
@@ -17,16 +18,20 @@ public:
cpp = static_cast<CppType*>(static_cast<void*>(&zig));
};
Wrap(ZigType* zig){
cpp = static_cast<CppType*>(static_cast<void*>(&zig));
};
Wrap(CppType _cpp){
char* buffer = alignedBuffer();
memcpy(buffer, std::move(reinterpret_cast<char*>(reinterpret_cast<void*>(&_cpp))), sizeof(CppType));
cpp = reinterpret_cast<CppType*>(buffer);
auto buffer = alignedBuffer();
cpp = new (buffer) CppType(_cpp);
};
~Wrap(){};
char* alignedBuffer() {
unsigned char* alignedBuffer() {
return result.bytes + alignof(CppType) - reinterpret_cast<intptr_t>(result.bytes) % alignof(CppType);
}
@@ -37,9 +42,17 @@ public:
return *static_cast<ZigType*>(static_cast<void*>(&obj));
}
static ZigType wrap(CppType* obj) {
return *static_cast<ZigType*>(static_cast<void*>(obj));
static CppType unwrap(ZigType obj) {
return *static_cast<CppType*>(static_cast<void*>(&obj));
}
static CppType* unwrap(ZigType* obj) {
return static_cast<CppType*>(static_cast<void*>(obj));
}
};

0
src/javascript/jsc/bindings/jsc.zig Normal file
View File

9
src/javascript/jsc/bindings/shared.zig Normal file
View File

@@ -0,0 +1,9 @@
pub const std = @import("std");
pub const is_bindgen: bool = std.meta.globalOption("bindgen", bool) orelse false;
pub const StaticExport = @import("./static_export.zig");
pub const c_char = StaticExport.c_char;
pub usingnamespace @import("../../../global.zig");
pub fn zigCast(comptime Destination: type, value: anytype) *Destination {
return @ptrCast(*Destination, @alignCast(@alignOf(*Destination), value));
}

142
src/javascript/jsc/bindings/shimmer.zig
View File

@@ -1,56 +1,71 @@
const std = @import("std");
const StaticExport = @import("./static_export.zig");
const Sizes = @import("./sizes.zig");
const is_bindgen: bool = std.meta.globalOption("bindgen", bool) orelse false;
pub const is_bindgen: bool = std.meta.globalOption("bindgen", bool) orelse false;
pub fn Shimmer(comptime _namespace: []const u8, comptime _name: []const u8, comptime Parent: type) type {
const extern_count: usize = if (@hasDecl(Parent, "Extern")) Parent.Extern.len else 0;
return struct {
pub const namespace = _namespace;
pub const name = _name;
fn toCppType(comptime FromType: ?type) ?type {
return comptime brk: {
var NewReturnType = FromType orelse c_void;
// fn toCppType(comptime FromType: type) type {
// var NewReturnType = FromType;
if (NewReturnType == c_void) {
break :brk FromType;
}
// if (NewReturnType == c_void) {
// return FromType;
// }
var ReturnTypeInfo: std.builtin.TypeInfo = @typeInfo(FromType orelse c_void);
// var ReturnTypeInfo: std.builtin.TypeInfo = @typeInfo(FromType);
if (ReturnTypeInfo == .Pointer and NewReturnType != *c_void) {
NewReturnType = ReturnTypeInfo.Pointer.child;
ReturnTypeInfo = @typeInfo(NewReturnType);
}
// if (ReturnTypeInfo == .Pointer and NewReturnType != *c_void) {
// NewReturnType = ReturnTypeInfo.Pointer.child;
// ReturnTypeInfo = @typeInfo(NewReturnType);
// }
switch (ReturnTypeInfo) {
.Union,
.Struct,
.Enum,
=> {
if (@hasDecl(ReturnTypeInfo, "Type")) {
break :brk NewReturnType;
}
},
else => {},
}
// switch (ReturnTypeInfo) {
// .Union,
// .Struct,
// .Enum,
// => {
// if (@hasDecl(ReturnTypeInfo., "Type")) {
// return NewReturnType;
// }
// },
// else => {},
// }
break :brk FromType;
};
}
// return FromType;
// }
pub const align_of_symbol = std.fmt.comptimePrint("{s}__{s}_object_align_", .{ namespace, name });
pub const size_of_symbol = std.fmt.comptimePrint("{s}__{s}_object_size_", .{ namespace, name });
const align_symbol = std.fmt.comptimePrint("{s}__{s}_align", .{ namespace, name });
pub const byte_size = brk: {
const identifier = std.fmt.comptimePrint("{s}__{s}", .{ namespace, name });
const align_symbol = std.fmt.comptimePrint("{s}__{s}_align", .{ namespace, name });
if (@hasDecl(Sizes, identifier)) {
break :brk @field(Sizes, identifier); //+ @field(Sizes, align_symbol);
break :brk @field(Sizes, identifier);
} else {
break :brk 0;
}
};
pub const align_size = brk: {
const identifier = std.fmt.comptimePrint("{s}__{s}_align", .{ namespace, name });
if (@hasDecl(Sizes, identifier)) {
break :brk @field(Sizes, identifier);
} else {
break :brk 0;
}
};
pub const Bytes = [byte_size]u8;
pub const Return = struct {
pub const Type = Parent;
pub const is_return = true;
};
pub inline fn getConvertibleType(comptime ZigType: type) type {
if (@typeInfo(ZigType) == .Struct) {
const Struct: std.builtin.TypeInfo.Struct = ChildType.Struct;
@@ -72,17 +87,6 @@ pub fn Shimmer(comptime _namespace: []const u8, comptime _name: []const u8, comp
return Type;
}
pub inline fn toZigType(comptime ZigType: type, comptime CppType: type, value: CppType) *ZigType {
if (comptime hasRef(ZigType)) {
// *WTF::String => Wtf.String{ = value}, via casting instead of copying
if (comptime @typeInfo(CppType) == .Pointer and @typeInfo(ZigType) != .Pointer) {
return @bitCast(ZigType, @ptrToInt(value));
}
}
return @as(ZigType, value);
}
pub fn symbolName(comptime typeName: []const u8) []const u8 {
return comptime std.fmt.comptimePrint("{s}__{s}__{s}", .{ namespace, name, typeName });
}
@@ -114,34 +118,6 @@ pub fn Shimmer(comptime _namespace: []const u8, comptime _name: []const u8, comp
};
}
pub inline fn zigFn(comptime typeName: []const u8, args: anytype) (@typeInfo(@TypeOf(@field(Parent, typeName))).Fn.return_type orelse void) {
const identifier = symbolName(typeName);
const func = comptime @typeInfo(Parent).Struct.fields[std.meta.fieldIndex(Parent, typeName)].field_type;
const ReturnType = comptime @typeInfo(func).Fn.return_type orelse c_void;
const Func: type = comptime brk: {
var FuncType: std.builtin.TypeInfo = @typeInfo(@TypeOf(func));
var Fn: std.builtin.TypeInfo.Fn = FuncType.Fn;
Fn.calling_convention = std.builtin.CallingConvention.C;
Fn.return_type = toCppType(Fn.return_type);
const ArgsType = @TypeOf(args);
for (std.meta.fieldNames(args)) |field, i| {
Fn.args[i] = std.builtin.TypeInfo.FnArg{
.is_generic = false,
.is_noalias = false,
.arg_type = @typeInfo(ArgsType).fields[i].field_type,
};
}
FuncType.Fn = Fn;
break :brk @Type(FuncType);
};
comptime @export(Func, .{ .name = identifier });
unreachable;
}
pub inline fn cppFn(comptime typeName: []const u8, args: anytype) (ret: {
if (!@hasDecl(Parent, typeName)) {
@compileError(@typeName(Parent) ++ " is missing cppFn: " ++ typeName);
@@ -150,37 +126,7 @@ pub fn Shimmer(comptime _namespace: []const u8, comptime _name: []const u8, comp
}) {
if (comptime is_bindgen) {
unreachable;
} else {
const identifier = comptime std.fmt.comptimePrint("{s}__{s}__{s}", .{ namespace, name, typeName });
const func = comptime @typeInfo(Parent).Struct.fields[std.meta.fieldIndex(Parent, typeName)].field_type;
const ReturnType = comptime @typeInfo(func).Fn.return_type orelse c_void;
const Func: type = comptime brk: {
var FuncType: std.builtin.TypeInfo = @typeInfo(@TypeOf(func));
var Fn: std.builtin.TypeInfo.Fn = FuncType.Fn;
Fn.calling_convention = std.builtin.CallingConvention.C;
Fn.return_type = toCppType(Fn.return_type);
const ArgsType = @TypeOf(args);
for (std.meta.fieldNames(args)) |field, i| {
Fn.args[i] = std.builtin.TypeInfo.FnArg{
.is_generic = false,
.is_noalias = false,
.arg_type = @typeInfo(ArgsType).fields[i].field_type,
};
}
FuncType.Fn = Fn;
break :brk @Type(FuncType);
};
const Outgoing = comptime @extern(Func, std.builtin.ExternOptions{ .name = identifier });
return toZigType(
ReturnType,
@typeInfo(Func).Fn.return_type orelse void,
@call(.{}, Outgoing, args),
);
}
} else {}
}
};
}

16
src/javascript/jsc/bindings/sizes.zig
View File

@@ -1,4 +1,4 @@
// Auto-generated by src/javascript/jsc/headergen/sizegen.cpp at 2021-07-23 23:37:1627108668.
// Auto-generated by src/javascript/jsc/headergen/sizegen.cpp at 2021-07-26 01:37:1627288660.
// These are the byte sizes for the different object types with bindings in JavaScriptCore.
// This allows us to safely return stack allocated C++ types to Zig.
// It is only safe to do this when these sizes are correct.
@@ -8,7 +8,7 @@
// Failure to do so will lead to undefined behavior and probably some frustrated people.
// --- Regenerate this: ---
// 1. "make jsc-bindings-headers"
// 2. "make sizegen"
// 2. "makpe sizegen"
// 3. "make jsc-bindings-headers"
// ------------------------
// You can verify the numbers written in this file at runtime via the `extern`d types
@@ -21,13 +21,11 @@ pub const JSC__JSString = 16;
pub const JSC__JSString_align = 8;
pub const Inspector__ScriptArguments = 32;
pub const Inspector__ScriptArguments_align = 8;
pub const Zig__GlobalObject = 2464;
pub const Zig__GlobalObject = 2400;
pub const Zig__GlobalObject_align = 8;
pub const Wundle__DefaultGlobal = 2464;
pub const Wundle__DefaultGlobal_align = 8;
pub const JSC__JSModuleLoader = 16;
pub const JSC__JSModuleLoader_align = 8;
pub const JSC__JSModuleRecord = 344;
pub const JSC__JSModuleRecord = 216;
pub const JSC__JSModuleRecord_align = 8;
pub const JSC__JSPromise = 32;
pub const JSC__JSPromise_align = 8;
@@ -39,7 +37,7 @@ pub const JSC__SourceCode = 24;
pub const JSC__SourceCode_align = 8;
pub const JSC__JSFunction = 32;
pub const JSC__JSFunction_align = 8;
pub const JSC__JSGlobalObject = 2464;
pub const JSC__JSGlobalObject = 2400;
pub const JSC__JSGlobalObject_align = 8;
pub const WTF__URL = 40;
pub const WTF__URL_align = 8;
@@ -51,7 +49,7 @@ pub const JSC__PropertyName = 8;
pub const JSC__PropertyName_align = 8;
pub const JSC__Exception = 40;
pub const JSC__Exception_align = 8;
pub const JSC__VM = 49080;
pub const JSC__VM = 48824;
pub const JSC__VM_align = 8;
pub const JSC__ThrowScope = 8;
pub const JSC__ThrowScope_align = 8;
@@ -65,5 +63,5 @@ pub const WTF__StringImpl = 24;
pub const WTF__StringImpl_align = 8;
pub const WTF__ExternalStringImpl = 32;
pub const WTF__ExternalStringImpl_align = 8;
pub const WTF__StringView = 24;
pub const WTF__StringView = 16;
pub const WTF__StringView_align = 8;

2
src/javascript/jsc/bindings/static_export.zig
View File

@@ -11,3 +11,5 @@ pub fn Decl(comptime this: *const @This()) std.builtin.TypeInfo.Declaration {
pub fn wrappedName(comptime this: *const @This()) []const u8 {
return comptime "wrap" ++ this.symbol_name;
}
pub const c_char = enum(u8) { _ };

0
src/javascript/jsc/bindings/wrapper.zig Normal file
View File