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

process.stdout and process.stderr

Browse Source
This commit is contained in:
Jarred Sumner
2022-12-03 08:25:15 -08:00
parent bc028168a8
commit bdc43c1696
15 changed files with 1537 additions and 564 deletions
Download Patch File Download Diff File Expand all files Collapse all files

83
src/bun.js/bindings/Process.cpp
View File

@@ -6,7 +6,7 @@
#include "ZigGlobalObject.h"
#include "headers.h"
#include "JSEnvironmentVariableMap.h"
#include "ImportMetaObject.h"
#pragma mark - Node.js Process
namespace Zig {
@@ -39,6 +39,78 @@ static JSC_DECLARE_CUSTOM_GETTER(Process_getPPID);
static JSC_DECLARE_HOST_FUNCTION(Process_functionCwd);
static JSValue constructStdioWriteStream(JSC::JSGlobalObject* globalObject, int fd)
{
auto& vm = globalObject->vm();
auto scope = DECLARE_THROW_SCOPE(vm);
auto* thisObject = reinterpret_cast<Zig::GlobalObject*>(globalObject);
JSC::JSFunction* getStdioWriteStream = JSC::JSFunction::create(vm, processObjectInternalsGetStdioWriteStreamCodeGenerator(vm), globalObject);
JSC::MarkedArgumentBuffer args;
WTF::String process = WTF::String("node:process"_s);
JSC::JSValue requireFunction = Zig::ImportMetaObject::createRequireFunction(
vm,
globalObject,
process);
args.append(JSC::jsNumber(fd));
args.append(requireFunction);
auto clientData = WebCore::clientData(vm);
JSC::CallData callData = JSC::getCallData(getStdioWriteStream);
NakedPtr<JSC::Exception> returnedException = nullptr;
auto result = JSC::call(globalObject, getStdioWriteStream, callData, globalObject->globalThis(), args, returnedException);
RETURN_IF_EXCEPTION(scope, {});
if (returnedException) {
throwException(globalObject, scope, returnedException.get());
return {};
}
return result;
}
JSC_DEFINE_CUSTOM_GETTER(
Process_lazyStdinGetter,
(JSGlobalObject * globalObject, EncodedJSValue thisValue, PropertyName property))
{
}
JSC_DEFINE_CUSTOM_GETTER(
Process_lazyStdoutGetter,
(JSGlobalObject * globalObject, EncodedJSValue thisValue, PropertyName property))
{
JSValue value = JSValue::decode(thisValue);
auto& vm = globalObject->vm();
JSC::JSObject* thisObject = value.toObject(globalObject);
JSC::JSValue stream = constructStdioWriteStream(globalObject, 1);
thisObject->putDirect(vm, property, stream, 0);
return JSValue::encode(stream);
}
JSC_DEFINE_CUSTOM_GETTER(
Process_lazyStderrGetter, (JSGlobalObject * globalObject, EncodedJSValue thisValue, PropertyName property))
{
JSValue value = JSValue::decode(thisValue);
auto& vm = globalObject->vm();
JSC::JSObject* thisObject = value.toObject(globalObject);
JSC::JSValue stream = constructStdioWriteStream(globalObject, 2);
thisObject->putDirect(vm, property, stream, 0);
return JSValue::encode(stream);
}
JSC_DEFINE_CUSTOM_SETTER(Process_defaultSetter,
(JSC::JSGlobalObject * globalObject, JSC::EncodedJSValue thisValue,
JSC::EncodedJSValue value, JSC::PropertyName propertyName))
{
JSC::VM& vm = globalObject->vm();
JSC::JSObject* thisObject = JSC::jsDynamicCast<JSC::JSObject*>(JSValue::decode(thisValue));
thisObject->putDirect(vm, propertyName, JSValue::decode(value), 0);
return true;
}
JSC_DECLARE_HOST_FUNCTION(Process_functionNextTick);
JSC_DEFINE_HOST_FUNCTION(Process_functionNextTick,
(JSC::JSGlobalObject * globalObject, JSC::CallFrame* callFrame))
@@ -241,7 +313,6 @@ static JSC_DECLARE_HOST_FUNCTION(Process_functionChdir);
static JSC_DEFINE_HOST_FUNCTION(Process_functionChdir,
(JSC::JSGlobalObject * globalObject, JSC::CallFrame* callFrame))
{
auto scope = DECLARE_THROW_SCOPE(globalObject->vm());
ZigString str = ZigString { nullptr, 0 };
@@ -389,6 +460,12 @@ void Process::finishCreation(JSC::VM& vm)
this->putDirectCustomAccessor(vm, JSC::PropertyName(JSC::Identifier::fromString(vm, "release"_s)),
JSC::CustomGetterSetter::create(vm, Process_getterRelease, Process_setterRelease), 0);
this->putDirectCustomAccessor(vm, JSC::PropertyName(JSC::Identifier::fromString(vm, "stdout"_s)),
JSC::CustomGetterSetter::create(vm, Process_lazyStdoutGetter, Process_defaultSetter), 0);
this->putDirectCustomAccessor(vm, JSC::PropertyName(JSC::Identifier::fromString(vm, "stderr"_s)),
JSC::CustomGetterSetter::create(vm, Process_lazyStderrGetter, Process_defaultSetter), 0);
}
const JSC::ClassInfo Process::s_info = { "Process"_s, &Base::s_info, nullptr, nullptr,
@@ -522,7 +599,6 @@ JSC_DEFINE_CUSTOM_SETTER(Process_setVersionsLazy,
(JSC::JSGlobalObject * globalObject, JSC::EncodedJSValue thisValue,
JSC::EncodedJSValue value, JSC::PropertyName))
{
JSC::VM& vm = globalObject->vm();
auto clientData = WebCore::clientData(vm);
@@ -540,7 +616,6 @@ JSC_DEFINE_CUSTOM_SETTER(Process_setVersionsLazy,
static JSC_DEFINE_HOST_FUNCTION(Process_functionCwd,
(JSC::JSGlobalObject * globalObject, JSC::CallFrame* callFrame))
{
auto scope = DECLARE_THROW_SCOPE(globalObject->vm());
JSC::JSValue result = JSC::JSValue::decode(Bun__Process__getCwd(globalObject));
JSC::JSObject* obj = result.getObject();

6
src/bun.js/bindings/ZigGlobalObject.cpp
View File

@@ -2923,7 +2923,6 @@ void GlobalObject::addBuiltinGlobals(JSC::VM& vm)
extraStaticGlobals.uncheckedAppend(GlobalPropertyInfo(builtinNames.whenSignalAbortedPrivateName(), JSFunction::create(vm, this, 2, String(), whenSignalAborted, ImplementationVisibility::Public), PropertyAttribute::DontDelete | PropertyAttribute::ReadOnly));
extraStaticGlobals.uncheckedAppend(GlobalPropertyInfo(builtinNames.cloneArrayBufferPrivateName(), JSFunction::create(vm, this, 3, String(), cloneArrayBuffer, ImplementationVisibility::Public), PropertyAttribute::DontDelete | PropertyAttribute::ReadOnly));
extraStaticGlobals.uncheckedAppend(GlobalPropertyInfo(builtinNames.structuredCloneForStreamPrivateName(), JSFunction::create(vm, this, 1, String(), structuredCloneForStream, ImplementationVisibility::Public), PropertyAttribute::DontDelete | PropertyAttribute::ReadOnly));
extraStaticGlobals.uncheckedAppend(GlobalPropertyInfo(vm.propertyNames->builtinNames().ArrayBufferPrivateName(), arrayBufferConstructor(), PropertyAttribute::DontDelete | PropertyAttribute::ReadOnly));
extraStaticGlobals.uncheckedAppend(GlobalPropertyInfo(builtinNames.streamClosedPrivateName(), jsNumber(1), PropertyAttribute::DontDelete | PropertyAttribute::ReadOnly | PropertyAttribute::ConstantInteger));
extraStaticGlobals.uncheckedAppend(GlobalPropertyInfo(builtinNames.streamClosingPrivateName(), jsNumber(2), PropertyAttribute::DontDelete | PropertyAttribute::ReadOnly | PropertyAttribute::ConstantInteger));
extraStaticGlobals.uncheckedAppend(GlobalPropertyInfo(builtinNames.streamErroredPrivateName(), jsNumber(3), PropertyAttribute::DontDelete | PropertyAttribute::ReadOnly | PropertyAttribute::ConstantInteger));
@@ -2942,7 +2941,6 @@ void GlobalObject::addBuiltinGlobals(JSC::VM& vm)
extraStaticGlobals.releaseBuffer();
putDirectBuiltinFunction(vm, this, builtinNames.createFIFOPrivateName(), streamInternalsCreateFIFOCodeGenerator(vm), PropertyAttribute::Builtin | PropertyAttribute::DontDelete | PropertyAttribute::ReadOnly);
putDirectBuiltinFunction(vm, this, builtinNames.createNativeReadableStreamPrivateName(), readableStreamCreateNativeReadableStreamCodeGenerator(vm), PropertyAttribute::Builtin | PropertyAttribute::DontDelete | PropertyAttribute::ReadOnly);
putDirectBuiltinFunction(vm, this, builtinNames.createEmptyReadableStreamPrivateName(), readableStreamCreateEmptyReadableStreamCodeGenerator(vm), PropertyAttribute::Builtin | PropertyAttribute::DontDelete | PropertyAttribute::ReadOnly);
putDirectBuiltinFunction(vm, this, builtinNames.consumeReadableStreamPrivateName(), readableStreamConsumeReadableStreamCodeGenerator(vm), PropertyAttribute::Builtin | PropertyAttribute::DontDelete | PropertyAttribute::ReadOnly);
@@ -2952,7 +2950,6 @@ void GlobalObject::addBuiltinGlobals(JSC::VM& vm)
putDirectBuiltinFunction(vm, this, builtinNames.requireESMPrivateName(), importMetaObjectRequireESMCodeGenerator(vm), PropertyAttribute::Builtin | PropertyAttribute::DontDelete | PropertyAttribute::ReadOnly);
putDirectBuiltinFunction(vm, this, builtinNames.requirePrivateName(), importMetaObjectRequireCodeGenerator(vm), PropertyAttribute::Builtin | PropertyAttribute::DontDelete | PropertyAttribute::ReadOnly);
putDirectBuiltinFunction(vm, this, builtinNames.loadCJS2ESMPrivateName(), importMetaObjectLoadCJS2ESMCodeGenerator(vm), PropertyAttribute::Builtin | PropertyAttribute::DontDelete | PropertyAttribute::ReadOnly);
putDirectNativeFunction(vm, this, builtinNames.createUninitializedArrayBufferPrivateName(), 1, functionCreateUninitializedArrayBuffer, ImplementationVisibility::Public, NoIntrinsic, PropertyAttribute::DontDelete | PropertyAttribute::ReadOnly | PropertyAttribute::Function);
putDirectNativeFunction(vm, this, builtinNames.resolveSyncPrivateName(), 1, functionImportMeta__resolveSync, ImplementationVisibility::Public, NoIntrinsic, PropertyAttribute::DontDelete | PropertyAttribute::ReadOnly | PropertyAttribute::Function);
@@ -3034,7 +3031,6 @@ void GlobalObject::addBuiltinGlobals(JSC::VM& vm)
putDirectCustomAccessor(vm, static_cast<JSVMClientData*>(vm.clientData)->builtinNames().WritableStreamDefaultControllerPrivateName(), CustomGetterSetter::create(vm, jsServiceWorkerGlobalScope_WritableStreamDefaultControllerConstructor, nullptr), attributesForStructure(JSC::PropertyAttribute::DontDelete | JSC::PropertyAttribute::ReadOnly));
putDirectCustomAccessor(vm, static_cast<JSVMClientData*>(vm.clientData)->builtinNames().WritableStreamDefaultWriterPrivateName(), CustomGetterSetter::create(vm, jsServiceWorkerGlobalScope_WritableStreamDefaultWriterConstructor, nullptr), attributesForStructure(JSC::PropertyAttribute::DontDelete | JSC::PropertyAttribute::ReadOnly));
putDirectCustomAccessor(vm, static_cast<JSVMClientData*>(vm.clientData)->builtinNames().AbortSignalPrivateName(), CustomGetterSetter::create(vm, JSDOMAbortSignal_getter, nullptr), JSC::PropertyAttribute::DontDelete | JSC::PropertyAttribute::ReadOnly);
putDirectCustomAccessor(vm, static_cast<JSVMClientData*>(vm.clientData)->builtinNames().TransformStreamDefaultControllerPublicName(), CustomGetterSetter::create(vm, jsServiceWorkerGlobalScope_TransformStreamDefaultControllerConstructor, nullptr), static_cast<unsigned>(JSC::PropertyAttribute::CustomAccessor | JSC::PropertyAttribute::DontEnum));
putDirectCustomAccessor(vm, static_cast<JSVMClientData*>(vm.clientData)->builtinNames().ReadableByteStreamControllerPublicName(), CustomGetterSetter::create(vm, jsServiceWorkerGlobalScope_ReadableByteStreamControllerConstructor, nullptr), JSC::PropertyAttribute::CustomAccessor | JSC::PropertyAttribute::DontDelete | JSC::PropertyAttribute::ReadOnly);
putDirectCustomAccessor(vm, static_cast<JSVMClientData*>(vm.clientData)->builtinNames().ReadableStreamPublicName(), CustomGetterSetter::create(vm, jsServiceWorkerGlobalScope_ReadableStreamConstructor, nullptr), JSC::PropertyAttribute::CustomAccessor | JSC::PropertyAttribute::DontDelete | JSC::PropertyAttribute::ReadOnly);
@@ -3045,9 +3041,9 @@ void GlobalObject::addBuiltinGlobals(JSC::VM& vm)
putDirectCustomAccessor(vm, static_cast<JSVMClientData*>(vm.clientData)->builtinNames().WritableStreamPublicName(), CustomGetterSetter::create(vm, jsServiceWorkerGlobalScope_WritableStreamConstructor, nullptr), JSC::PropertyAttribute::CustomAccessor | JSC::PropertyAttribute::DontDelete | JSC::PropertyAttribute::ReadOnly);
putDirectCustomAccessor(vm, static_cast<JSVMClientData*>(vm.clientData)->builtinNames().WritableStreamDefaultControllerPublicName(), CustomGetterSetter::create(vm, jsServiceWorkerGlobalScope_WritableStreamDefaultControllerConstructor, nullptr), JSC::PropertyAttribute::CustomAccessor | JSC::PropertyAttribute::DontDelete | JSC::PropertyAttribute::ReadOnly);
putDirectCustomAccessor(vm, static_cast<JSVMClientData*>(vm.clientData)->builtinNames().WritableStreamDefaultWriterPublicName(), CustomGetterSetter::create(vm, jsServiceWorkerGlobalScope_WritableStreamDefaultWriterConstructor, nullptr), JSC::PropertyAttribute::CustomAccessor | JSC::PropertyAttribute::DontDelete | JSC::PropertyAttribute::ReadOnly);
putDirectCustomAccessor(vm, JSC::Identifier::fromString(vm, "ByteLengthQueuingStrategy"_s), CustomGetterSetter::create(vm, jsServiceWorkerGlobalScope_ByteLengthQueuingStrategyConstructor, nullptr), JSC::PropertyAttribute::DontDelete | JSC::PropertyAttribute::ReadOnly);
putDirectCustomAccessor(vm, JSC::Identifier::fromString(vm, "CountQueuingStrategy"_s), CustomGetterSetter::create(vm, jsServiceWorkerGlobalScope_CountQueuingStrategyConstructor, nullptr), JSC::PropertyAttribute::DontDelete | JSC::PropertyAttribute::ReadOnly);
putDirectCustomAccessor(vm, JSC::Identifier::fromString(vm, "SubtleCrypto"_s), JSC::CustomGetterSetter::create(vm, getterSubtleCryptoConstructor, nullptr), JSC::PropertyAttribute::DontDelete | JSC::PropertyAttribute::ReadOnly);
putDirectCustomAccessor(vm, JSC::Identifier::fromString(vm, "CryptoKey"_s), JSC::CustomGetterSetter::create(vm, getterCryptoKeyConstructor, nullptr), JSC::PropertyAttribute::DontDelete | JSC::PropertyAttribute::ReadOnly);
}

8
src/bun.js/builtins/WebCoreJSBuiltinInternals.cpp
View File

@@ -52,6 +52,7 @@ namespace WebCore {
JSBuiltinInternalFunctions::JSBuiltinInternalFunctions(JSC::VM& vm)
: m_vm(vm)
, m_processObjectInternals(m_vm)
, m_readableByteStreamInternals(m_vm)
, m_readableStreamInternals(m_vm)
, m_streamInternals(m_vm)
@@ -64,6 +65,7 @@ JSBuiltinInternalFunctions::JSBuiltinInternalFunctions(JSC::VM& vm)
template<typename Visitor>
void JSBuiltinInternalFunctions::visit(Visitor& visitor)
{
m_processObjectInternals.visit(visitor);
m_readableByteStreamInternals.visit(visitor);
m_readableStreamInternals.visit(visitor);
m_streamInternals.visit(visitor);
@@ -78,6 +80,7 @@ template void JSBuiltinInternalFunctions::visit(SlotVisitor&);
SUPPRESS_ASAN void JSBuiltinInternalFunctions::initialize(JSDOMGlobalObject& globalObject)
{
UNUSED_PARAM(globalObject);
m_processObjectInternals.init(globalObject);
m_readableByteStreamInternals.init(globalObject);
m_readableStreamInternals.init(globalObject);
m_streamInternals.init(globalObject);
@@ -86,6 +89,11 @@ SUPPRESS_ASAN void JSBuiltinInternalFunctions::initialize(JSDOMGlobalObject& glo
JSVMClientData& clientData = *static_cast<JSVMClientData*>(m_vm.clientData);
JSDOMGlobalObject::GlobalPropertyInfo staticGlobals[] = {
#define DECLARE_GLOBAL_STATIC(name) \
JSDOMGlobalObject::GlobalPropertyInfo( \
clientData.builtinFunctions().processObjectInternalsBuiltins().name##PrivateName(), processObjectInternals().m_##name##Function.get() , JSC::PropertyAttribute::DontDelete | JSC::PropertyAttribute::ReadOnly),
WEBCORE_FOREACH_PROCESSOBJECTINTERNALS_BUILTIN_FUNCTION_NAME(DECLARE_GLOBAL_STATIC)
#undef DECLARE_GLOBAL_STATIC
#define DECLARE_GLOBAL_STATIC(name) \
JSDOMGlobalObject::GlobalPropertyInfo( \
clientData.builtinFunctions().readableByteStreamInternalsBuiltins().name##PrivateName(), readableByteStreamInternals().m_##name##Function.get() , JSC::PropertyAttribute::DontDelete | JSC::PropertyAttribute::ReadOnly),

2
src/bun.js/builtins/WebCoreJSBuiltins.cpp
View File

@@ -40,7 +40,7 @@
#include "JSBufferConstructorBuiltins.cpp"
#include "JSBufferPrototypeBuiltins.cpp"
#include "OnigurumaRegExpPrototypeBuiltins.cpp"
#include "ProcessObjectBuiltins.cpp"
#include "ProcessObjectInternalsBuiltins.cpp"
#include "ReadableByteStreamControllerBuiltins.cpp"
#include "ReadableByteStreamInternalsBuiltins.cpp"
#include "ReadableStreamBYOBReaderBuiltins.cpp"

63
src/bun.js/builtins/cpp/ProcessObjectBuiltins.cpp
View File

@@ -1,63 +0,0 @@
/*
* Copyright (c) 2015 Igalia
* Copyright (c) 2015 Igalia S.L.
* Copyright (c) 2015 Igalia.
* Copyright (c) 2015, 2016 Canon Inc. All rights reserved.
* Copyright (c) 2015, 2016, 2017 Canon Inc.
* Copyright (c) 2016, 2018 -2018 Apple Inc. All rights reserved.
* Copyright (c) 2016, 2020 Apple Inc. All rights reserved.
* Copyright (c) 2022 Codeblog Corp. All rights reserved.
*
* Redistribution and use in source and binary forms, with or without
* modification, are permitted provided that the following conditions
* are met:
* 1. Redistributions of source code must retain the above copyright
* notice, this list of conditions and the following disclaimer.
* 2. Redistributions in binary form must reproduce the above copyright
* notice, this list of conditions and the following disclaimer in the
* documentation and/or other materials provided with the distribution.
*
* THIS SOFTWARE IS PROVIDED BY APPLE INC. AND ITS CONTRIBUTORS ``AS IS''
* AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO,
* THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
* PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL APPLE INC. OR ITS CONTRIBUTORS
* BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR
* CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF
* SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS
* INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN
* CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)
* ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF
* THE POSSIBILITY OF SUCH DAMAGE.
*
*/
// DO NOT EDIT THIS FILE. It is automatically generated from JavaScript files for
// builtins by the script: Source/JavaScriptCore/Scripts/generate-js-builtins.py
#include "config.h"
#include "ProcessObjectBuiltins.h"
#include "WebCoreJSClientData.h"
#include <JavaScriptCore/HeapInlines.h>
#include <JavaScriptCore/IdentifierInlines.h>
#include <JavaScriptCore/ImplementationVisibility.h>
#include <JavaScriptCore/Intrinsic.h>
#include <JavaScriptCore/JSCJSValueInlines.h>
#include <JavaScriptCore/JSCellInlines.h>
#include <JavaScriptCore/StructureInlines.h>
#include <JavaScriptCore/VM.h>
namespace WebCore {
#define DEFINE_BUILTIN_GENERATOR(codeName, functionName, overriddenName, argumentCount) \
JSC::FunctionExecutable* codeName##Generator(JSC::VM& vm) \
{\
JSVMClientData* clientData = static_cast<JSVMClientData*>(vm.clientData); \
return clientData->builtinFunctions().processObjectBuiltins().codeName##Executable()->link(vm, nullptr, clientData->builtinFunctions().processObjectBuiltins().codeName##Source(), std::nullopt, s_##codeName##Intrinsic); \
}
WEBCORE_FOREACH_PROCESSOBJECT_BUILTIN_CODE(DEFINE_BUILTIN_GENERATOR)
#undef DEFINE_BUILTIN_GENERATOR
} // namespace WebCore

120
src/bun.js/builtins/cpp/ProcessObjectBuiltins.h
View File

@@ -1,120 +0,0 @@
/*
* Copyright (c) 2015 Igalia
* Copyright (c) 2015 Igalia S.L.
* Copyright (c) 2015 Igalia.
* Copyright (c) 2015, 2016 Canon Inc. All rights reserved.
* Copyright (c) 2015, 2016, 2017 Canon Inc.
* Copyright (c) 2016, 2018 -2018 Apple Inc. All rights reserved.
* Copyright (c) 2016, 2020 Apple Inc. All rights reserved.
* Copyright (c) 2022 Codeblog Corp. All rights reserved.
*
* Redistribution and use in source and binary forms, with or without
* modification, are permitted provided that the following conditions
* are met:
* 1. Redistributions of source code must retain the above copyright
* notice, this list of conditions and the following disclaimer.
* 2. Redistributions in binary form must reproduce the above copyright
* notice, this list of conditions and the following disclaimer in the
* documentation and/or other materials provided with the distribution.
*
* THIS SOFTWARE IS PROVIDED BY APPLE INC. AND ITS CONTRIBUTORS ``AS IS''
* AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO,
* THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
* PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL APPLE INC. OR ITS CONTRIBUTORS
* BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR
* CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF
* SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS
* INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN
* CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)
* ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF
* THE POSSIBILITY OF SUCH DAMAGE.
*
*/
// DO NOT EDIT THIS FILE. It is automatically generated from JavaScript files for
// builtins by the script: Source/JavaScriptCore/Scripts/generate-js-builtins.py
#pragma once
#include <JavaScriptCore/BuiltinUtils.h>
#include <JavaScriptCore/Identifier.h>
#include <JavaScriptCore/JSFunction.h>
#include <JavaScriptCore/UnlinkedFunctionExecutable.h>
namespace JSC {
class FunctionExecutable;
}
namespace WebCore {
/* ProcessObject */
#define WEBCORE_FOREACH_PROCESSOBJECT_BUILTIN_DATA(macro) \
#define WEBCORE_FOREACH_PROCESSOBJECT_BUILTIN_CODE(macro) \
#define WEBCORE_FOREACH_PROCESSOBJECT_BUILTIN_FUNCTION_NAME(macro) \
#define DECLARE_BUILTIN_GENERATOR(codeName, functionName, overriddenName, argumentCount) \
JSC::FunctionExecutable* codeName##Generator(JSC::VM&);
WEBCORE_FOREACH_PROCESSOBJECT_BUILTIN_CODE(DECLARE_BUILTIN_GENERATOR)
#undef DECLARE_BUILTIN_GENERATOR
class ProcessObjectBuiltinsWrapper : private JSC::WeakHandleOwner {
public:
explicit ProcessObjectBuiltinsWrapper(JSC::VM& vm)
: m_vm(vm)
WEBCORE_FOREACH_PROCESSOBJECT_BUILTIN_FUNCTION_NAME(INITIALIZE_BUILTIN_NAMES)
#define INITIALIZE_BUILTIN_SOURCE_MEMBERS(name, functionName, overriddenName, length) , m_##name##Source(JSC::makeSource(StringImpl::createWithoutCopying(s_##name, length), { }))
WEBCORE_FOREACH_PROCESSOBJECT_BUILTIN_CODE(INITIALIZE_BUILTIN_SOURCE_MEMBERS)
#undef INITIALIZE_BUILTIN_SOURCE_MEMBERS
{
}
#define EXPOSE_BUILTIN_EXECUTABLES(name, functionName, overriddenName, length) \
JSC::UnlinkedFunctionExecutable* name##Executable(); \
const JSC::SourceCode& name##Source() const { return m_##name##Source; }
WEBCORE_FOREACH_PROCESSOBJECT_BUILTIN_CODE(EXPOSE_BUILTIN_EXECUTABLES)
#undef EXPOSE_BUILTIN_EXECUTABLES
WEBCORE_FOREACH_PROCESSOBJECT_BUILTIN_FUNCTION_NAME(DECLARE_BUILTIN_IDENTIFIER_ACCESSOR)
void exportNames();
private:
JSC::VM& m_vm;
WEBCORE_FOREACH_PROCESSOBJECT_BUILTIN_FUNCTION_NAME(DECLARE_BUILTIN_NAMES)
#define DECLARE_BUILTIN_SOURCE_MEMBERS(name, functionName, overriddenName, length) \
JSC::SourceCode m_##name##Source;\
JSC::Weak<JSC::UnlinkedFunctionExecutable> m_##name##Executable;
WEBCORE_FOREACH_PROCESSOBJECT_BUILTIN_CODE(DECLARE_BUILTIN_SOURCE_MEMBERS)
#undef DECLARE_BUILTIN_SOURCE_MEMBERS
};
#define DEFINE_BUILTIN_EXECUTABLES(name, functionName, overriddenName, length) \
inline JSC::UnlinkedFunctionExecutable* ProcessObjectBuiltinsWrapper::name##Executable() \
{\
if (!m_##name##Executable) {\
JSC::Identifier executableName = functionName##PublicName();\
if (overriddenName)\
executableName = JSC::Identifier::fromString(m_vm, overriddenName);\
m_##name##Executable = JSC::Weak<JSC::UnlinkedFunctionExecutable>(JSC::createBuiltinExecutable(m_vm, m_##name##Source, executableName, s_##name##ImplementationVisibility, s_##name##ConstructorKind, s_##name##ConstructAbility), this, &m_##name##Executable);\
}\
return m_##name##Executable.get();\
}
WEBCORE_FOREACH_PROCESSOBJECT_BUILTIN_CODE(DEFINE_BUILTIN_EXECUTABLES)
#undef DEFINE_BUILTIN_EXECUTABLES
inline void ProcessObjectBuiltinsWrapper::exportNames()
{
#define EXPORT_FUNCTION_NAME(name) m_vm.propertyNames->appendExternalName(name##PublicName(), name##PrivateName());
WEBCORE_FOREACH_PROCESSOBJECT_BUILTIN_FUNCTION_NAME(EXPORT_FUNCTION_NAME)
#undef EXPORT_FUNCTION_NAME
}
} // namespace WebCore

655
src/bun.js/builtins/cpp/ProcessObjectInternalsBuiltins.cpp Normal file
View File

@@ -0,0 +1,655 @@
/*
* Copyright (c) 2015 Igalia
* Copyright (c) 2015 Igalia S.L.
* Copyright (c) 2015 Igalia.
* Copyright (c) 2015, 2016 Canon Inc. All rights reserved.
* Copyright (c) 2015, 2016, 2017 Canon Inc.
* Copyright (c) 2016, 2018 -2018 Apple Inc. All rights reserved.
* Copyright (c) 2016, 2020 Apple Inc. All rights reserved.
* Copyright (c) 2022 Codeblog Corp. All rights reserved.
*
* Redistribution and use in source and binary forms, with or without
* modification, are permitted provided that the following conditions
* are met:
* 1. Redistributions of source code must retain the above copyright
* notice, this list of conditions and the following disclaimer.
* 2. Redistributions in binary form must reproduce the above copyright
* notice, this list of conditions and the following disclaimer in the
* documentation and/or other materials provided with the distribution.
*
* THIS SOFTWARE IS PROVIDED BY APPLE INC. AND ITS CONTRIBUTORS ``AS IS''
* AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO,
* THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
* PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL APPLE INC. OR ITS CONTRIBUTORS
* BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR
* CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF
* SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS
* INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN
* CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)
* ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF
* THE POSSIBILITY OF SUCH DAMAGE.
*
*/
// DO NOT EDIT THIS FILE. It is automatically generated from JavaScript files for
// builtins by the script: Source/JavaScriptCore/Scripts/generate-js-builtins.py
#include "config.h"
#include "ProcessObjectInternalsBuiltins.h"
#include "WebCoreJSClientData.h"
#include <JavaScriptCore/HeapInlines.h>
#include <JavaScriptCore/IdentifierInlines.h>
#include <JavaScriptCore/ImplementationVisibility.h>
#include <JavaScriptCore/Intrinsic.h>
#include <JavaScriptCore/JSCJSValueInlines.h>
#include <JavaScriptCore/JSCellInlines.h>
#include <JavaScriptCore/StructureInlines.h>
#include <JavaScriptCore/VM.h>
namespace WebCore {
const JSC::ConstructAbility s_processObjectInternalsGetStdioWriteStreamCodeConstructAbility = JSC::ConstructAbility::CannotConstruct;
const JSC::ConstructorKind s_processObjectInternalsGetStdioWriteStreamCodeConstructorKind = JSC::ConstructorKind::None;
const JSC::ImplementationVisibility s_processObjectInternalsGetStdioWriteStreamCodeImplementationVisibility = JSC::ImplementationVisibility::Public;
const int s_processObjectInternalsGetStdioWriteStreamCodeLength = 9885;
static const JSC::Intrinsic s_processObjectInternalsGetStdioWriteStreamCodeIntrinsic = JSC::NoIntrinsic;
const char* const s_processObjectInternalsGetStdioWriteStreamCode =
"(function (fd_, rawRequire) {\n" \
" var module = { path: \"node:process\", require: rawRequire };\n" \
" var require = (path) => module.require(path);\n" \
"\n" \
" function createStdioWriteStream(fd_) {\n" \
" var { Duplex, eos, destroy } = require(\"node:stream\");\n" \
" var StdioWriteStream = class StdioWriteStream extends Duplex {\n" \
" #writeStream;\n" \
" #readStream;\n" \
"\n" \
" #readable = true;\n" \
" #writable = true;\n" \
" #fdPath;\n" \
"\n" \
" #onClose;\n" \
" #onDrain;\n" \
" #onFinish;\n" \
" #onReadable;\n" \
" #isTTY;\n" \
"\n" \
" get isTTY() {\n" \
" return (this.#isTTY ??= require(\"node:tty\").isatty(fd_));\n" \
" }\n" \
"\n" \
" get fd() {\n" \
" return fd_;\n" \
" }\n" \
"\n" \
" constructor(fd) {\n" \
" super({ readable: true, writable: true });\n" \
" this.#fdPath = `/dev/fd/${fd}`;\n" \
" }\n" \
"\n" \
" #onFinished(err) {\n" \
" const cb = this.#onClose;\n" \
" this.#onClose = null;\n" \
"\n" \
" if (cb) {\n" \
" cb(err);\n" \
" } else if (err) {\n" \
" this.destroy(err);\n" \
" } else if (!this.#readable && !this.#writable) {\n" \
" this.destroy();\n" \
" }\n" \
" }\n" \
"\n" \
" _destroy(err, callback) {\n" \
" if (!err && this.#onClose !== null) {\n" \
" var AbortError = class AbortError extends Error {\n" \
" constructor(\n" \
" message = \"The operation was aborted\",\n" \
" options = void 0,\n" \
" ) {\n" \
" if (options !== void 0 && typeof options !== \"object\") {\n" \
" throw new Error(\n" \
" `Invalid AbortError options:\\n" \
"\\n" \
"${JSON.stringify(\n" \
" options,\n" \
" null,\n" \
" 2,\n" \
" )}`,\n" \
" );\n" \
" }\n" \
" super(message, options);\n" \
" this.code = \"ABORT_ERR\";\n" \
" this.name = \"AbortError\";\n" \
" }\n" \
" };\n" \
" err = new AbortError();\n" \
" }\n" \
"\n" \
" this.#onDrain = null;\n" \
" this.#onFinish = null;\n" \
" if (this.#onClose === null) {\n" \
" callback(err);\n" \
" } else {\n" \
" this.#onClose = callback;\n" \
" if (this.#writeStream) destroy(this.#writeStream, err);\n" \
" if (this.#readStream) destroy(this.#readStream, err);\n" \
" }\n" \
" }\n" \
"\n" \
" _write(chunk, encoding, callback) {\n" \
" if (!this.#writeStream) {\n" \
" var { createWriteStream } = require(\"node:fs\");\n" \
" var stream = (this.#writeStream = createWriteStream(this.#fdPath));\n" \
"\n" \
" stream.on(\"finish\", () => {\n" \
" if (this.#onFinish) {\n" \
" const cb = this.#onFinish;\n" \
" this.#onFinish = null;\n" \
" cb();\n" \
" }\n" \
" });\n" \
"\n" \
" stream.on(\"drain\", () => {\n" \
" if (this.#onDrain) {\n" \
" const cb = this.#onDrain;\n" \
" this.#onDrain = null;\n" \
" cb();\n" \
" }\n" \
" });\n" \
"\n" \
" eos(stream, (err) => {\n" \
" this.#writable = false;\n" \
" if (err) {\n" \
" destroy(stream, err);\n" \
" }\n" \
" this.#onFinished(err);\n" \
" });\n" \
" }\n" \
" if (stream.write(chunk, encoding)) {\n" \
" callback();\n" \
" } else {\n" \
" this.#onDrain = callback;\n" \
" }\n" \
" }\n" \
"\n" \
" _final(callback) {\n" \
" this.#writeStream && this.#writeStream.end();\n" \
" this.#onFinish = callback;\n" \
" }\n" \
"\n" \
" #loadReadStream() {\n" \
" var { createReadStream } = require(\"node:fs\");\n" \
"\n" \
" var readStream = (this.#readStream = createReadStream(this.#fdPath));\n" \
"\n" \
" readStream.on(\"readable\", () => {\n" \
" if (this.#onReadable) {\n" \
" const cb = this.#onReadable;\n" \
" this.#onReadable = null;\n" \
" cb();\n" \
" } else {\n" \
" this.read();\n" \
" }\n" \
" });\n" \
"\n" \
" readStream.on(\"end\", () => {\n" \
" this.push(null);\n" \
" });\n" \
"\n" \
" eos(readStream, (err) => {\n" \
" this.#readable = false;\n" \
" if (err) {\n" \
" destroy(readStream, err);\n" \
" }\n" \
" this.#onFinished(err);\n" \
" });\n" \
" return readStream;\n" \
" }\n" \
"\n" \
" _read() {\n" \
" var stream = this.#readStream;\n" \
" if (!stream) {\n" \
" stream = this.#loadReadStream();\n" \
" }\n" \
"\n" \
" while (true) {\n" \
" const buf = stream.read();\n" \
" if (buf === null || !this.push(buf)) {\n" \
" return;\n" \
" }\n" \
" }\n" \
" }\n" \
" };\n" \
" return new StdioWriteStream(fd_);\n" \
" }\n" \
"\n" \
" var { EventEmitter } = require(\"node:events\");\n" \
"\n" \
" function isFastEncoding(encoding) {\n" \
" if (!encoding) return true;\n" \
"\n" \
" var normalied = encoding.toLowerCase();\n" \
" return (\n" \
" normalied === \"utf8\" ||\n" \
" normalied === \"utf-8\" ||\n" \
" normalied === \"buffer\" ||\n" \
" normalied === \"binary\" ||\n" \
" normalized === \"\"\n" \
" );\n" \
" }\n" \
" var FastStdioWriteStream = class StdioWriteStream extends EventEmitter {\n" \
" #fd;\n" \
" #innerStream;\n" \
" #writer;\n" \
" #isTTY;\n" \
"\n" \
" bytesWritten = 0;\n" \
"\n" \
" setDefaultEncoding(encoding) {\n" \
" if (this.#innerStream || !isFastEncoding(encoding)) {\n" \
" this.#ensureInnerStream();\n" \
" return this.#innerStream.setDefaultEncoding(encoding);\n" \
" }\n" \
" }\n" \
"\n" \
" #createWriter() {\n" \
" switch (this.#fd) {\n" \
" case 1: {\n" \
" var writer = Bun.stdout.writer({ highWaterMark: 0 });\n" \
" writer.unref();\n" \
" return writer;\n" \
" }\n" \
"\n" \
" case 2: {\n" \
" var writer = Bun.stderr.writer({ highWaterMark: 0 });\n" \
" writer.unref();\n" \
" return writer;\n" \
" }\n" \
" default: {\n" \
" throw new Error(\"Unsupported writer\");\n" \
" }\n" \
" }\n" \
" }\n" \
"\n" \
" #getWriter() {\n" \
" return (this.#writer ??= this.#createWriter());\n" \
" }\n" \
"\n" \
" constructor(fd_) {\n" \
" super();\n" \
" this.#fd = fd_;\n" \
" }\n" \
"\n" \
" get fd() {\n" \
" return this.#fd;\n" \
" }\n" \
"\n" \
" get isTTY() {\n" \
" return (this.#isTTY ??= require(\"node:tty\").isatty(this.#fd));\n" \
" }\n" \
"\n" \
" on(event, listener) {\n" \
" if (event === \"close\" || event === \"finish\") {\n" \
" this.#ensureInnerStream();\n" \
" return this.#innerStream.on(event, listener);\n" \
" }\n" \
"\n" \
" if (event === \"drain\") {\n" \
" return super.on(\"drain\", listener);\n" \
" }\n" \
"\n" \
" if (event === \"error\") {\n" \
" return super.on(\"error\", listener);\n" \
" }\n" \
"\n" \
" return super.on(event, listener);\n" \
" }\n" \
"\n" \
" get _writableState() {\n" \
" this.#ensureInnerStream();\n" \
" return this.#innerStream._writableState;\n" \
" }\n" \
"\n" \
" get _readableState() {\n" \
" this.#ensureInnerStream();\n" \
" return this.#innerStream._readableState;\n" \
" }\n" \
"\n" \
" pipe(destination) {\n" \
" this.#ensureInnerStream();\n" \
" return this.#innerStream.pipe(destination);\n" \
" }\n" \
"\n" \
" unpipe(destination) {\n" \
" this.#ensureInnerStream();\n" \
" return this.#innerStream.unpipe(destination);\n" \
" }\n" \
"\n" \
" #ensureInnerStream() {\n" \
" if (this.#innerStream) return;\n" \
" this.#innerStream = createStdioWriteStream(this.#fd);\n" \
" const events = this.eventNames();\n" \
" for (const event of events) {\n" \
" this.#innerStream.on(event, (...args) => {\n" \
" this.emit(event, ...args);\n" \
" });\n" \
" }\n" \
" }\n" \
"\n" \
" #write1(chunk) {\n" \
" var writer = this.#getWriter();\n" \
" const writeResult = writer.write(chunk);\n" \
" this.bytesWritten += writeResult;\n" \
" const flushResult = writer.flush();\n" \
" return !!(writeResult || flushResult);\n" \
" }\n" \
"\n" \
" #writeWithEncoding(chunk, encoding) {\n" \
" if (!isFastEncoding(encoding)) {\n" \
" this.#ensureInnerStream();\n" \
" return this.#innerStream.write(chunk, encoding);\n" \
" }\n" \
"\n" \
" return this.#write1(chunk);\n" \
" }\n" \
"\n" \
" #performCallback(cb, err) {\n" \
" if (err) {\n" \
" this.emit(\"error\", err);\n" \
" }\n" \
"\n" \
" try {\n" \
" cb(err ? err : null);\n" \
" } catch (err2) {\n" \
" this.emit(\"error\", err2);\n" \
" }\n" \
" }\n" \
"\n" \
" #writeWithCallbackAndEncoding(chunk, encoding, callback) {\n" \
" if (!isFastEncoding(encoding)) {\n" \
" this.#ensureInnerStream();\n" \
" return this.#innerStream.write(chunk, encoding, callback);\n" \
" }\n" \
"\n" \
" var writer = this.#getWriter();\n" \
" const writeResult = writer.write(chunk);\n" \
" const flushResult = writer.flush(true);\n" \
" if (flushResult?.then) {\n" \
" flushResult.then(\n" \
" () => {\n" \
" this.#performCallback(callback);\n" \
" this.emit(\"drain\");\n" \
" },\n" \
" (err) => this.#performCallback(callback, err),\n" \
" );\n" \
" return false;\n" \
" }\n" \
"\n" \
" queueMicrotask(() => {\n" \
" this.#performCallback(callback);\n" \
" });\n" \
"\n" \
" return !!(writeResult || flushResult);\n" \
" }\n" \
"\n" \
" write(chunk, encoding, callback) {\n" \
" const result = this._write(chunk, encoding, callback);\n" \
"\n" \
" if (result) {\n" \
" this.emit(\"drain\");\n" \
" }\n" \
"\n" \
" return result;\n" \
" }\n" \
"\n" \
" get hasColors() {\n" \
" return Bun.tty[this.#fd].hasColors;\n" \
" }\n" \
"\n" \
" _write(chunk, encoding, callback) {\n" \
" var inner = this.#innerStream;\n" \
" if (inner) {\n" \
" return inner.write(chunk, encoding, callback);\n" \
" }\n" \
"\n" \
" switch (arguments.length) {\n" \
" case 0: {\n" \
" var error = new Error(\"Invalid arguments\");\n" \
" error.code = \"ERR_INVALID_ARG_TYPE\";\n" \
" throw error;\n" \
" }\n" \
" case 1: {\n" \
" return this.#write1(chunk);\n" \
" }\n" \
" case 2: {\n" \
" if (typeof encoding === \"function\") {\n" \
" return this.#writeWithCallbackAndEncoding(chunk, \"\", encoding);\n" \
" } else if (typeof encoding === \"string\") {\n" \
" return this.#writeWithEncoding(chunk, encoding);\n" \
" }\n" \
" }\n" \
" default: {\n" \
" if (\n" \
" (typeof encoding !== \"undefined\" && typeof encoding !== \"string\") ||\n" \
" (typeof callback !== \"undefined\" && typeof callback !== \"function\")\n" \
" ) {\n" \
" var error = new Error(\"Invalid arguments\");\n" \
" error.code = \"ERR_INVALID_ARG_TYPE\";\n" \
" throw error;\n" \
" }\n" \
"\n" \
" if (typeof callback === \"undefined\") {\n" \
" return this.#writeWithEncoding(chunk, encoding);\n" \
" }\n" \
"\n" \
" return this.#writeWithCallbackAndEncoding(chunk, encoding, callback);\n" \
" }\n" \
" }\n" \
" }\n" \
"\n" \
" destroy() {\n" \
" return this;\n" \
" }\n" \
"\n" \
" end() {\n" \
" return this;\n" \
" }\n" \
" };\n" \
"\n" \
" return new FastStdioWriteStream(fd_);\n" \
"})\n" \
;
const JSC::ConstructAbility s_processObjectInternalsGetStdinStreamCodeConstructAbility = JSC::ConstructAbility::CannotConstruct;
const JSC::ConstructorKind s_processObjectInternalsGetStdinStreamCodeConstructorKind = JSC::ConstructorKind::None;
const JSC::ImplementationVisibility s_processObjectInternalsGetStdinStreamCodeImplementationVisibility = JSC::ImplementationVisibility::Public;
const int s_processObjectInternalsGetStdinStreamCodeLength = 3915;
static const JSC::Intrinsic s_processObjectInternalsGetStdinStreamCodeIntrinsic = JSC::NoIntrinsic;
const char* const s_processObjectInternalsGetStdinStreamCode =
"(function (fd, rawRequire, Bun) {\n" \
" var module = { path: \"node:process\", require: rawRequire };\n" \
" var require = (path) => module.require(path);\n" \
"\n" \
" var { Readable, Duplex, eos, destroy } = require(\"node:stream\");\n" \
"\n" \
" var StdinStream = class StdinStream extends Duplex {\n" \
" #readStream;\n" \
" #writeStream;\n" \
"\n" \
" #readable = true;\n" \
" #writable = true;\n" \
"\n" \
" #onFinish;\n" \
" #onClose;\n" \
" #onDrain;\n" \
" #onReadable;\n" \
"\n" \
" get isTTY() {\n" \
" return require(\"tty\").isatty(fd);\n" \
" }\n" \
"\n" \
" get fd() {\n" \
" return fd_;\n" \
" }\n" \
"\n" \
" constructor() {\n" \
" super({ readable: true, writable: true });\n" \
"\n" \
" this.#onReadable = this._read.bind(this);\n" \
" }\n" \
"\n" \
" #onFinished(err) {\n" \
" const cb = this.#onClose;\n" \
" this.#onClose = null;\n" \
"\n" \
" if (cb) {\n" \
" cb(err);\n" \
" } else if (err) {\n" \
" this.destroy(err);\n" \
" } else if (!this.#readable && !this.#writable) {\n" \
" this.destroy();\n" \
" }\n" \
" }\n" \
"\n" \
" _destroy(err, callback) {\n" \
" if (!err && this.#onClose !== null) {\n" \
" var AbortError = class AbortError extends Error {\n" \
" constructor(message = \"The operation was aborted\", options = void 0) {\n" \
" if (options !== void 0 && typeof options !== \"object\") {\n" \
" throw new Error(\n" \
" `Invalid AbortError options:\\n" \
"\\n" \
"${JSON.stringify(\n" \
" options,\n" \
" null,\n" \
" 2,\n" \
" )}`,\n" \
" );\n" \
" }\n" \
" super(message, options);\n" \
" this.code = \"ABORT_ERR\";\n" \
" this.name = \"AbortError\";\n" \
" }\n" \
" };\n" \
" err = new AbortError();\n" \
" }\n" \
"\n" \
" if (this.#onClose === null) {\n" \
" callback(err);\n" \
" } else {\n" \
" this.#onClose = callback;\n" \
" if (this.#readStream) destroy(this.#readStream, err);\n" \
" if (this.#writeStream) destroy(this.#writeStream, err);\n" \
" }\n" \
" }\n" \
"\n" \
" on(ev, cb) {\n" \
" super.on(ev, cb);\n" \
" if (!this.#readStream && (ev === \"readable\" || ev === \"data\")) {\n" \
" this.#loadReadStream();\n" \
" }\n" \
" }\n" \
"\n" \
" #loadReadStream() {\n" \
" var readStream = (this.#readStream = Readable.fromWeb(\n" \
" Bun.stdin.stream(),\n" \
" ));\n" \
"\n" \
" readStream.on(\"readable\", () => {\n" \
" const cb = this.#onReadable;\n" \
" this.#onReadable = null;\n" \
" cb();\n" \
" });\n" \
"\n" \
" readStream.on(\"end\", () => {\n" \
" this.push(null);\n" \
" });\n" \
"\n" \
" eos(readStream, (err) => {\n" \
" this.#readable = false;\n" \
" if (err) {\n" \
" destroy(readStream, err);\n" \
" }\n" \
" this.#onFinished(err);\n" \
" });\n" \
" }\n" \
"\n" \
" _read() {\n" \
" var readStream = this.#readStream;\n" \
" while (true) {\n" \
" const buf = readStream.read();\n" \
" if (buf === null || !this.push(buf)) {\n" \
" this.#onReadable = this._read.bind(this);\n" \
" return;\n" \
" }\n" \
" }\n" \
" }\n" \
"\n" \
" #constructWriteStream() {\n" \
" var { createWriteStream } = require(\"node:fs\");\n" \
" var writeStream = (this.#writeStream = createWriteStream(\"/dev/fd/0\"));\n" \
"\n" \
" writeStream.on(\"finish\", () => {\n" \
" if (this.#onFinish) {\n" \
" const cb = this.#onFinish;\n" \
" this.#onFinish = null;\n" \
" cb();\n" \
" }\n" \
" });\n" \
"\n" \
" writeStream.on(\"drain\", () => {\n" \
" if (this.#onDrain) {\n" \
" const cb = this.#onDrain;\n" \
" this.#onDrain = null;\n" \
" cb();\n" \
" }\n" \
" });\n" \
"\n" \
" eos(writeStream, (err) => {\n" \
" this.#writable = false;\n" \
" if (err) {\n" \
" destroy(writeStream, err);\n" \
" }\n" \
" this.#onFinished(err);\n" \
" });\n" \
"\n" \
" return writeStream;\n" \
" }\n" \
"\n" \
" _write(chunk, encoding, callback) {\n" \
" var writeStream = this.#writeStream;\n" \
" if (!writeStream) {\n" \
" writeStream = this.#constructWriteStream();\n" \
" }\n" \
"\n" \
" if (writeStream.write(chunk, encoding)) {\n" \
" callback();\n" \
" } else {\n" \
" this.#onDrain = callback;\n" \
" }\n" \
" }\n" \
"\n" \
" _final(callback) {\n" \
" this.#writeStream.end();\n" \
" this.#onFinish = callback.bind(this);\n" \
" }\n" \
" };\n" \
"\n" \
" return new StdinStream();\n" \
"})\n" \
;
#define DEFINE_BUILTIN_GENERATOR(codeName, functionName, overriddenName, argumentCount) \
JSC::FunctionExecutable* codeName##Generator(JSC::VM& vm) \
{\
JSVMClientData* clientData = static_cast<JSVMClientData*>(vm.clientData); \
return clientData->builtinFunctions().processObjectInternalsBuiltins().codeName##Executable()->link(vm, nullptr, clientData->builtinFunctions().processObjectInternalsBuiltins().codeName##Source(), std::nullopt, s_##codeName##Intrinsic); \
}
WEBCORE_FOREACH_PROCESSOBJECTINTERNALS_BUILTIN_CODE(DEFINE_BUILTIN_GENERATOR)
#undef DEFINE_BUILTIN_GENERATOR
} // namespace WebCore

175
src/bun.js/builtins/cpp/ProcessObjectInternalsBuiltins.h Normal file
View File

@@ -0,0 +1,175 @@
/*
* Copyright (c) 2015 Igalia
* Copyright (c) 2015 Igalia S.L.
* Copyright (c) 2015 Igalia.
* Copyright (c) 2015, 2016 Canon Inc. All rights reserved.
* Copyright (c) 2015, 2016, 2017 Canon Inc.
* Copyright (c) 2016, 2018 -2018 Apple Inc. All rights reserved.
* Copyright (c) 2016, 2020 Apple Inc. All rights reserved.
* Copyright (c) 2022 Codeblog Corp. All rights reserved.
*
* Redistribution and use in source and binary forms, with or without
* modification, are permitted provided that the following conditions
* are met:
* 1. Redistributions of source code must retain the above copyright
* notice, this list of conditions and the following disclaimer.
* 2. Redistributions in binary form must reproduce the above copyright
* notice, this list of conditions and the following disclaimer in the
* documentation and/or other materials provided with the distribution.
*
* THIS SOFTWARE IS PROVIDED BY APPLE INC. AND ITS CONTRIBUTORS ``AS IS''
* AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO,
* THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
* PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL APPLE INC. OR ITS CONTRIBUTORS
* BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR
* CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF
* SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS
* INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN
* CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)
* ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF
* THE POSSIBILITY OF SUCH DAMAGE.
*
*/
// DO NOT EDIT THIS FILE. It is automatically generated from JavaScript files for
// builtins by the script: Source/JavaScriptCore/Scripts/generate-js-builtins.py
#pragma once
#include <JavaScriptCore/BuiltinUtils.h>
#include <JavaScriptCore/Identifier.h>
#include <JavaScriptCore/JSFunction.h>
#include <JavaScriptCore/UnlinkedFunctionExecutable.h>
namespace JSC {
class FunctionExecutable;
}
namespace WebCore {
/* ProcessObjectInternals */
extern const char* const s_processObjectInternalsGetStdioWriteStreamCode;
extern const int s_processObjectInternalsGetStdioWriteStreamCodeLength;
extern const JSC::ConstructAbility s_processObjectInternalsGetStdioWriteStreamCodeConstructAbility;
extern const JSC::ConstructorKind s_processObjectInternalsGetStdioWriteStreamCodeConstructorKind;
extern const JSC::ImplementationVisibility s_processObjectInternalsGetStdioWriteStreamCodeImplementationVisibility;
extern const char* const s_processObjectInternalsGetStdinStreamCode;
extern const int s_processObjectInternalsGetStdinStreamCodeLength;
extern const JSC::ConstructAbility s_processObjectInternalsGetStdinStreamCodeConstructAbility;
extern const JSC::ConstructorKind s_processObjectInternalsGetStdinStreamCodeConstructorKind;
extern const JSC::ImplementationVisibility s_processObjectInternalsGetStdinStreamCodeImplementationVisibility;
#define WEBCORE_FOREACH_PROCESSOBJECTINTERNALS_BUILTIN_DATA(macro) \
macro(getStdioWriteStream, processObjectInternalsGetStdioWriteStream, 2) \
macro(getStdinStream, processObjectInternalsGetStdinStream, 3) \
#define WEBCORE_BUILTIN_PROCESSOBJECTINTERNALS_GETSTDIOWRITESTREAM 1
#define WEBCORE_BUILTIN_PROCESSOBJECTINTERNALS_GETSTDINSTREAM 1
#define WEBCORE_FOREACH_PROCESSOBJECTINTERNALS_BUILTIN_CODE(macro) \
macro(processObjectInternalsGetStdioWriteStreamCode, getStdioWriteStream, ASCIILiteral(), s_processObjectInternalsGetStdioWriteStreamCodeLength) \
macro(processObjectInternalsGetStdinStreamCode, getStdinStream, ASCIILiteral(), s_processObjectInternalsGetStdinStreamCodeLength) \
#define WEBCORE_FOREACH_PROCESSOBJECTINTERNALS_BUILTIN_FUNCTION_NAME(macro) \
macro(getStdinStream) \
macro(getStdioWriteStream) \
#define DECLARE_BUILTIN_GENERATOR(codeName, functionName, overriddenName, argumentCount) \
JSC::FunctionExecutable* codeName##Generator(JSC::VM&);
WEBCORE_FOREACH_PROCESSOBJECTINTERNALS_BUILTIN_CODE(DECLARE_BUILTIN_GENERATOR)
#undef DECLARE_BUILTIN_GENERATOR
class ProcessObjectInternalsBuiltinsWrapper : private JSC::WeakHandleOwner {
public:
explicit ProcessObjectInternalsBuiltinsWrapper(JSC::VM& vm)
: m_vm(vm)
WEBCORE_FOREACH_PROCESSOBJECTINTERNALS_BUILTIN_FUNCTION_NAME(INITIALIZE_BUILTIN_NAMES)
#define INITIALIZE_BUILTIN_SOURCE_MEMBERS(name, functionName, overriddenName, length) , m_##name##Source(JSC::makeSource(StringImpl::createWithoutCopying(s_##name, length), { }))
WEBCORE_FOREACH_PROCESSOBJECTINTERNALS_BUILTIN_CODE(INITIALIZE_BUILTIN_SOURCE_MEMBERS)
#undef INITIALIZE_BUILTIN_SOURCE_MEMBERS
{
}
#define EXPOSE_BUILTIN_EXECUTABLES(name, functionName, overriddenName, length) \
JSC::UnlinkedFunctionExecutable* name##Executable(); \
const JSC::SourceCode& name##Source() const { return m_##name##Source; }
WEBCORE_FOREACH_PROCESSOBJECTINTERNALS_BUILTIN_CODE(EXPOSE_BUILTIN_EXECUTABLES)
#undef EXPOSE_BUILTIN_EXECUTABLES
WEBCORE_FOREACH_PROCESSOBJECTINTERNALS_BUILTIN_FUNCTION_NAME(DECLARE_BUILTIN_IDENTIFIER_ACCESSOR)
void exportNames();
private:
JSC::VM& m_vm;
WEBCORE_FOREACH_PROCESSOBJECTINTERNALS_BUILTIN_FUNCTION_NAME(DECLARE_BUILTIN_NAMES)
#define DECLARE_BUILTIN_SOURCE_MEMBERS(name, functionName, overriddenName, length) \
JSC::SourceCode m_##name##Source;\
JSC::Weak<JSC::UnlinkedFunctionExecutable> m_##name##Executable;
WEBCORE_FOREACH_PROCESSOBJECTINTERNALS_BUILTIN_CODE(DECLARE_BUILTIN_SOURCE_MEMBERS)
#undef DECLARE_BUILTIN_SOURCE_MEMBERS
};
#define DEFINE_BUILTIN_EXECUTABLES(name, functionName, overriddenName, length) \
inline JSC::UnlinkedFunctionExecutable* ProcessObjectInternalsBuiltinsWrapper::name##Executable() \
{\
if (!m_##name##Executable) {\
JSC::Identifier executableName = functionName##PublicName();\
if (overriddenName)\
executableName = JSC::Identifier::fromString(m_vm, overriddenName);\
m_##name##Executable = JSC::Weak<JSC::UnlinkedFunctionExecutable>(JSC::createBuiltinExecutable(m_vm, m_##name##Source, executableName, s_##name##ImplementationVisibility, s_##name##ConstructorKind, s_##name##ConstructAbility), this, &m_##name##Executable);\
}\
return m_##name##Executable.get();\
}
WEBCORE_FOREACH_PROCESSOBJECTINTERNALS_BUILTIN_CODE(DEFINE_BUILTIN_EXECUTABLES)
#undef DEFINE_BUILTIN_EXECUTABLES
inline void ProcessObjectInternalsBuiltinsWrapper::exportNames()
{
#define EXPORT_FUNCTION_NAME(name) m_vm.propertyNames->appendExternalName(name##PublicName(), name##PrivateName());
WEBCORE_FOREACH_PROCESSOBJECTINTERNALS_BUILTIN_FUNCTION_NAME(EXPORT_FUNCTION_NAME)
#undef EXPORT_FUNCTION_NAME
}
class ProcessObjectInternalsBuiltinFunctions {
public:
explicit ProcessObjectInternalsBuiltinFunctions(JSC::VM& vm) : m_vm(vm) { }
void init(JSC::JSGlobalObject&);
template<typename Visitor> void visit(Visitor&);
public:
JSC::VM& m_vm;
#define DECLARE_BUILTIN_SOURCE_MEMBERS(functionName) \
JSC::WriteBarrier<JSC::JSFunction> m_##functionName##Function;
WEBCORE_FOREACH_PROCESSOBJECTINTERNALS_BUILTIN_FUNCTION_NAME(DECLARE_BUILTIN_SOURCE_MEMBERS)
#undef DECLARE_BUILTIN_SOURCE_MEMBERS
};
inline void ProcessObjectInternalsBuiltinFunctions::init(JSC::JSGlobalObject& globalObject)
{
#define EXPORT_FUNCTION(codeName, functionName, overriddenName, length)\
m_##functionName##Function.set(m_vm, &globalObject, JSC::JSFunction::create(m_vm, codeName##Generator(m_vm), &globalObject));
WEBCORE_FOREACH_PROCESSOBJECTINTERNALS_BUILTIN_CODE(EXPORT_FUNCTION)
#undef EXPORT_FUNCTION
}
template<typename Visitor>
inline void ProcessObjectInternalsBuiltinFunctions::visit(Visitor& visitor)
{
#define VISIT_FUNCTION(name) visitor.append(m_##name##Function);
WEBCORE_FOREACH_PROCESSOBJECTINTERNALS_BUILTIN_FUNCTION_NAME(VISIT_FUNCTION)
#undef VISIT_FUNCTION
}
template void ProcessObjectInternalsBuiltinFunctions::visit(JSC::AbstractSlotVisitor&);
template void ProcessObjectInternalsBuiltinFunctions::visit(JSC::SlotVisitor&);
} // namespace WebCore

3
src/bun.js/builtins/cpp/WebCoreJSBuiltinInternals.h
View File

@@ -40,6 +40,7 @@ namespace Zig { class GlobalObject; }
#pragma once
#include "ProcessObjectInternalsBuiltins.h"
#include "ReadableByteStreamInternalsBuiltins.h"
#include "ReadableStreamInternalsBuiltins.h"
#include "StreamInternalsBuiltins.h"
@@ -59,6 +60,7 @@ public:
template<typename Visitor> void visit(Visitor&);
void initialize(JSDOMGlobalObject&);
ProcessObjectInternalsBuiltinFunctions& processObjectInternals() { return m_processObjectInternals; }
ReadableByteStreamInternalsBuiltinFunctions& readableByteStreamInternals() { return m_readableByteStreamInternals; }
ReadableStreamInternalsBuiltinFunctions& readableStreamInternals() { return m_readableStreamInternals; }
StreamInternalsBuiltinFunctions& streamInternals() { return m_streamInternals; }
@@ -67,6 +69,7 @@ public:
private:
JSC::VM& m_vm;
ProcessObjectInternalsBuiltinFunctions m_processObjectInternals;
ReadableByteStreamInternalsBuiltinFunctions m_readableByteStreamInternals;
ReadableStreamInternalsBuiltinFunctions m_readableStreamInternals;
StreamInternalsBuiltinFunctions m_streamInternals;

9
src/bun.js/builtins/cpp/WebCoreJSBuiltins.h
View File

@@ -42,7 +42,7 @@
#include "JSBufferConstructorBuiltins.h"
#include "JSBufferPrototypeBuiltins.h"
#include "OnigurumaRegExpPrototypeBuiltins.h"
#include "ProcessObjectBuiltins.h"
#include "ProcessObjectInternalsBuiltins.h"
#include "ReadableByteStreamControllerBuiltins.h"
#include "ReadableByteStreamInternalsBuiltins.h"
#include "ReadableStreamBYOBReaderBuiltins.h"
@@ -72,7 +72,7 @@ public:
, m_jsBufferConstructorBuiltins(m_vm)
, m_jsBufferPrototypeBuiltins(m_vm)
, m_onigurumaRegExpPrototypeBuiltins(m_vm)
, m_processObjectBuiltins(m_vm)
, m_processObjectInternalsBuiltins(m_vm)
, m_readableByteStreamControllerBuiltins(m_vm)
, m_readableByteStreamInternalsBuiltins(m_vm)
, m_readableStreamBuiltins(m_vm)
@@ -89,6 +89,7 @@ public:
, m_writableStreamDefaultWriterBuiltins(m_vm)
, m_writableStreamInternalsBuiltins(m_vm)
{
m_processObjectInternalsBuiltins.exportNames();
m_readableByteStreamInternalsBuiltins.exportNames();
m_readableStreamInternalsBuiltins.exportNames();
m_streamInternalsBuiltins.exportNames();
@@ -102,7 +103,7 @@ public:
JSBufferConstructorBuiltinsWrapper& jsBufferConstructorBuiltins() { return m_jsBufferConstructorBuiltins; }
JSBufferPrototypeBuiltinsWrapper& jsBufferPrototypeBuiltins() { return m_jsBufferPrototypeBuiltins; }
OnigurumaRegExpPrototypeBuiltinsWrapper& onigurumaRegExpPrototypeBuiltins() { return m_onigurumaRegExpPrototypeBuiltins; }
ProcessObjectBuiltinsWrapper& processObjectBuiltins() { return m_processObjectBuiltins; }
ProcessObjectInternalsBuiltinsWrapper& processObjectInternalsBuiltins() { return m_processObjectInternalsBuiltins; }
ReadableByteStreamControllerBuiltinsWrapper& readableByteStreamControllerBuiltins() { return m_readableByteStreamControllerBuiltins; }
ReadableByteStreamInternalsBuiltinsWrapper& readableByteStreamInternalsBuiltins() { return m_readableByteStreamInternalsBuiltins; }
ReadableStreamBuiltinsWrapper& readableStreamBuiltins() { return m_readableStreamBuiltins; }
@@ -127,7 +128,7 @@ private:
JSBufferConstructorBuiltinsWrapper m_jsBufferConstructorBuiltins;
JSBufferPrototypeBuiltinsWrapper m_jsBufferPrototypeBuiltins;
OnigurumaRegExpPrototypeBuiltinsWrapper m_onigurumaRegExpPrototypeBuiltins;
ProcessObjectBuiltinsWrapper m_processObjectBuiltins;
ProcessObjectInternalsBuiltinsWrapper m_processObjectInternalsBuiltins;
ReadableByteStreamControllerBuiltinsWrapper m_readableByteStreamControllerBuiltins;
ReadableByteStreamInternalsBuiltinsWrapper m_readableByteStreamInternalsBuiltins;
ReadableStreamBuiltinsWrapper m_readableStreamBuiltins;

24
src/bun.js/builtins/js/ProcessObject.js
View File

@@ -1,24 +0,0 @@
/*
* Copyright 2022 Codeblog Corp. All rights reserved.
*
* Redistribution and use in source and binary forms, with or without
* modification, are permitted provided that the following conditions
* are met:
* 1. Redistributions of source code must retain the above copyright
* notice, this list of conditions and the following disclaimer.
* 2. Redistributions in binary form must reproduce the above copyright
* notice, this list of conditions and the following disclaimer in the
* documentation and/or other materials provided with the distribution.
*
* THIS SOFTWARE IS PROVIDED BY APPLE INC. ``AS IS'' AND ANY
* EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
* IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
* PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL APPLE INC. OR
* CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL,
* EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO,
* PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR
* PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY
* OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
* (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
* OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
*/

600
src/bun.js/builtins/js/ProcessObjectInternals.js Normal file
View File

@@ -0,0 +1,600 @@
/*
* Copyright 2022 Codeblog Corp. All rights reserved.
*
* Redistribution and use in source and binary forms, with or without
* modification, are permitted provided that the following conditions
* are met:
* 1. Redistributions of source code must retain the above copyright
* notice, this list of conditions and the following disclaimer.
* 2. Redistributions in binary form must reproduce the above copyright
* notice, this list of conditions and the following disclaimer in the
* documentation and/or other materials provided with the distribution.
*
* THIS SOFTWARE IS PROVIDED BY APPLE INC. ``AS IS'' AND ANY
* EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
* IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
* PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL APPLE INC. OR
* CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL,
* EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO,
* PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR
* PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY
* OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
* (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
* OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
*/
// @internal
function getStdioWriteStream(fd_, rawRequire) {
var module = { path: "node:process", require: rawRequire };
var require = (path) => module.require(path);
function createStdioWriteStream(fd_) {
var { Duplex, eos, destroy } = require("node:stream");
var StdioWriteStream = class StdioWriteStream extends Duplex {
#writeStream;
#readStream;
#readable = true;
#writable = true;
#fdPath;
#onClose;
#onDrain;
#onFinish;
#onReadable;
#isTTY;
get isTTY() {
return (this.#isTTY ??= require("node:tty").isatty(fd_));
}
get fd() {
return fd_;
}
constructor(fd) {
super({ readable: true, writable: true });
this.#fdPath = `/dev/fd/${fd}`;
}
#onFinished(err) {
const cb = this.#onClose;
this.#onClose = null;
if (cb) {
cb(err);
} else if (err) {
this.destroy(err);
} else if (!this.#readable && !this.#writable) {
this.destroy();
}
}
_destroy(err, callback) {
if (!err && this.#onClose !== null) {
var AbortError = class AbortError extends Error {
constructor(
message = "The operation was aborted",
options = void 0,
) {
if (options !== void 0 && typeof options !== "object") {
throw new Error(
`Invalid AbortError options:\n\n${JSON.stringify(
options,
null,
2,
)}`,
);
}
super(message, options);
this.code = "ABORT_ERR";
this.name = "AbortError";
}
};
err = new AbortError();
}
this.#onDrain = null;
this.#onFinish = null;
if (this.#onClose === null) {
callback(err);
} else {
this.#onClose = callback;
if (this.#writeStream) destroy(this.#writeStream, err);
if (this.#readStream) destroy(this.#readStream, err);
}
}
_write(chunk, encoding, callback) {
if (!this.#writeStream) {
var { createWriteStream } = require("node:fs");
var stream = (this.#writeStream = createWriteStream(this.#fdPath));
stream.on("finish", () => {
if (this.#onFinish) {
const cb = this.#onFinish;
this.#onFinish = null;
cb();
}
});
stream.on("drain", () => {
if (this.#onDrain) {
const cb = this.#onDrain;
this.#onDrain = null;
cb();
}
});
eos(stream, (err) => {
this.#writable = false;
if (err) {
destroy(stream, err);
}
this.#onFinished(err);
});
}
if (stream.write(chunk, encoding)) {
callback();
} else {
this.#onDrain = callback;
}
}
_final(callback) {
this.#writeStream && this.#writeStream.end();
this.#onFinish = callback;
}
#loadReadStream() {
var { createReadStream } = require("node:fs");
var readStream = (this.#readStream = createReadStream(this.#fdPath));
readStream.on("readable", () => {
if (this.#onReadable) {
const cb = this.#onReadable;
this.#onReadable = null;
cb();
} else {
this.read();
}
});
readStream.on("end", () => {
this.push(null);
});
eos(readStream, (err) => {
this.#readable = false;
if (err) {
destroy(readStream, err);
}
this.#onFinished(err);
});
return readStream;
}
_read() {
var stream = this.#readStream;
if (!stream) {
stream = this.#loadReadStream();
}
while (true) {
const buf = stream.read();
if (buf === null || !this.push(buf)) {
return;
}
}
}
};
return new StdioWriteStream(fd_);
}
var { EventEmitter } = require("node:events");
function isFastEncoding(encoding) {
if (!encoding) return true;
var normalied = encoding.toLowerCase();
return (
normalied === "utf8" ||
normalied === "utf-8" ||
normalied === "buffer" ||
normalied === "binary" ||
normalized === ""
);
}
var FastStdioWriteStream = class StdioWriteStream extends EventEmitter {
#fd;
#innerStream;
#writer;
#isTTY;
bytesWritten = 0;
setDefaultEncoding(encoding) {
if (this.#innerStream || !isFastEncoding(encoding)) {
this.#ensureInnerStream();
return this.#innerStream.setDefaultEncoding(encoding);
}
}
#createWriter() {
switch (this.#fd) {
case 1: {
var writer = Bun.stdout.writer({ highWaterMark: 0 });
writer.unref();
return writer;
}
case 2: {
var writer = Bun.stderr.writer({ highWaterMark: 0 });
writer.unref();
return writer;
}
default: {
throw new Error("Unsupported writer");
}
}
}
#getWriter() {
return (this.#writer ??= this.#createWriter());
}
constructor(fd_) {
super();
this.#fd = fd_;
}
get fd() {
return this.#fd;
}
get isTTY() {
return (this.#isTTY ??= require("node:tty").isatty(this.#fd));
}
on(event, listener) {
if (event === "close" || event === "finish") {
this.#ensureInnerStream();
return this.#innerStream.on(event, listener);
}
if (event === "drain") {
return super.on("drain", listener);
}
if (event === "error") {
return super.on("error", listener);
}
return super.on(event, listener);
}
get _writableState() {
this.#ensureInnerStream();
return this.#innerStream._writableState;
}
get _readableState() {
this.#ensureInnerStream();
return this.#innerStream._readableState;
}
pipe(destination) {
this.#ensureInnerStream();
return this.#innerStream.pipe(destination);
}
unpipe(destination) {
this.#ensureInnerStream();
return this.#innerStream.unpipe(destination);
}
#ensureInnerStream() {
if (this.#innerStream) return;
this.#innerStream = createStdioWriteStream(this.#fd);
const events = this.eventNames();
for (const event of events) {
this.#innerStream.on(event, (...args) => {
this.emit(event, ...args);
});
}
}
#write1(chunk) {
var writer = this.#getWriter();
const writeResult = writer.write(chunk);
this.bytesWritten += writeResult;
const flushResult = writer.flush();
return !!(writeResult || flushResult);
}
#writeWithEncoding(chunk, encoding) {
if (!isFastEncoding(encoding)) {
this.#ensureInnerStream();
return this.#innerStream.write(chunk, encoding);
}
return this.#write1(chunk);
}
#performCallback(cb, err) {
if (err) {
this.emit("error", err);
}
try {
cb(err ? err : null);
} catch (err2) {
this.emit("error", err2);
}
}
#writeWithCallbackAndEncoding(chunk, encoding, callback) {
if (!isFastEncoding(encoding)) {
this.#ensureInnerStream();
return this.#innerStream.write(chunk, encoding, callback);
}
var writer = this.#getWriter();
const writeResult = writer.write(chunk);
const flushResult = writer.flush(true);
if (flushResult?.then) {
flushResult.then(
() => {
this.#performCallback(callback);
this.emit("drain");
},
(err) => this.#performCallback(callback, err),
);
return false;
}
queueMicrotask(() => {
this.#performCallback(callback);
});
return !!(writeResult || flushResult);
}
write(chunk, encoding, callback) {
const result = this._write(chunk, encoding, callback);
if (result) {
this.emit("drain");
}
return result;
}
get hasColors() {
return Bun.tty[this.#fd].hasColors;
}
_write(chunk, encoding, callback) {
var inner = this.#innerStream;
if (inner) {
return inner.write(chunk, encoding, callback);
}
switch (arguments.length) {
case 0: {
var error = new Error("Invalid arguments");
error.code = "ERR_INVALID_ARG_TYPE";
throw error;
}
case 1: {
return this.#write1(chunk);
}
case 2: {
if (typeof encoding === "function") {
return this.#writeWithCallbackAndEncoding(chunk, "", encoding);
} else if (typeof encoding === "string") {
return this.#writeWithEncoding(chunk, encoding);
}
}
default: {
if (
(typeof encoding !== "undefined" && typeof encoding !== "string") ||
(typeof callback !== "undefined" && typeof callback !== "function")
) {
var error = new Error("Invalid arguments");
error.code = "ERR_INVALID_ARG_TYPE";
throw error;
}
if (typeof callback === "undefined") {
return this.#writeWithEncoding(chunk, encoding);
}
return this.#writeWithCallbackAndEncoding(chunk, encoding, callback);
}
}
}
destroy() {
return this;
}
end() {
return this;
}
};
return new FastStdioWriteStream(fd_);
}
function getStdinStream(fd, rawRequire, Bun) {
var module = { path: "node:process", require: rawRequire };
var require = (path) => module.require(path);
var { Readable, Duplex, eos, destroy } = require("node:stream");
var StdinStream = class StdinStream extends Duplex {
#readStream;
#writeStream;
#readable = true;
#writable = true;
#onFinish;
#onClose;
#onDrain;
#onReadable;
get isTTY() {
return require("tty").isatty(fd);
}
get fd() {
return fd_;
}
constructor() {
super({ readable: true, writable: true });
this.#onReadable = this._read.bind(this);
}
#onFinished(err) {
const cb = this.#onClose;
this.#onClose = null;
if (cb) {
cb(err);
} else if (err) {
this.destroy(err);
} else if (!this.#readable && !this.#writable) {
this.destroy();
}
}
_destroy(err, callback) {
if (!err && this.#onClose !== null) {
var AbortError = class AbortError extends Error {
constructor(message = "The operation was aborted", options = void 0) {
if (options !== void 0 && typeof options !== "object") {
throw new Error(
`Invalid AbortError options:\n\n${JSON.stringify(
options,
null,
2,
)}`,
);
}
super(message, options);
this.code = "ABORT_ERR";
this.name = "AbortError";
}
};
err = new AbortError();
}
if (this.#onClose === null) {
callback(err);
} else {
this.#onClose = callback;
if (this.#readStream) destroy(this.#readStream, err);
if (this.#writeStream) destroy(this.#writeStream, err);
}
}
on(ev, cb) {
super.on(ev, cb);
if (!this.#readStream && (ev === "readable" || ev === "data")) {
this.#loadReadStream();
}
}
#loadReadStream() {
var readStream = (this.#readStream = Readable.fromWeb(
Bun.stdin.stream(),
));
readStream.on("readable", () => {
const cb = this.#onReadable;
this.#onReadable = null;
cb();
});
readStream.on("end", () => {
this.push(null);
});
eos(readStream, (err) => {
this.#readable = false;
if (err) {
destroy(readStream, err);
}
this.#onFinished(err);
});
}
_read() {
var readStream = this.#readStream;
while (true) {
const buf = readStream.read();
if (buf === null || !this.push(buf)) {
this.#onReadable = this._read.bind(this);
return;
}
}
}
#constructWriteStream() {
var { createWriteStream } = require("node:fs");
var writeStream = (this.#writeStream = createWriteStream("/dev/fd/0"));
writeStream.on("finish", () => {
if (this.#onFinish) {
const cb = this.#onFinish;
this.#onFinish = null;
cb();
}
});
writeStream.on("drain", () => {
if (this.#onDrain) {
const cb = this.#onDrain;
this.#onDrain = null;
cb();
}
});
eos(writeStream, (err) => {
this.#writable = false;
if (err) {
destroy(writeStream, err);
}
this.#onFinished(err);
});
return writeStream;
}
_write(chunk, encoding, callback) {
var writeStream = this.#writeStream;
if (!writeStream) {
writeStream = this.#constructWriteStream();
}
if (writeStream.write(chunk, encoding)) {
callback();
} else {
this.#onDrain = callback;
}
}
_final(callback) {
this.#writeStream.end();
this.#onFinish = callback.bind(this);
}
};
return new StdinStream();
}

9
src/bun.js/event_loop.zig
View File

@@ -467,6 +467,15 @@ pub const EventLoop = struct {
}
}
pub fn autoTickActive(this: *EventLoop) void {
var loop = this.virtual_machine.uws_event_loop.?;
if (loop.active > 0) {
loop.tick();
this.processGCTimer();
// this.afterUSocketsTick();
}
}
pub fn processGCTimer(this: *EventLoop) void {
this.virtual_machine.gc_controller.processGCTimer();
}

342
src/bun.js/process-stdio-polyfill.js
View File

@@ -1,342 +0,0 @@
var createReadStream;
var createWriteStream;
var StdioWriteStream;
var StdinStream;
var AbortError = class extends Error {
constructor(message = "The operation was aborted", options = void 0) {
if (options !== void 0 && typeof options !== "object") {
throw new Error(
`Invalid AbortError options:\n\n${JSON.stringify(options, null, 2)}`,
);
}
super(message, options);
this.code = "ABORT_ERR";
this.name = "AbortError";
}
};
function lazyLoadDeps({ require }) {
var {
createWriteStream: _createWriteStream,
createReadStream: _createReadStream,
} = require("node:fs", "node:process");
createWriteStream = _createWriteStream;
createReadStream = _createReadStream;
}
function getStdioWriteStream({ require }) {
if (!StdioWriteStream) {
var { Duplex, eos, destroy } = require("node:stream", "node:process");
if (!createWriteStream) {
lazyLoadDeps({ require });
}
StdioWriteStream = class StdioWriteStream extends Duplex {
#writeStream;
#readStream;
#readable = true;
#writable = true;
#fdPath;
#onClose;
#onDrain;
#onFinish;
#onReadable;
fd = 1;
get isTTY() {
return require("tty").isatty(this.fd);
}
constructor(fd) {
super({ readable: true, writable: true });
this.#fdPath = `/dev/fd/${fd}`;
Object.defineProperty(this, "fd", {
value: fd,
writable: false,
configurable: false,
});
}
#onFinished(err) {
const cb = this.#onClose;
this.#onClose = null;
if (cb) {
cb(err);
} else if (err) {
this.destroy(err);
} else if (!this.#readable && !this.#writable) {
this.destroy();
}
}
_destroy(err, callback) {
if (!err && this.#onClose !== null) {
err = new AbortError();
}
this.#onDrain = null;
this.#onFinish = null;
if (this.#onClose === null) {
callback(err);
} else {
this.#onClose = callback;
if (this.#writeStream) destroy(this.#writeStream, err);
if (this.#readStream) destroy(this.#readStream, err);
}
}
_write(chunk, encoding, callback) {
if (!this.#writeStream) {
this.#writeStream = createWriteStream(this.#fdPath);
this.#writeStream.on("finish", () => {
if (this.#onFinish) {
const cb = this.#onFinish;
this.#onFinish = null;
cb();
}
});
this.#writeStream.on("drain", () => {
if (this.#onDrain) {
const cb = this.#onDrain;
this.#onDrain = null;
cb();
}
});
eos(this.#writeStream, (err) => {
this.#writable = false;
if (err) {
destroy(this.#writeStream, err);
}
this.#onFinished(err);
});
}
if (this.#writeStream.write(chunk, encoding)) {
callback();
} else {
this.#onDrain = callback;
}
}
_final(callback) {
this.#writeStream.end();
this.#onFinish = callback;
}
_read() {
if (!this.#readStream) {
this.#readStream = createReadStream(this.#fdPath);
this.#readStream.on("readable", () => {
if (this.#onReadable) {
const cb = this.#onReadable;
this.#onReadable = null;
cb();
} else {
this.read();
}
});
this.#readStream.on("end", () => {
this.push(null);
});
eos(this.#readStream, (err) => {
this.#readable = false;
if (err) {
destroy(this.#readStream, err);
}
this.#onFinished(err);
});
}
while (true) {
const buf = this.#readStream.read();
if (buf === null || !this.push(buf)) {
return;
}
}
}
};
}
return StdioWriteStream;
}
function getStdinStream({ require }) {
if (!StdinStream) {
var {
Readable,
Duplex,
eos,
destroy,
} = require("node:stream", "node:process");
if (!createWriteStream) {
lazyLoadDeps({ require });
}
StdinStream = class StdinStream extends Duplex {
#readStream;
#writeStream;
#readable = true;
#writable = true;
#onFinish;
#onClose;
#onDrain;
#onReadable;
fd = 0;
get isTTY() {
return require("tty").isatty(this.fd);
}
constructor() {
super({ readable: true, writable: true });
Object.defineProperty(this, "fd", {
value: 0,
writable: false,
configurable: false,
});
this.#onReadable = this._read.bind(this);
}
#onFinished(err) {
const cb = this.#onClose;
this.#onClose = null;
if (cb) {
cb(err);
} else if (err) {
this.destroy(err);
} else if (!this.#readable && !this.#writable) {
this.destroy();
}
}
_destroy(err, callback) {
if (!err && this.#onClose !== null) {
err = new AbortError();
}
if (this.#onClose === null) {
callback(err);
} else {
this.#onClose = callback;
if (this.#readStream) destroy(this.#readStream, err);
if (this.#writeStream) destroy(this.#writeStream, err);
}
}
on(ev, cb) {
super.on(ev, cb);
if (!this.#readStream && (ev === "readable" || ev === "data")) {
this.#readStream = Readable.fromWeb(Bun.stdin.stream());
this.#readStream.on("readable", () => {
const cb = this.#onReadable;
this.#onReadable = null;
cb();
});
this.#readStream.on("end", () => {
this.push(null);
});
eos(this.#readStream, (err) => {
this.#readable = false;
if (err) {
destroy(this.#readStream, err);
}
this.#onFinished(err);
});
}
}
_read() {
while (true) {
const buf = this.#readStream.read();
if (buf === null || !this.push(buf)) {
this.#onReadable = this._read.bind(this);
return;
}
}
}
_write(chunk, encoding, callback) {
if (!this.#writeStream) {
this.#writeStream = createWriteStream("/dev/fd/0");
this.#writeStream.on("finish", () => {
if (this.#onFinish) {
const cb = this.#onFinish;
this.#onFinish = null;
cb();
}
});
this.#writeStream.on("drain", () => {
if (this.#onDrain) {
const cb = this.#onDrain;
this.#onDrain = null;
cb();
}
});
eos(this.#writeStream, (err) => {
this.#writable = false;
if (err) {
destroy(this.#writeStream, err);
}
this.#onFinished(err);
});
}
if (this.#writeStream.write(chunk, encoding)) {
callback();
} else {
this.#onDrain = callback;
}
}
_final(callback) {
this.#writeStream.end();
this.#onFinish = callback.bind(this);
}
};
}
return StdinStream;
}
export function stdin({ require }) {
var StdinStream = getStdinStream({ require });
var stream = new StdinStream();
return stream;
}
export function stdout({ require }) {
var StdioWriteStream = getStdioWriteStream({ require });
var stream = new StdioWriteStream(1);
return stream;
}
export function stderr({ require }) {
var StdioWriteStream = getStdioWriteStream({ require });
var stream = new StdioWriteStream(2);
return stream;
}
export default {
stdin,
stdout,
stderr,
[Symbol.for("CommonJS")]: 0,
};

2
src/bun_js.zig
View File

@@ -165,7 +165,7 @@ pub const Run = struct {
{
while (this.vm.eventLoop().tasks.count > 0 or this.vm.active_tasks > 0 or this.vm.uws_event_loop.?.active > 0) {
this.vm.tick();
this.vm.eventLoop().autoTick();
this.vm.eventLoop().autoTickActive();
}
if (this.vm.log.msgs.items.len > 0) {