goscript 0.0.35 → 0.0.37

package/gs/os/dir_unix.gs.ts

@@ -0,0 +1,155 @@
+import * as $ from "@goscript/builtin/builtin.js";
+import { direntIno, direntNamlen, direntReclen, direntType } from "./dirent_js.gs.js";
+import { IsNotExist } from "./error.gs.js";
+import { newUnixDirent } from "./file_unix_js.gs.js";
+
+import * as byteorder from "@goscript/internal/byteorder/index.js"
+
+import * as goarch from "@goscript/internal/goarch/index.js"
+
+import * as io from "@goscript/io/index.js"
+
+import * as runtime from "@goscript/runtime/index.js"
+
+import * as sync from "@goscript/sync/index.js"
+
+import * as syscall from "@goscript/syscall/index.js"
+
+import * as unsafe from "@goscript/unsafe/index.js"
+
+// Import uintptr type
+type uintptr = syscall.uintptr
+
+class dirInfo {
+	public get mu(): sync.Mutex {
+		return this._fields.mu.value
+	}
+	public set mu(value: sync.Mutex) {
+		this._fields.mu.value = value
+	}
+
+	// buffer for directory I/O
+	public get buf(): $.VarRef<$.Bytes> | null {
+		return this._fields.buf.value
+	}
+	public set buf(value: $.VarRef<$.Bytes> | null) {
+		this._fields.buf.value = value
+	}
+
+	// length of buf; return value from Getdirentries
+	public get nbuf(): number {
+		return this._fields.nbuf.value
+	}
+	public set nbuf(value: number) {
+		this._fields.nbuf.value = value
+	}
+
+	// location of next record in buf.
+	public get bufp(): number {
+		return this._fields.bufp.value
+	}
+	public set bufp(value: number) {
+		this._fields.bufp.value = value
+	}
+
+	public _fields: {
+		mu: $.VarRef<sync.Mutex>;
+		buf: $.VarRef<$.VarRef<$.Bytes> | null>;
+		nbuf: $.VarRef<number>;
+		bufp: $.VarRef<number>;
+	}
+
+	constructor(init?: Partial<{buf?: $.VarRef<$.Bytes> | null, bufp?: number, mu?: sync.Mutex, nbuf?: number}>) {
+		this._fields = {
+			mu: $.varRef(init?.mu?.clone() ?? new sync.Mutex()),
+			buf: $.varRef(init?.buf ?? null),
+			nbuf: $.varRef(init?.nbuf ?? 0),
+			bufp: $.varRef(init?.bufp ?? 0)
+		}
+	}
+
+	public clone(): dirInfo {
+		const cloned = new dirInfo()
+		cloned._fields = {
+			mu: $.varRef(this._fields.mu.value?.clone() ?? null),
+			buf: $.varRef(this._fields.buf.value),
+			nbuf: $.varRef(this._fields.nbuf.value),
+			bufp: $.varRef(this._fields.bufp.value)
+		}
+		return cloned
+	}
+
+	public close(): void {
+		const d = this
+		if (d.buf != null) {
+			dirBufPool.Put(d.buf)
+			d.buf = null
+		}
+	}
+
+	// Register this type with the runtime type system
+	static __typeInfo = $.registerStructType(
+	  'dirInfo',
+	  new dirInfo(),
+	  [{ name: "close", args: [], returns: [] }],
+	  dirInfo,
+	  {"mu": "Mutex", "buf": { kind: $.TypeKind.Pointer, elemType: { kind: $.TypeKind.Slice, elemType: { kind: $.TypeKind.Basic, name: "number" } } }, "nbuf": { kind: $.TypeKind.Basic, name: "number" }, "bufp": { kind: $.TypeKind.Basic, name: "number" }}
+	);
+}
+
+// More than 5760 to work around https://golang.org/issue/24015.
+let blockSize: number = 8192
+
+let dirBufPool: sync.Pool = new sync.Pool({New: (): null | any => {
+	// The buffer must be at least a block long.
+	let buf = new Uint8Array(8192)
+	return buf
+}})
+
+// readInt returns the size-bytes unsigned integer in native byte order at offset off.
+export function readInt(b: $.Bytes, off: uintptr, size: uintptr): [number, boolean] {
+	let u: number = 0
+	let ok: boolean = false
+	{
+		if ($.len(b) < $.int(off + size)) {
+			return [0, false]
+		}
+		if (goarch.BigEndian) {
+			return [readIntBE($.goSlice(b, off, undefined), size), true]
+		}
+		return [readIntLE($.goSlice(b, off, undefined), size), true]
+	}
+}
+
+export function readIntBE(b: $.Bytes, size: uintptr): number {
+	switch (size) {
+		case 1:
+			return (b![0] as number)
+		case 2:
+			return (byteorder.BEUint16(b) as number)
+		case 4:
+			return (byteorder.BEUint32(b) as number)
+		case 8:
+			return (byteorder.BEUint64(b) as number)
+		default:
+			$.panic("syscall: readInt with unsupported size")
+			return 0 // This line will never be reached due to panic, but satisfies TypeScript
+	}
+}
+
+export function readIntLE(b: $.Bytes, size: uintptr): number {
+	switch (size) {
+		case 1:
+			return (b![0] as number)
+		case 2:
+			return (byteorder.LEUint16(b) as number)
+		case 4:
+			return (byteorder.LEUint32(b) as number)
+		case 8:
+			return (byteorder.LEUint64(b) as number)
+		default:
+			$.panic("syscall: readInt with unsupported size")
+			return 0 // This line will never be reached due to panic, but satisfies TypeScript
+	}
+}
+

package/gs/os/dirent_js.gs.ts

@@ -0,0 +1,27 @@
+import * as $ from "@goscript/builtin/builtin.js";
+import { readInt } from "./dir_unix.gs.js";
+
+import * as syscall from "@goscript/syscall/index.js"
+
+import * as unsafe from "@goscript/unsafe/index.js"
+
+export function direntIno(buf: $.Bytes): [number, boolean] {
+	return [1, true]
+}
+
+export function direntReclen(buf: $.Bytes): [number, boolean] {
+	return readInt(buf, unsafe.Offsetof(new syscall.Dirent({}).Reclen), unsafe.Sizeof(new syscall.Dirent({}).Reclen))
+}
+
+export function direntNamlen(buf: $.Bytes): [number, boolean] {
+	let [reclen, ok] = direntReclen(buf)
+	if (!ok) {
+		return [0, false]
+	}
+	return [reclen - (unsafe.Offsetof(new syscall.Dirent({}).Name) as number), true]
+}
+
+export function direntType(buf: $.Bytes): number {
+	return ~(0 as number)
+}
+

package/gs/os/env.gs.ts

@@ -0,0 +1,179 @@
+import * as $ from "@goscript/builtin/builtin.js";
+import { NewSyscallError } from "./error.gs.js";
+
+import * as syscall from "@goscript/syscall/index.js"
+
+// Expand replaces ${var} or $var in the string based on the mapping function.
+// For example, [os.ExpandEnv](s) is equivalent to [os.Expand](s, [os.Getenv]).
+export function Expand(s: string, mapping: ((p0: string) => string) | null): string {
+	let buf: $.Bytes = new Uint8Array(0)
+	// ${} is all ASCII, so bytes are fine for this operation.
+	let i = 0
+
+	// Encountered invalid syntax; eat the
+	// characters.
+
+	// Valid syntax, but $ was not followed by a
+	// name. Leave the dollar character untouched.
+	for (let j = 0; j < $.len(s); j++) {
+
+		// Encountered invalid syntax; eat the
+		// characters.
+
+		// Valid syntax, but $ was not followed by a
+		// name. Leave the dollar character untouched.
+		if ($.indexString(s, j) == 36 && j + 1 < $.len(s)) {
+			if (buf == null) {
+				buf = $.makeSlice<number>(0, 2 * $.len(s), 'byte')
+			}
+			buf = $.append(buf, ...$.stringToBytes($.sliceString(s, i, j)))
+			let [name, w] = getShellName($.sliceString(s, j + 1, undefined))
+
+			// Encountered invalid syntax; eat the
+			// characters.
+
+			// Valid syntax, but $ was not followed by a
+			// name. Leave the dollar character untouched.
+			if (name == "" && w > 0) {
+
+			} else if (name == "") {
+				// Valid syntax, but $ was not followed by a
+				// name. Leave the dollar character untouched.
+				buf = $.append(buf, $.indexString(s, j))
+			} else {
+				buf = $.append(buf, ...$.stringToBytes(mapping!(name)))
+			}
+			j += w
+			i = j + 1
+		}
+	}
+	if (buf == null) {
+		return s
+	}
+	return $.bytesToString(buf) + $.sliceString(s, i, undefined)
+}
+
+// ExpandEnv replaces ${var} or $var in the string according to the values
+// of the current environment variables. References to undefined
+// variables are replaced by the empty string.
+export function ExpandEnv(s: string): string {
+	return Expand(s, Getenv)
+}
+
+// isShellSpecialVar reports whether the character identifies a special
+// shell variable such as $*.
+export function isShellSpecialVar(c: number): boolean {
+	switch (c) {
+		case 42:
+		case 35:
+		case 36:
+		case 64:
+		case 33:
+		case 63:
+		case 45:
+		case 48:
+		case 49:
+		case 50:
+		case 51:
+		case 52:
+		case 53:
+		case 54:
+		case 55:
+		case 56:
+		case 57:
+			return true
+			break
+	}
+	return false
+}
+
+// isAlphaNum reports whether the byte is an ASCII letter, number, or underscore.
+export function isAlphaNum(c: number): boolean {
+	return c == 95 || 48 <= c && c <= 57 || 97 <= c && c <= 122 || 65 <= c && c <= 90
+}
+
+// getShellName returns the name that begins the string and the number of bytes
+// consumed to extract it. If the name is enclosed in {}, it's part of a ${}
+// expansion and two more bytes are needed than the length of the name.
+export function getShellName(s: string): [string, number] {
+
+	// Scan to closing brace
+
+	// Bad syntax; eat "${}"
+
+	// Bad syntax; eat "${"
+	switch (true) {
+		case $.indexString(s, 0) == 123:
+			if ($.len(s) > 2 && isShellSpecialVar($.indexString(s, 1)) && $.indexString(s, 2) == 125) {
+				return [$.sliceString(s, 1, 2), 3]
+			}
+			for (let i = 1; i < $.len(s); i++) {
+
+				// Bad syntax; eat "${}"
+				if ($.indexString(s, i) == 125) {
+
+					// Bad syntax; eat "${}"
+					if (i == 1) {
+						return ["", 2]
+					}
+					return [$.sliceString(s, 1, i), i + 1]
+				}
+			}
+			return ["", 1]
+			break
+		case isShellSpecialVar($.indexString(s, 0)):
+			return [$.sliceString(s, 0, 1), 1]
+			break
+	}
+	// Scan alphanumerics.
+	let i: number = 0
+	for (i = 0; i < $.len(s) && isAlphaNum($.indexString(s, i)); i++) {
+	}
+	return [$.sliceString(s, undefined, i), i]
+}
+
+// Getenv retrieves the value of the environment variable named by the key.
+// It returns the value, which will be empty if the variable is not present.
+// To distinguish between an empty value and an unset value, use [LookupEnv].
+export function Getenv(key: string): string {
+	// testlog.Getenv(key) // Testlog not available in JavaScript
+	let [v, ] = syscall.Getenv(key)
+	return v
+}
+
+// LookupEnv retrieves the value of the environment variable named
+// by the key. If the variable is present in the environment the
+// value (which may be empty) is returned and the boolean is true.
+// Otherwise the returned value will be empty and the boolean will
+// be false.
+export function LookupEnv(key: string): [string, boolean] {
+	// testlog.Getenv(key) // Testlog not available in JavaScript
+	return syscall.Getenv(key)
+}
+
+// Setenv sets the value of the environment variable named by the key.
+// It returns an error, if any.
+export function Setenv(key: string, value: string): $.GoError {
+	let err = syscall.Setenv(key, value)
+	if (err != null) {
+		return NewSyscallError("setenv", err)
+	}
+	return null
+}
+
+// Unsetenv unsets a single environment variable.
+export function Unsetenv(key: string): $.GoError {
+	return syscall.Unsetenv(key)
+}
+
+// Clearenv deletes all environment variables.
+export function Clearenv(): void {
+	syscall.Clearenv()
+}
+
+// Environ returns a copy of strings representing the environment,
+// in the form "key=value".
+export function Environ(): $.Slice<string> {
+	return syscall.Environ()
+}
+

package/gs/os/error.gs.ts

@@ -0,0 +1,205 @@
+import * as $ from "@goscript/builtin/builtin.js";
+
+// import * as poll from "@goscript/internal/poll/index.js" // Not available in JavaScript
+
+import * as fs from "@goscript/io/fs/index.js"
+
+// ErrInvalid indicates an invalid argument.
+// Methods on File will return this error when the receiver is nil.
+// "invalid argument"
+export let ErrInvalid: $.GoError = fs.ErrInvalid
+
+// "permission denied"
+export let ErrPermission: $.GoError = fs.ErrPermission
+
+// "file already exists"
+export let ErrExist: $.GoError = fs.ErrExist
+
+// "file does not exist"
+export let ErrNotExist: $.GoError = fs.ErrNotExist
+
+// "file already closed"
+export let ErrClosed: $.GoError = fs.ErrClosed
+
+// "file type does not support deadline"
+export let ErrNoDeadline: $.GoError = errNoDeadline()
+
+// "i/o timeout"
+export let ErrDeadlineExceeded: $.GoError = errDeadlineExceeded()
+
+// "operation not implemented in JavaScript environment"
+export let ErrUnimplemented: $.GoError = {
+	Error: () => "operation not implemented in JavaScript environment"
+}
+
+export function errNoDeadline(): $.GoError {
+	return {Error: () => "file type does not support deadline"}
+}
+
+// errDeadlineExceeded returns the value for os.ErrDeadlineExceeded.
+// This error comes from the internal/poll package, which is also
+// used by package net. Doing it this way ensures that the net
+// package will return os.ErrDeadlineExceeded for an exceeded deadline,
+// as documented by net.Conn.SetDeadline, without requiring any extra
+// work in the net package and without requiring the internal/poll
+// package to import os (which it can't, because that would be circular).
+export function errDeadlineExceeded(): $.GoError {
+	return {Error: () => "i/o timeout"}
+}
+
+type timeout = null | {
+	Timeout(): boolean
+}
+
+$.registerInterfaceType(
+  'timeout',
+  null, // Zero value for interface is null
+  [{ name: "Timeout", args: [], returns: [{ type: { kind: $.TypeKind.Basic, name: "boolean" } }] }]
+);
+
+export type PathError = fs.PathError;
+export const PathError = null as any;
+
+export class SyscallError {
+	public get Syscall(): string {
+		return this._fields.Syscall.value
+	}
+	public set Syscall(value: string) {
+		this._fields.Syscall.value = value
+	}
+
+	public get Err(): $.GoError {
+		return this._fields.Err.value
+	}
+	public set Err(value: $.GoError) {
+		this._fields.Err.value = value
+	}
+
+	public _fields: {
+		Syscall: $.VarRef<string>;
+		Err: $.VarRef<$.GoError>;
+	}
+
+	constructor(init?: Partial<{Err?: $.GoError, Syscall?: string}>) {
+		this._fields = {
+			Syscall: $.varRef(init?.Syscall ?? ""),
+			Err: $.varRef(init?.Err ?? null)
+		}
+	}
+
+	public clone(): SyscallError {
+		const cloned = new SyscallError()
+		cloned._fields = {
+			Syscall: $.varRef(this._fields.Syscall.value),
+			Err: $.varRef(this._fields.Err.value)
+		}
+		return cloned
+	}
+
+	public Error(): string {
+		const e = this
+		return e.Syscall + ": " + e.Err!.Error()
+	}
+
+	public Unwrap(): $.GoError {
+		const e = this
+		return e.Err
+	}
+
+	// Timeout reports whether this error represents a timeout.
+	public Timeout(): boolean {
+		const e = this
+		let { value: t, ok: ok } = $.typeAssert<timeout>(e.Err, 'timeout')
+		return ok && t!.Timeout()
+	}
+
+	// Register this type with the runtime type system
+	static __typeInfo = $.registerStructType(
+	  'SyscallError',
+	  new SyscallError(),
+	  [{ name: "Error", args: [], returns: [{ type: { kind: $.TypeKind.Basic, name: "string" } }] }, { name: "Unwrap", args: [], returns: [{ type: { kind: $.TypeKind.Interface, name: 'GoError', methods: [{ name: 'Error', args: [], returns: [{ type: { kind: $.TypeKind.Basic, name: 'string' } }] }] } }] }, { name: "Timeout", args: [], returns: [{ type: { kind: $.TypeKind.Basic, name: "boolean" } }] }],
+	  SyscallError,
+	  {"Syscall": { kind: $.TypeKind.Basic, name: "string" }, "Err": { kind: $.TypeKind.Interface, name: 'GoError', methods: [{ name: 'Error', args: [], returns: [{ type: { kind: $.TypeKind.Basic, name: 'string' } }] }] }}
+	);
+}
+
+// NewSyscallError returns, as an error, a new [SyscallError]
+// with the given system call name and error details.
+// As a convenience, if err is nil, NewSyscallError returns nil.
+export function NewSyscallError(syscall: string, err: $.GoError): $.GoError {
+	if (err == null) {
+		return null
+	}
+	return new SyscallError({})
+}
+
+// IsExist returns a boolean indicating whether its argument is known to report
+// that a file or directory already exists. It is satisfied by [ErrExist] as
+// well as some syscall errors.
+//
+// This function predates [errors.Is]. It only supports errors returned by
+// the os package. New code should use errors.Is(err, fs.ErrExist).
+export function IsExist(err: $.GoError): boolean {
+	return underlyingErrorIs(err, ErrExist)
+}
+
+// IsNotExist returns a boolean indicating whether its argument is known to
+// report that a file or directory does not exist. It is satisfied by
+// [ErrNotExist] as well as some syscall errors.
+//
+// This function predates [errors.Is]. It only supports errors returned by
+// the os package. New code should use errors.Is(err, fs.ErrNotExist).
+export function IsNotExist(err: $.GoError): boolean {
+	return underlyingErrorIs(err, ErrNotExist)
+}
+
+// IsPermission returns a boolean indicating whether its argument is known to
+// report that permission is denied. It is satisfied by [ErrPermission] as well
+// as some syscall errors.
+//
+// This function predates [errors.Is]. It only supports errors returned by
+// the os package. New code should use errors.Is(err, fs.ErrPermission).
+export function IsPermission(err: $.GoError): boolean {
+	return underlyingErrorIs(err, ErrPermission)
+}
+
+// IsTimeout returns a boolean indicating whether its argument is known
+// to report that a timeout occurred.
+//
+// This function predates [errors.Is], and the notion of whether an
+// error indicates a timeout can be ambiguous. For example, the Unix
+// error EWOULDBLOCK sometimes indicates a timeout and sometimes does not.
+// New code should use errors.Is with a value appropriate to the call
+// returning the error, such as [os.ErrDeadlineExceeded].
+export function IsTimeout(err: $.GoError): boolean {
+	let { value: terr, ok: ok } = $.typeAssert<timeout>(underlyingError(err), 'timeout')
+	return ok && terr!.Timeout()
+}
+
+export function underlyingErrorIs(err: $.GoError, target: $.GoError): boolean {
+	// Note that this function is not errors.Is:
+	// underlyingError only unwraps the specific error-wrapping types
+	// that it historically did, not all errors implementing Unwrap().
+	err = underlyingError(err)
+	if (err == target) {
+		return true
+	}
+	// To preserve prior behavior, only examine syscall errors.
+	let { value: e, ok: ok } = $.typeAssert<any>(err, 'syscallErrorType')
+	return ok && e.Is(target)
+}
+
+// underlyingError returns the underlying error for known os error types.
+export function underlyingError(err: $.GoError): $.GoError {
+	$.typeSwitch(err, [{ types: [{kind: $.TypeKind.Pointer, elemType: 'PathError'}], body: (err) => {
+		return err!.Err
+	}},
+	{ types: [{kind: $.TypeKind.Pointer, elemType: 'LinkError'}], body: (err) => {
+		return err!.Err
+	}},
+	{ types: [{kind: $.TypeKind.Pointer, elemType: 'SyscallError'}], body: (err) => {
+		return err!.Err
+	}}])
+	return err
+}
+

package/gs/os/error_errno.gs.ts

@@ -0,0 +1,12 @@
+import * as $ from "@goscript/builtin/builtin.js";
+
+import * as syscall from "@goscript/syscall/index.js"
+
+type syscallErrorType = syscall.Errno;
+
+let errENOSYS: syscall.Errno = syscall.ENOSYS
+
+let errERANGE: syscall.Errno = syscall.ERANGE
+
+let errENOMEM: syscall.Errno = syscall.ENOMEM
+