goscript 0.0.36 → 0.0.38

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
+

package/gs/os/exec.gs.ts

@@ -0,0 +1,198 @@
+import * as $ from "@goscript/builtin/builtin.js";
+import { ErrUnimplemented } from "./error.gs.js";
+
+import * as errors from "@goscript/errors/index.js"
+import * as syscall from "@goscript/syscall/index.js"
+
+export let ErrProcessDone: $.GoError = errors.New("os: process already finished")
+
+// Simplified Process class for JavaScript environment
+export class Process {
+	public get Pid(): number {
+		return this._fields.Pid.value
+	}
+	public set Pid(value: number) {
+		this._fields.Pid.value = value
+	}
+
+	public _fields: {
+		Pid: $.VarRef<number>;
+	}
+
+	constructor(init?: Partial<{Pid?: number}>) {
+		this._fields = {
+			Pid: $.varRef(init?.Pid ?? -1)
+		}
+	}
+
+	public clone(): Process {
+		const cloned = new Process()
+		cloned._fields = {
+			Pid: $.varRef(this._fields.Pid.value)
+		}
+		return cloned
+	}
+
+	// All process operations return ErrUnimplemented in JavaScript
+	public Release(): $.GoError {
+		return ErrUnimplemented
+	}
+
+	public Kill(): $.GoError {
+		return ErrUnimplemented
+	}
+
+	public Wait(): [ProcessState | null, $.GoError] {
+		return [null, ErrUnimplemented]
+	}
+
+	public Signal(sig: Signal): $.GoError {
+		return ErrUnimplemented
+	}
+
+	// Register this type with the runtime type system
+	static __typeInfo = $.registerStructType(
+		'Process',
+		new Process(),
+		[
+			{ name: "Release", args: [], returns: [{ type: { kind: $.TypeKind.Interface, name: 'GoError', methods: [{ name: 'Error', args: [], returns: [{ type: { kind: $.TypeKind.Basic, name: 'string' } }] }] } }] },
+			{ name: "Kill", args: [], returns: [{ type: { kind: $.TypeKind.Interface, name: 'GoError', methods: [{ name: 'Error', args: [], returns: [{ type: { kind: $.TypeKind.Basic, name: 'string' } }] }] } }] },
+			{ name: "Wait", args: [], returns: [{ type: { kind: $.TypeKind.Pointer, elemType: "ProcessState" } }, { type: { kind: $.TypeKind.Interface, name: 'GoError', methods: [{ name: 'Error', args: [], returns: [{ type: { kind: $.TypeKind.Basic, name: 'string' } }] }] } }] },
+			{ name: "Signal", args: [{ name: "sig", type: "Signal" }], returns: [{ type: { kind: $.TypeKind.Interface, name: 'GoError', methods: [{ name: 'Error', args: [], returns: [{ type: { kind: $.TypeKind.Basic, name: 'string' } }] }] } }] }
+		],
+		Process,
+		{ "Pid": { kind: $.TypeKind.Basic, name: "number" } }
+	);
+}
+
+// Simplified ProcAttr class for JavaScript environment  
+export class ProcAttr {
+	public get Dir(): string {
+		return this._fields.Dir.value
+	}
+	public set Dir(value: string) {
+		this._fields.Dir.value = value
+	}
+
+	public get Env(): $.Slice<string> {
+		return this._fields.Env.value
+	}
+	public set Env(value: $.Slice<string>) {
+		this._fields.Env.value = value
+	}
+
+	public get Files(): $.Slice<any> {
+		return this._fields.Files.value
+	}
+	public set Files(value: $.Slice<any>) {
+		this._fields.Files.value = value
+	}
+
+	public get Sys(): any {
+		return this._fields.Sys.value
+	}
+	public set Sys(value: any) {
+		this._fields.Sys.value = value
+	}
+
+	public _fields: {
+		Dir: $.VarRef<string>;
+		Env: $.VarRef<$.Slice<string>>;
+		Files: $.VarRef<$.Slice<any>>;
+		Sys: $.VarRef<any>;
+	}
+
+	constructor(init?: Partial<{Dir?: string, Env?: $.Slice<string>, Files?: $.Slice<any>, Sys?: any}>) {
+		this._fields = {
+			Dir: $.varRef(init?.Dir ?? ""),
+			Env: $.varRef(init?.Env ?? null),
+			Files: $.varRef(init?.Files ?? null),
+			Sys: $.varRef(init?.Sys ?? null)
+		}
+	}
+
+	public clone(): ProcAttr {
+		const cloned = new ProcAttr()
+		cloned._fields = {
+			Dir: $.varRef(this._fields.Dir.value),
+			Env: $.varRef(this._fields.Env.value),
+			Files: $.varRef(this._fields.Files.value),
+			Sys: $.varRef(this._fields.Sys.value)
+		}
+		return cloned
+	}
+
+	// Register this type with the runtime type system
+	static __typeInfo = $.registerStructType(
+		'ProcAttr',
+		new ProcAttr(),
+		[],
+		ProcAttr,
+		{ 
+			"Dir": { kind: $.TypeKind.Basic, name: "string" },
+			"Env": { kind: $.TypeKind.Slice, elemType: { kind: $.TypeKind.Basic, name: "string" } },
+			"Files": { kind: $.TypeKind.Slice, elemType: { kind: $.TypeKind.Basic, name: "any" } },
+			"Sys": { kind: $.TypeKind.Basic, name: "any" }
+		}
+	);
+}
+
+// Stub ProcessState for JavaScript environment
+export class ProcessState {
+	public _fields: {}
+
+	constructor() {
+		this._fields = {}
+	}
+
+	public clone(): ProcessState {
+		return new ProcessState()
+	}
+
+	// Register this type with the runtime type system
+	static __typeInfo = $.registerStructType(
+		'ProcessState',
+		new ProcessState(),
+		[],
+		ProcessState,
+		{}
+	);
+}
+
+// Signal interface stub
+export type Signal = null | {
+	Signal(): void
+	String(): string
+}
+export const Signal = null as any;
+
+// Stub functions that return ErrUnimplemented
+export function Getpid(): number {
+	return -1 // Not available in JavaScript
+}
+
+export function Getppid(): number {
+	return -1 // Not available in JavaScript
+}
+
+export function FindProcess(pid: number): [Process | null, $.GoError] {
+	return [null, ErrUnimplemented]
+}
+
+export function StartProcess(name: string, argv: $.Slice<string>, attr: ProcAttr | null): [Process | null, $.GoError] {
+	return [null, ErrUnimplemented]
+}
+
+// Internal functions used by exec_unix.gs.ts
+export function newDoneProcess(pid: number): Process {
+	return new Process({Pid: pid})
+}
+
+export function newHandleProcess(pid: number, handle: number): Process {
+	return new Process({Pid: pid})
+}
+
+export function newPIDProcess(pid: number): Process {
+	return new Process({Pid: pid})
+}
+

package/gs/os/exec_nohandle.gs.ts

@@ -0,0 +1,2 @@
+import * as $ from "@goscript/builtin/builtin.js";
+

package/gs/os/exec_posix.gs.ts

@@ -0,0 +1,95 @@
+import * as $ from "@goscript/builtin/builtin.js";
+import { Signal } from "./exec.gs.js";
+import { ErrUnimplemented } from "./error.gs.js";
+
+import * as syscall from "@goscript/syscall/index.js"
+
+// Signal constants for JavaScript environment
+export let Interrupt: Signal = null // syscall.SIGINT not available in JavaScript
+
+export let Kill: Signal = null // syscall.SIGKILL not available in JavaScript
+
+// Simplified ProcessState for JavaScript environment  
+export class ProcessState {
+	public get pid(): number {
+		return this._fields.pid.value
+	}
+	public set pid(value: number) {
+		this._fields.pid.value = value
+	}
+
+	public _fields: {
+		pid: $.VarRef<number>;
+	}
+
+	constructor(init?: Partial<{pid?: number}>) {
+		this._fields = {
+			pid: $.varRef(init?.pid ?? -1)
+		}
+	}
+
+	public clone(): ProcessState {
+		const cloned = new ProcessState()
+		cloned._fields = {
+			pid: $.varRef(this._fields.pid.value)
+		}
+		return cloned
+	}
+
+	// All methods return stub values for JavaScript environment
+	public UserTime(): any {
+		return 0 // Duration not available
+	}
+
+	public SystemTime(): any {
+		return 0 // Duration not available
+	}
+
+	public Exited(): boolean {
+		return false
+	}
+
+	public Success(): boolean {
+		return false
+	}
+
+	public Sys(): null | any {
+		return null
+	}
+
+	public SysUsage(): null | any {
+		return null
+	}
+
+	public Pid(): number {
+		return this.pid
+	}
+
+	public String(): string {
+		return `exit status ${this.pid}`
+	}
+
+	public ExitCode(): number {
+		return -1
+	}
+
+	// Register this type with the runtime type system
+	static __typeInfo = $.registerStructType(
+		'ProcessState',
+		new ProcessState(),
+		[
+			{ name: "UserTime", args: [], returns: [{ type: { kind: $.TypeKind.Basic, name: "any" } }] },
+			{ name: "SystemTime", args: [], returns: [{ type: { kind: $.TypeKind.Basic, name: "any" } }] },
+			{ name: "Exited", args: [], returns: [{ type: { kind: $.TypeKind.Basic, name: "boolean" } }] },
+			{ name: "Success", args: [], returns: [{ type: { kind: $.TypeKind.Basic, name: "boolean" } }] },
+			{ name: "Sys", args: [], returns: [{ type: { kind: $.TypeKind.Basic, name: "any" } }] },
+			{ name: "SysUsage", args: [], returns: [{ type: { kind: $.TypeKind.Basic, name: "any" } }] },
+			{ name: "Pid", args: [], returns: [{ type: { kind: $.TypeKind.Basic, name: "number" } }] },
+			{ name: "String", args: [], returns: [{ type: { kind: $.TypeKind.Basic, name: "string" } }] },
+			{ name: "ExitCode", args: [], returns: [{ type: { kind: $.TypeKind.Basic, name: "number" } }] }
+		],
+		ProcessState,
+		{ "pid": { kind: $.TypeKind.Basic, name: "number" } }
+	);
+}
+

package/gs/os/exec_unix.gs.ts

@@ -0,0 +1,64 @@
+import * as $ from "@goscript/builtin/builtin.js";
+import { NewSyscallError, ErrUnimplemented } from "./error.gs.js";
+import { newDoneProcess, newHandleProcess, newPIDProcess, Process, ErrProcessDone } from "./exec.gs.js";
+
+import * as errors from "@goscript/errors/index.js"
+
+import * as runtime from "@goscript/runtime/index.js"
+
+import * as syscall from "@goscript/syscall/index.js"
+
+import * as time from "@goscript/time/index.js"
+
+// Import uintptr type
+type uintptr = syscall.uintptr
+
+// Stub functions for JavaScript environment
+function ignoringEINTR2(fn: any, arg1: any, arg2: any): [any, $.GoError] {
+	return [null, ErrUnimplemented]
+}
+
+function pidfdFind(pid: number): [uintptr, $.GoError] {
+	return [0, ErrUnimplemented]
+}
+
+// Special values for Process.Pid.
+let pidUnset: number = 0
+
+let pidReleased: number = -1
+
+export function convertESRCH(err: $.GoError): $.GoError {
+	if (err == syscall.ESRCH) {
+		return ErrProcessDone
+	}
+	return err
+}
+
+export function findProcess(pid: number): [Process | null, $.GoError] {
+	let p: Process | null = null
+	let err: $.GoError = null
+	{
+		let h: uintptr
+		[h, err] = pidfdFind(pid)
+
+		// We can't return an error here since users are not expecting
+		// it. Instead, return a process with a "done" state already
+		// and let a subsequent Signal or Wait call catch that.
+
+		// Ignore other errors from pidfdFind, as the callers
+		// do not expect them. Fall back to using the PID.
+		if (err == ErrProcessDone) {
+			// We can't return an error here since users are not expecting
+			// it. Instead, return a process with a "done" state already
+			// and let a subsequent Signal or Wait call catch that.
+			return [newDoneProcess(pid), null]
+		} else if (err != null) {
+			// Ignore other errors from pidfdFind, as the callers
+			// do not expect them. Fall back to using the PID.
+			return [newPIDProcess(pid), null]
+		}
+		// Use the handle.
+		return [newHandleProcess(pid, h), null]
+	}
+}
+

package/gs/os/executable.gs.ts

@@ -0,0 +1,18 @@
+import * as $ from "@goscript/builtin/builtin.js";
+import { executable } from "./executable_js.gs.js";
+
+// Executable returns the path name for the executable that started
+// the current process. There is no guarantee that the path is still
+// pointing to the correct executable. If a symlink was used to start
+// the process, depending on the operating system, the result might
+// be the symlink or the path it pointed to. If a stable result is
+// needed, [path/filepath.EvalSymlinks] might help.
+//
+// Executable returns an absolute path unless an error occurred.
+//
+// The main use case is finding resources located relative to an
+// executable.
+export function Executable(): [string, $.GoError] {
+	return executable()
+}
+

package/gs/os/executable_js.gs.ts

@@ -0,0 +1,6 @@
+import * as $ from "@goscript/builtin/builtin.js";
+import { ErrUnimplemented } from "./error.gs.js";
+
+export function executable(): [string, $.GoError] {
+	return ["", ErrUnimplemented]
+} 

package/gs/os/executable_wasm.gs.ts

@@ -0,0 +1,10 @@
+import * as $ from "@goscript/builtin/builtin.js";
+
+import * as errors from "@goscript/errors/index.js"
+
+import * as runtime from "@goscript/runtime/index.js"
+
+export function executable(): [string, $.GoError] {
+	return ["", errors.New("Executable not implemented for " + runtime.GOOS)]
+}
+