mirror of
https://github.com/oven-sh/bun
synced 2026-02-11 03:18:53 +00:00
fs.*Sync(), bun wiptest, and More ™ (#106)
* very very wip
* almost ready to fix the errors
* Update identity_context.zig
* Update base.zig
* [bun test] It runs successfully
* Remove unnecessary call
* [Bun.js] Improve JS <> Zig unicode string interop
This fixes longstanding unicode bugs with `console.log` & `fetch`.
I believe @evanwashere reported this first awhile ago
* [Bun.js] Implement `Object.is()` binding and a way to set a timeout for script execution
* Update PLCrashReport.zig
* [Bun.js] Make `console.log` more closely match Node.js and Deno
* [Bun.js] Implement formatting specifier for console.*
* Implement `console.clear()`
* bug fix
* Support console.clear()
* Buffer stderr
* [bun test] Begin implementing Node.js `fs`
* Update darwin_c.zig
* Implement more of `fs`
* `mkdir`, `mkdir` recursive, `mkdtemp`
* `open`, `read` (and pread)
* Move some things into more files
* Implement readdir
* `readFile`, `readLink`, and `realpath`
* `writeFile`, `symlink`, `chown`, `rename`, `stat`, `unlink`, `truncate`
* `lutimes`
* Implement `SystemError` and begin wiring up the `fs` module
* `"fs"` - Most of the arguments / validation
* `fs` - Rest of the arguments / validations
* Begin wiring up the `fs` module
* Fix all the build errors
* support printing typed arrays in console.log
* It...works?
* Support `require("fs")`, `import fs from 'fs';`, `import * as fs from 'fs'`
* Fix a couple bugs
* get rid of the crash reporter for now
* Update fs.exports.js
* [bun.js] slight improvement to startup time
* [bun.js] Improve error message printing
* [Bun.js] Add `Bun.gc()` to run the garbage collector manually and report heap size
* [Bun.js] Add Bun.generateHeapSnapshot to return what JS types are using memory
* [Bun.js] Add `Bun.shrink()` to tell JSC to shrink the VM size
* Improve encoding reader
* [bun.js] Improve callback & microtask performance
* Update node_fs.zig
* Implement `console.assert`
* simple test
* [Bun.js] Prepare for multiple globals/realms to support testing
* Create callbacks-overhead.mjs
* Update http.zig
* [Bun.js] Implement `queueMicrotask`
* Add test for queueMicrotask
* 😪
* [Bun.js] Implement `process.versions`, `process.pid`, `process.ppid`, `process.nextTick`, `process.versions`,
* Implement `process.env.toJSON()`
* [Bun.js] Improve performance of `fs.existsSync`
* 💅
* [Bun.js] Implement `process.chdir(str)` and `process.cwd()`, support up to 4 args in `process.nextTick`
* Make creating Zig::Process lazy
* Split processi nto separte file
* [Bun.js] Node.js Streams - Part 1/?
* [Bun.js] Node.js streams 2/?
* WIP streams
* fix crash
* Reduce allocations in many places
* swap
* Make `bun` start 2ms faster
* Always use an apiLock()
* libBacktrace doesn't really work yet
* Fix crash in the upgrade checker
* Clean up code for importing the runtime when not bundling
* 📷
* Update linker.zig
* 68!
* backtrace
* no, really backtrace
* Fix
* Linux fixes
* Fixes on Linux
* Update mimalloc
* [bun test] Automatically scan for {.test,_test,.spec,_spec}.{jsx,tsx,js,cts,mts,ts,cjs}
This commit is contained in:
Jarred Sumner
553
src/javascript/jsc/node/buffer.zig
Normal file
553
src/javascript/jsc/node/buffer.zig
Normal file
@@ -0,0 +1,553 @@
|
||||
const std = @import("std");
|
||||
const _global = @import("../../../global.zig");
|
||||
const strings = _global.strings;
|
||||
const string = _global.string;
|
||||
const AsyncIO = @import("io");
|
||||
const JSC = @import("../../../jsc.zig");
|
||||
const PathString = JSC.PathString;
|
||||
const Environment = _global.Environment;
|
||||
const C = _global.C;
|
||||
const Syscall = @import("./syscall.zig");
|
||||
const os = std.os;
|
||||
const Buffer = JSC.ArrayBuffer;
|
||||
|
||||
const JSGlobalObject = JSC.JSGlobalObject;
|
||||
const ArgumentsSlice = JSC.Node.ArgumentsSlice;
|
||||
|
||||
const BufferStaticFunctionEnum = JSC.Node.DeclEnum(BufferStatic);
|
||||
|
||||
fn BufferStatic_wrap(comptime FunctionEnum: BufferStaticFunctionEnum) NodeFSFunction {
|
||||
const Function = @field(BufferStatic, @tagName(BufferStaticFunctionEnum));
|
||||
const FunctionType = @TypeOf(Function);
|
||||
|
||||
const function: std.builtin.TypeInfo.Fn = comptime @typeInfo(FunctionType).Fn;
|
||||
comptime if (function.args.len != 3) @compileError("Expected 3 arguments");
|
||||
const Arguments = comptime function.args[1].arg_type.?;
|
||||
const FormattedName = comptime [1]u8{std.ascii.toUpper(@tagName(BufferStaticFunctionEnum)[0])} ++ @tagName(BufferStaticFunctionEnum)[1..];
|
||||
const Result = JSC.JSValue;
|
||||
|
||||
const NodeBindingClosure = struct {
|
||||
pub fn bind(
|
||||
_: void,
|
||||
ctx: JSC.C.JSContextRef,
|
||||
_: JSC.C.JSObjectRef,
|
||||
_: JSC.C.JSObjectRef,
|
||||
arguments: []const JSC.C.JSValueRef,
|
||||
exception: JSC.C.ExceptionRef,
|
||||
) JSC.C.JSValueRef {
|
||||
var slice = ArgumentsSlice.init(@ptrCast([*]const JSC.JSValue, arguments.ptr)[0..arguments.len]);
|
||||
|
||||
defer {
|
||||
// TODO: fix this
|
||||
for (arguments) |arg| {
|
||||
JSC.C.JSValueUnprotect(ctx, arg);
|
||||
}
|
||||
slice.arena.deinit();
|
||||
}
|
||||
|
||||
const args = if (comptime Arguments != void)
|
||||
(Arguments.fromJS(ctx, &slice, exception) orelse return null)
|
||||
else
|
||||
Arguments{};
|
||||
if (exception.* != null) return null;
|
||||
|
||||
const result: Result = Function(
|
||||
ctx.ptr(),
|
||||
args,
|
||||
exception,
|
||||
);
|
||||
if (exception.* != null) {
|
||||
return null;
|
||||
}
|
||||
|
||||
return result.asObjectRef();
|
||||
}
|
||||
};
|
||||
|
||||
return NodeBindingClosure.bind;
|
||||
}
|
||||
|
||||
pub const BufferStatic = struct {
|
||||
pub const Arguments = struct {
|
||||
pub const Alloc = struct {
|
||||
pub fn fromJS(ctx: JSC.C.JSContextRef, arguments: *ArgumentsSlice, exception: JSC.C.ExceptionRef) ?Alloc {}
|
||||
};
|
||||
pub const AllocUnsafe = struct {
|
||||
pub fn fromJS(ctx: JSC.C.JSContextRef, arguments: *ArgumentsSlice, exception: JSC.C.ExceptionRef) ?AllocUnsafe {}
|
||||
};
|
||||
pub const AllocUnsafeSlow = struct {
|
||||
pub fn fromJS(ctx: JSC.C.JSContextRef, arguments: *ArgumentsSlice, exception: JSC.C.ExceptionRef) ?AllocUnsafeSlow {}
|
||||
};
|
||||
pub const Compare = struct {
|
||||
pub fn fromJS(ctx: JSC.C.JSContextRef, arguments: *ArgumentsSlice, exception: JSC.C.ExceptionRef) ?Compare {}
|
||||
};
|
||||
pub const Concat = struct {
|
||||
pub fn fromJS(ctx: JSC.C.JSContextRef, arguments: *ArgumentsSlice, exception: JSC.C.ExceptionRef) ?Concat {}
|
||||
};
|
||||
pub const IsEncoding = struct {
|
||||
pub fn fromJS(ctx: JSC.C.JSContextRef, arguments: *ArgumentsSlice, exception: JSC.C.ExceptionRef) ?IsEncoding {}
|
||||
};
|
||||
};
|
||||
pub fn alloc(globalThis: *JSGlobalObject, args: Arguments.Alloc, exception: JSC.C.ExceptionRef) JSC.JSValue {}
|
||||
pub fn allocUnsafe(globalThis: *JSGlobalObject, args: Arguments.AllocUnsafe, exception: JSC.C.ExceptionRef) JSC.JSValue {}
|
||||
pub fn allocUnsafeSlow(globalThis: *JSGlobalObject, args: Arguments.AllocUnsafeSlow, exception: JSC.C.ExceptionRef) JSC.JSValue {}
|
||||
pub fn compare(globalThis: *JSGlobalObject, args: Arguments.Compare, exception: JSC.C.ExceptionRef) JSC.JSValue {}
|
||||
pub fn concat(globalThis: *JSGlobalObject, args: Arguments.Concat, exception: JSC.C.ExceptionRef) JSC.JSValue {}
|
||||
pub fn isEncoding(globalThis: *JSGlobalObject, args: Arguments.IsEncoding, exception: JSC.C.ExceptionRef) JSC.JSValue {}
|
||||
|
||||
pub const Class = JSC.NewClass(
|
||||
void,
|
||||
.{ .name = "Buffer" },
|
||||
.{
|
||||
.alloc = .{ .name = "alloc", .rfn = BufferStatic_wrap(.alloc) },
|
||||
.allocUnsafe = .{ .name = "allocUnsafe", .rfn = BufferStatic_wrap(.allocUnsafe) },
|
||||
.allocUnsafeSlow = .{ .name = "allocUnsafeSlow", .rfn = BufferStatic_wrap(.allocUnsafeSlow) },
|
||||
.compare = .{ .name = "compare", .rfn = BufferStatic_wrap(.compare) },
|
||||
.concat = .{ .name = "concat", .rfn = BufferStatic_wrap(.concat) },
|
||||
.isEncoding = .{ .name = "isEncoding", .rfn = BufferStatic_wrap(.isEncoding) },
|
||||
},
|
||||
.{ ._poolSize = .{ .name = "_poolSize", .get = .{ .name = "get", .rfn = BufferStatic.getPoolSize }, .set = .{ .name = "set", .rfn = BufferStatic.setPoolSize } } },
|
||||
);
|
||||
};
|
||||
|
||||
pub const BufferPrototype = struct {
|
||||
const Arguments = struct {
|
||||
pub const Compare = struct {
|
||||
pub fn fromJS(ctx: JSC.C.JSContextRef, arguments: *ArgumentsSlice, exception: JSC.C.ExceptionRef) ?Compare {
|
||||
return null;
|
||||
}
|
||||
};
|
||||
pub const Copy = struct {
|
||||
pub fn fromJS(ctx: JSC.C.JSContextRef, arguments: *ArgumentsSlice, exception: JSC.C.ExceptionRef) ?Copy {
|
||||
return null;
|
||||
}
|
||||
};
|
||||
pub const Equals = struct {
|
||||
pub fn fromJS(ctx: JSC.C.JSContextRef, arguments: *ArgumentsSlice, exception: JSC.C.ExceptionRef) ?Equals {
|
||||
return null;
|
||||
}
|
||||
};
|
||||
pub const Fill = struct {
|
||||
pub fn fromJS(ctx: JSC.C.JSContextRef, arguments: *ArgumentsSlice, exception: JSC.C.ExceptionRef) ?Fill {
|
||||
return null;
|
||||
}
|
||||
};
|
||||
pub const Includes = struct {
|
||||
pub fn fromJS(ctx: JSC.C.JSContextRef, arguments: *ArgumentsSlice, exception: JSC.C.ExceptionRef) ?Includes {
|
||||
return null;
|
||||
}
|
||||
};
|
||||
pub const IndexOf = struct {
|
||||
pub fn fromJS(ctx: JSC.C.JSContextRef, arguments: *ArgumentsSlice, exception: JSC.C.ExceptionRef) ?IndexOf {
|
||||
return null;
|
||||
}
|
||||
};
|
||||
pub const LastIndexOf = struct {
|
||||
pub fn fromJS(ctx: JSC.C.JSContextRef, arguments: *ArgumentsSlice, exception: JSC.C.ExceptionRef) ?LastIndexOf {
|
||||
return null;
|
||||
}
|
||||
};
|
||||
pub const Swap16 = struct {
|
||||
pub fn fromJS(ctx: JSC.C.JSContextRef, arguments: *ArgumentsSlice, exception: JSC.C.ExceptionRef) ?Swap16 {
|
||||
return null;
|
||||
}
|
||||
};
|
||||
pub const Swap32 = struct {
|
||||
pub fn fromJS(ctx: JSC.C.JSContextRef, arguments: *ArgumentsSlice, exception: JSC.C.ExceptionRef) ?Swap32 {
|
||||
return null;
|
||||
}
|
||||
};
|
||||
pub const Swap64 = struct {
|
||||
pub fn fromJS(ctx: JSC.C.JSContextRef, arguments: *ArgumentsSlice, exception: JSC.C.ExceptionRef) ?Swap64 {
|
||||
return null;
|
||||
}
|
||||
};
|
||||
pub const Write = struct {
|
||||
pub fn fromJS(ctx: JSC.C.JSContextRef, arguments: *ArgumentsSlice, exception: JSC.C.ExceptionRef) ?Write {
|
||||
return null;
|
||||
}
|
||||
};
|
||||
pub const Read = struct {
|
||||
pub fn fromJS(ctx: JSC.C.JSContextRef, arguments: *ArgumentsSlice, exception: JSC.C.ExceptionRef) ?Read {
|
||||
return null;
|
||||
}
|
||||
};
|
||||
|
||||
pub fn WriteInt(comptime kind: Int) type {
|
||||
return struct {
|
||||
const This = @This();
|
||||
const Value = Int.native.get(kind);
|
||||
};
|
||||
}
|
||||
pub fn ReadInt(comptime kind: Int) type {
|
||||
return struct {
|
||||
const This = @This();
|
||||
const Value = Int.native.get(kind);
|
||||
};
|
||||
}
|
||||
};
|
||||
pub fn compare(this: *Buffer, globalThis: *JSC.JSGlobalObject, args: Arguments.Compare) JSC.JSValue {
|
||||
_ = this;
|
||||
_ = globalThis;
|
||||
_ = args;
|
||||
return JSC.JSValue.jsUndefined();
|
||||
}
|
||||
pub fn copy(this: *Buffer, globalThis: *JSC.JSGlobalObject, args: Arguments.Copy) JSC.JSValue {
|
||||
_ = this;
|
||||
_ = globalThis;
|
||||
_ = args;
|
||||
return JSC.JSValue.jsUndefined();
|
||||
}
|
||||
pub fn equals(this: *Buffer, globalThis: *JSC.JSGlobalObject, args: Arguments.Equals) JSC.JSValue {
|
||||
_ = this;
|
||||
_ = globalThis;
|
||||
_ = args;
|
||||
return JSC.JSValue.jsUndefined();
|
||||
}
|
||||
pub fn fill(this: *Buffer, globalThis: *JSC.JSGlobalObject, args: Arguments.Fill) JSC.JSValue {
|
||||
_ = this;
|
||||
_ = globalThis;
|
||||
_ = args;
|
||||
return JSC.JSValue.jsUndefined();
|
||||
}
|
||||
pub fn includes(this: *Buffer, globalThis: *JSC.JSGlobalObject, args: Arguments.Includes) JSC.JSValue {
|
||||
_ = this;
|
||||
_ = globalThis;
|
||||
_ = args;
|
||||
return JSC.JSValue.jsUndefined();
|
||||
}
|
||||
pub fn indexOf(this: *Buffer, globalThis: *JSC.JSGlobalObject, args: Arguments.IndexOf) JSC.JSValue {
|
||||
_ = this;
|
||||
_ = globalThis;
|
||||
_ = args;
|
||||
return JSC.JSValue.jsUndefined();
|
||||
}
|
||||
pub fn lastIndexOf(this: *Buffer, globalThis: *JSC.JSGlobalObject, args: Arguments.LastIndexOf) JSC.JSValue {
|
||||
_ = this;
|
||||
_ = globalThis;
|
||||
_ = args;
|
||||
return JSC.JSValue.jsUndefined();
|
||||
}
|
||||
pub fn swap16(this: *Buffer, globalThis: *JSC.JSGlobalObject, args: Arguments.Swap16) JSC.JSValue {
|
||||
_ = this;
|
||||
_ = globalThis;
|
||||
_ = args;
|
||||
return JSC.JSValue.jsUndefined();
|
||||
}
|
||||
pub fn swap32(this: *Buffer, globalThis: *JSC.JSGlobalObject, args: Arguments.Swap32) JSC.JSValue {
|
||||
_ = this;
|
||||
_ = globalThis;
|
||||
_ = args;
|
||||
return JSC.JSValue.jsUndefined();
|
||||
}
|
||||
pub fn swap64(this: *Buffer, globalThis: *JSC.JSGlobalObject, args: Arguments.Swap64) JSC.JSValue {
|
||||
_ = this;
|
||||
_ = globalThis;
|
||||
_ = args;
|
||||
return JSC.JSValue.jsUndefined();
|
||||
}
|
||||
pub fn write(this: *Buffer, globalThis: *JSC.JSGlobalObject, args: Arguments.Write) JSC.JSValue {
|
||||
_ = this;
|
||||
_ = globalThis;
|
||||
_ = args;
|
||||
return JSC.JSValue.jsUndefined();
|
||||
}
|
||||
pub fn read(this: *Buffer, globalThis: *JSC.JSGlobalObject, args: Arguments.Read) JSC.JSValue {
|
||||
_ = this;
|
||||
_ = globalThis;
|
||||
_ = args;
|
||||
return JSC.JSValue.jsUndefined();
|
||||
}
|
||||
|
||||
fn writeIntAny(this: *Buffer, comptime kind: Int, args: Arguments.WriteInt(kind)) JSC.JSValue {}
|
||||
fn readIntAny(this: *Buffer, comptime kind: Int, args: Arguments.ReadInt(kind)) JSC.JSValue {}
|
||||
|
||||
pub const Class = JSC.NewClass(
|
||||
void,
|
||||
.{ .name = "Buffer" },
|
||||
.{
|
||||
.compare = .{
|
||||
.name = "compare",
|
||||
.rfn = wrap(BufferPrototype.compare),
|
||||
},
|
||||
.copy = .{
|
||||
.name = "copy",
|
||||
.rfn = wrap(BufferPrototype.copy),
|
||||
},
|
||||
.equals = .{
|
||||
.name = "equals",
|
||||
.rfn = wrap(BufferPrototype.equals),
|
||||
},
|
||||
.fill = .{
|
||||
.name = "fill",
|
||||
.rfn = wrap(BufferPrototype.fill),
|
||||
},
|
||||
.includes = .{
|
||||
.name = "includes",
|
||||
.rfn = wrap(BufferPrototype.includes),
|
||||
},
|
||||
.indexOf = .{
|
||||
.name = "indexOf",
|
||||
.rfn = wrap(BufferPrototype.indexOf),
|
||||
},
|
||||
.lastIndexOf = .{
|
||||
.name = "lastIndexOf",
|
||||
.rfn = wrap(BufferPrototype.lastIndexOf),
|
||||
},
|
||||
.swap16 = .{
|
||||
.name = "swap16",
|
||||
.rfn = wrap(BufferPrototype.swap16),
|
||||
},
|
||||
.swap32 = .{
|
||||
.name = "swap32",
|
||||
.rfn = wrap(BufferPrototype.swap32),
|
||||
},
|
||||
.swap64 = .{
|
||||
.name = "swap64",
|
||||
.rfn = wrap(BufferPrototype.swap64),
|
||||
},
|
||||
.write = .{
|
||||
.name = "write",
|
||||
.rfn = wrap(BufferPrototype.write),
|
||||
},
|
||||
.read = .{
|
||||
.name = "read",
|
||||
.rfn = wrap(BufferPrototype.read),
|
||||
},
|
||||
|
||||
// -- Write --
|
||||
.writeBigInt64BE = .{
|
||||
.name = "writeBigInt64BE",
|
||||
.rfn = writeWrap(Int.BigInt64BE),
|
||||
},
|
||||
.writeBigInt64LE = .{
|
||||
.name = "writeBigInt64LE",
|
||||
.rfn = writeWrap(Int.BigInt64LE),
|
||||
},
|
||||
.writeBigUInt64BE = .{
|
||||
.name = "writeBigUInt64BE",
|
||||
.rfn = writeWrap(Int.BigUInt64BE),
|
||||
},
|
||||
.writeBigUInt64LE = .{
|
||||
.name = "writeBigUInt64LE",
|
||||
.rfn = writeWrap(Int.BigUInt64LE),
|
||||
},
|
||||
.writeDoubleBE = .{
|
||||
.name = "writeDoubleBE",
|
||||
.rfn = writeWrap(Int.DoubleBE),
|
||||
},
|
||||
.writeDoubleLE = .{
|
||||
.name = "writeDoubleLE",
|
||||
.rfn = writeWrap(Int.DoubleLE),
|
||||
},
|
||||
.writeFloatBE = .{
|
||||
.name = "writeFloatBE",
|
||||
.rfn = writeWrap(Int.FloatBE),
|
||||
},
|
||||
.writeFloatLE = .{
|
||||
.name = "writeFloatLE",
|
||||
.rfn = writeWrap(Int.FloatLE),
|
||||
},
|
||||
.writeInt8 = .{
|
||||
.name = "writeInt8",
|
||||
.rfn = writeWrap(Int.Int8),
|
||||
},
|
||||
.writeInt16BE = .{
|
||||
.name = "writeInt16BE",
|
||||
.rfn = writeWrap(Int.Int16BE),
|
||||
},
|
||||
.writeInt16LE = .{
|
||||
.name = "writeInt16LE",
|
||||
.rfn = writeWrap(Int.Int16LE),
|
||||
},
|
||||
.writeInt32BE = .{
|
||||
.name = "writeInt32BE",
|
||||
.rfn = writeWrap(Int.Int32BE),
|
||||
},
|
||||
.writeInt32LE = .{
|
||||
.name = "writeInt32LE",
|
||||
.rfn = writeWrap(Int.Int32LE),
|
||||
},
|
||||
.writeIntBE = .{
|
||||
.name = "writeIntBE",
|
||||
.rfn = writeWrap(Int.IntBE),
|
||||
},
|
||||
.writeIntLE = .{
|
||||
.name = "writeIntLE",
|
||||
.rfn = writeWrap(Int.IntLE),
|
||||
},
|
||||
.writeUInt8 = .{
|
||||
.name = "writeUInt8",
|
||||
.rfn = writeWrap(Int.UInt8),
|
||||
},
|
||||
.writeUInt16BE = .{
|
||||
.name = "writeUInt16BE",
|
||||
.rfn = writeWrap(Int.UInt16BE),
|
||||
},
|
||||
.writeUInt16LE = .{
|
||||
.name = "writeUInt16LE",
|
||||
.rfn = writeWrap(Int.UInt16LE),
|
||||
},
|
||||
.writeUInt32BE = .{
|
||||
.name = "writeUInt32BE",
|
||||
.rfn = writeWrap(Int.UInt32BE),
|
||||
},
|
||||
.writeUInt32LE = .{
|
||||
.name = "writeUInt32LE",
|
||||
.rfn = writeWrap(Int.UInt32LE),
|
||||
},
|
||||
.writeUIntBE = .{
|
||||
.name = "writeUIntBE",
|
||||
.rfn = writeWrap(Int.UIntBE),
|
||||
},
|
||||
.writeUIntLE = .{
|
||||
.name = "writeUIntLE",
|
||||
.rfn = writeWrap(Int.UIntLE),
|
||||
},
|
||||
|
||||
// -- Read --
|
||||
.readBigInt64BE = .{
|
||||
.name = "readBigInt64BE",
|
||||
.rfn = readWrap(Int.BigInt64BE),
|
||||
},
|
||||
.readBigInt64LE = .{
|
||||
.name = "readBigInt64LE",
|
||||
.rfn = readWrap(Int.BigInt64LE),
|
||||
},
|
||||
.readBigUInt64BE = .{
|
||||
.name = "readBigUInt64BE",
|
||||
.rfn = readWrap(Int.BigUInt64BE),
|
||||
},
|
||||
.readBigUInt64LE = .{
|
||||
.name = "readBigUInt64LE",
|
||||
.rfn = readWrap(Int.BigUInt64LE),
|
||||
},
|
||||
.readDoubleBE = .{
|
||||
.name = "readDoubleBE",
|
||||
.rfn = readWrap(Int.DoubleBE),
|
||||
},
|
||||
.readDoubleLE = .{
|
||||
.name = "readDoubleLE",
|
||||
.rfn = readWrap(Int.DoubleLE),
|
||||
},
|
||||
.readFloatBE = .{
|
||||
.name = "readFloatBE",
|
||||
.rfn = readWrap(Int.FloatBE),
|
||||
},
|
||||
.readFloatLE = .{
|
||||
.name = "readFloatLE",
|
||||
.rfn = readWrap(Int.FloatLE),
|
||||
},
|
||||
.readInt8 = .{
|
||||
.name = "readInt8",
|
||||
.rfn = readWrap(Int.Int8),
|
||||
},
|
||||
.readInt16BE = .{
|
||||
.name = "readInt16BE",
|
||||
.rfn = readWrap(Int.Int16BE),
|
||||
},
|
||||
.readInt16LE = .{
|
||||
.name = "readInt16LE",
|
||||
.rfn = readWrap(Int.Int16LE),
|
||||
},
|
||||
.readInt32BE = .{
|
||||
.name = "readInt32BE",
|
||||
.rfn = readWrap(Int.Int32BE),
|
||||
},
|
||||
.readInt32LE = .{
|
||||
.name = "readInt32LE",
|
||||
.rfn = readWrap(Int.Int32LE),
|
||||
},
|
||||
.readIntBE = .{
|
||||
.name = "readIntBE",
|
||||
.rfn = readWrap(Int.IntBE),
|
||||
},
|
||||
.readIntLE = .{
|
||||
.name = "readIntLE",
|
||||
.rfn = readWrap(Int.IntLE),
|
||||
},
|
||||
.readUInt8 = .{
|
||||
.name = "readUInt8",
|
||||
.rfn = readWrap(Int.UInt8),
|
||||
},
|
||||
.readUInt16BE = .{
|
||||
.name = "readUInt16BE",
|
||||
.rfn = readWrap(Int.UInt16BE),
|
||||
},
|
||||
.readUInt16LE = .{
|
||||
.name = "readUInt16LE",
|
||||
.rfn = readWrap(Int.UInt16LE),
|
||||
},
|
||||
.readUInt32BE = .{
|
||||
.name = "readUInt32BE",
|
||||
.rfn = readWrap(Int.UInt32BE),
|
||||
},
|
||||
.readUInt32LE = .{
|
||||
.name = "readUInt32LE",
|
||||
.rfn = readWrap(Int.UInt32LE),
|
||||
},
|
||||
.readUIntBE = .{
|
||||
.name = "readUIntBE",
|
||||
.rfn = readWrap(Int.UIntBE),
|
||||
},
|
||||
.readUIntLE = .{
|
||||
.name = "readUIntLE",
|
||||
.rfn = readWrap(Int.UIntLE),
|
||||
},
|
||||
},
|
||||
.{},
|
||||
);
|
||||
};
|
||||
|
||||
const Int = enum {
|
||||
BigInt64BE,
|
||||
BigInt64LE,
|
||||
BigUInt64BE,
|
||||
BigUInt64LE,
|
||||
DoubleBE,
|
||||
DoubleLE,
|
||||
FloatBE,
|
||||
FloatLE,
|
||||
Int8,
|
||||
Int16BE,
|
||||
Int16LE,
|
||||
Int32BE,
|
||||
Int32LE,
|
||||
IntBE,
|
||||
IntLE,
|
||||
UInt8,
|
||||
UInt16BE,
|
||||
UInt16LE,
|
||||
UInt32BE,
|
||||
UInt32LE,
|
||||
UIntBE,
|
||||
UIntLE,
|
||||
|
||||
const NativeMap = std.EnumArray(Int, type);
|
||||
pub const native: NativeMap = brk: {
|
||||
var map = NativeMap.initUndefined();
|
||||
map.set(.BigInt64BE, i64);
|
||||
map.set(.BigInt64LE, i64);
|
||||
map.set(.BigUInt64BE, u64);
|
||||
map.set(.BigUInt64LE, u64);
|
||||
map.set(.DoubleBE, f64);
|
||||
map.set(.DoubleLE, f64);
|
||||
map.set(.FloatBE, f32);
|
||||
map.set(.FloatLE, f32);
|
||||
map.set(.Int8, i8);
|
||||
map.set(.Int16BE, i16);
|
||||
map.set(.Int16LE, i16);
|
||||
map.set(.Int32BE, u32);
|
||||
map.set(.Int32LE, u32);
|
||||
map.set(.IntBE, i32);
|
||||
map.set(.IntLE, i32);
|
||||
map.set(.UInt8, u8);
|
||||
map.set(.UInt16BE, u16);
|
||||
map.set(.UInt16LE, u16);
|
||||
map.set(.UInt32BE, u32);
|
||||
map.set(.UInt32LE, u32);
|
||||
map.set(.UIntBE, u32);
|
||||
map.set(.UIntLE, u32);
|
||||
break :brk map;
|
||||
};
|
||||
};
|
||||
Reference in New Issue
Block a user