goscript 0.0.36 → 0.0.37

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)]
+}
+

package/gs/os/file_constants_js.gs.ts

@@ -0,0 +1,98 @@
+import * as $ from "@goscript/builtin/builtin.js";
+import { ErrUnimplemented } from "./error.gs.js";
+
+// JavaScript-specific stubs for file constants and operations
+// These provide the required constants and stub implementations
+
+// File open flags - using values compatible with typical Unix systems
+export const O_RDONLY = 0
+export const O_WRONLY = 1
+export const O_RDWR = 2
+export const O_APPEND = 1024
+export const O_CREATE = 64
+export const O_EXCL = 128
+export const O_SYNC = 1052672
+export const O_TRUNC = 512
+
+// Seek constants
+export const SEEK_SET = 0
+export const SEEK_CUR = 1
+export const SEEK_END = 2
+
+// LinkError stub for compatibility
+export class LinkError {
+	public get Op(): string {
+		return this._fields.Op.value
+	}
+	public set Op(value: string) {
+		this._fields.Op.value = value
+	}
+
+	public get Old(): string {
+		return this._fields.Old.value
+	}
+	public set Old(value: string) {
+		this._fields.Old.value = value
+	}
+
+	public get New(): string {
+		return this._fields.New.value
+	}
+	public set New(value: string) {
+		this._fields.New.value = value
+	}
+
+	public get Err(): $.GoError {
+		return this._fields.Err.value
+	}
+	public set Err(value: $.GoError) {
+		this._fields.Err.value = value
+	}
+
+	public _fields: {
+		Op: $.VarRef<string>;
+		Old: $.VarRef<string>;
+		New: $.VarRef<string>;
+		Err: $.VarRef<$.GoError>;
+	}
+
+	constructor(init?: Partial<{Op?: string, Old?: string, New?: string, Err?: $.GoError}>) {
+		this._fields = {
+			Op: $.varRef(init?.Op ?? ""),
+			Old: $.varRef(init?.Old ?? ""),
+			New: $.varRef(init?.New ?? ""),
+			Err: $.varRef(init?.Err ?? null)
+		}
+	}
+
+	public Error(): string {
+		const e = this
+		return e.Op + " " + e.Old + " " + e.New + ": " + (e.Err?.Error() ?? "")
+	}
+
+	public Unwrap(): $.GoError {
+		const e = this
+		return e.Err
+	}
+}
+
+// Directory and file operation stubs
+export function Readlink(name: string): [string, $.GoError] {
+	return ["", ErrUnimplemented]
+}
+
+export function TempDir(): string {
+	return "/tmp"
+}
+
+export function UserCacheDir(): [string, $.GoError] {
+	return ["", ErrUnimplemented]
+}
+
+export function UserConfigDir(): [string, $.GoError] {
+	return ["", ErrUnimplemented]
+}
+
+export function UserHomeDir(): [string, $.GoError] {
+	return ["", ErrUnimplemented]
+} 

package/gs/os/file_js.gs.ts

@@ -0,0 +1,99 @@
+import * as $ from "@goscript/builtin/builtin.js";
+import { ErrUnimplemented } from "./error.gs.js";
+import { File } from "./types_js.gs.js";
+
+import * as fs from "@goscript/io/fs/index.js"
+
+// JavaScript-specific implementations for filesystem operations
+// These functions stub filesystem operations that cannot be implemented 
+// in a JavaScript environment
+
+// File operations - stub implementations
+export function Open(name: string): [File | null, $.GoError] {
+  return [null, ErrUnimplemented]
+}
+
+export function Create(name: string): [File | null, $.GoError] {
+  return [null, ErrUnimplemented]
+}
+
+export function OpenFile(name: string, flag: number, perm: number): [File | null, $.GoError] {
+  return [null, ErrUnimplemented]
+}
+
+export function ReadFile(name: string): [$.Bytes, $.GoError] {
+  return [null, ErrUnimplemented]
+}
+
+export function WriteFile(name: string, data: $.Bytes, perm: number): $.GoError {
+  return ErrUnimplemented
+}
+
+// Directory operations - stub implementations  
+export function Mkdir(name: string, perm: number): $.GoError {
+  return ErrUnimplemented
+}
+
+export function MkdirAll(path: string, perm: number): $.GoError {
+  return ErrUnimplemented
+}
+
+export function Remove(name: string): $.GoError {
+  return ErrUnimplemented
+}
+
+export function RemoveAll(path: string): $.GoError {
+  return ErrUnimplemented
+}
+
+export function Chdir(dir: string): $.GoError {
+  return ErrUnimplemented
+}
+
+export function Chmod(name: string, mode: number): $.GoError {
+  return ErrUnimplemented
+}
+
+export function Rename(oldpath: string, newpath: string): $.GoError {
+  return ErrUnimplemented
+}
+
+// File information operations - stub implementations
+export function Stat(name: string): [fs.FileInfo, $.GoError] {
+  return [null, ErrUnimplemented]
+}
+
+export function Lstat(name: string): [fs.FileInfo, $.GoError] {
+  return [null, ErrUnimplemented]
+}
+
+// Link operations - stub implementations  
+export function Link(oldname: string, newname: string): $.GoError {
+  return ErrUnimplemented
+}
+
+export function Symlink(oldname: string, newname: string): $.GoError {
+  return ErrUnimplemented
+}
+
+export function Readlink(name: string): [string, $.GoError] {
+  return ["", ErrUnimplemented]
+}
+
+export function Truncate(name: string, size: number): $.GoError {
+  return ErrUnimplemented
+}
+
+// File system information - stub implementations
+export function DirFS(dir: string): fs.FS {
+  // Return a stub filesystem that always returns ErrUnimplemented
+  return new stubFS()
+}
+
+class stubFS {
+  public Open(name: string): [fs.File, $.GoError] {
+    return [null, ErrUnimplemented]
+  }
+}
+
+ 

package/gs/os/file_open_unix.gs.ts

@@ -0,0 +1,15 @@
+import * as $ from "@goscript/builtin/builtin.js";
+import { ErrUnimplemented } from "./error.gs.js";
+
+import * as syscall from "@goscript/syscall/index.js"
+
+// Stub SysFile for JavaScript environment
+class SysFile {
+	constructor(init?: any) {}
+}
+
+export function open(path: string, flag: number, perm: number): [number, SysFile, $.GoError] {
+	let [fd, err] = syscall.Open(path, flag, perm)
+	return [fd, new SysFile({}), err]
+}
+

package/gs/os/file_posix_js.gs.ts

@@ -0,0 +1,40 @@
+import * as $ from "@goscript/builtin/builtin.js";
+import { ErrUnimplemented } from "./error.gs.js";
+
+// JavaScript-specific stubs for POSIX file operations
+// These operations are not available in JavaScript environments
+
+// syscallMode stub
+export function syscallMode(i: number): number {
+	return 0
+}
+
+// ignoringEINTR stub
+export function ignoringEINTR(fn: () => $.GoError): $.GoError {
+	return ErrUnimplemented
+}
+
+// ignoringEINTR2 stub
+export function ignoringEINTR2(fn: () => [string, $.GoError]): [string, $.GoError] {
+	return ["", ErrUnimplemented]
+}
+
+// Chmod operation stub
+export function Chmod(name: string, mode: number): $.GoError {
+	return ErrUnimplemented
+}
+
+// Chown operation stub
+export function Chown(name: string, uid: number, gid: number): $.GoError {
+	return ErrUnimplemented
+}
+
+// Lchown operation stub
+export function Lchown(name: string, uid: number, gid: number): $.GoError {
+	return ErrUnimplemented
+}
+
+// Chtimes operation stub
+export function Chtimes(name: string, atime: any, mtime: any): $.GoError {
+	return ErrUnimplemented
+} 

package/gs/os/file_unix_js.gs.ts

@@ -0,0 +1,94 @@
+import * as $ from "@goscript/builtin/builtin.js";
+import { ErrUnimplemented } from "./error.gs.js";
+import { File } from "./types_js.gs.js";
+
+import * as fs from "@goscript/io/fs/index.js"
+
+// JavaScript-specific implementations for Unix file operations
+// These functions stub Unix-specific operations that cannot be implemented in JavaScript
+
+// Device null path - stub for JavaScript
+export const DevNull = "/dev/null"
+
+// Stdin, Stdout, Stderr - stub implementations
+export const Stdin: File | null = null
+export const Stdout: File | null = null  
+export const Stderr: File | null = null
+
+// NewFile creates a File from a file descriptor - stub implementation
+export function NewFile(fd: number, name: string): File | null {
+	return null
+}
+
+// File operations that need to be stubbed
+export function Remove(name: string): $.GoError {
+	return ErrUnimplemented
+}
+
+export function Link(oldname: string, newname: string): $.GoError {
+	return ErrUnimplemented
+}
+
+export function Symlink(oldname: string, newname: string): $.GoError {
+	return ErrUnimplemented
+}
+
+export function Truncate(name: string, size: number): $.GoError {
+	return ErrUnimplemented
+}
+
+// Internal stub functions that may be referenced by other files
+export function rename(oldname: string, newname: string): $.GoError {
+	return ErrUnimplemented
+}
+
+export function openFileNolog(name: string, flag: number, perm: number): [File | null, $.GoError] {
+	return [null, ErrUnimplemented]
+}
+
+export function openDirNolog(name: string): [File | null, $.GoError] {
+	return [null, ErrUnimplemented]
+}
+
+export function tempDir(): string {
+	return "/tmp"
+}
+
+export function readlink(name: string): [string, $.GoError] {
+	return ["", ErrUnimplemented]
+}
+
+// File class methods that need to be stubbed for unix compatibility
+export function fixLongPath(path: string): string {
+	return path
+}
+
+export function sigpipe(): void {
+	// No-op in JavaScript
+}
+
+export function epipecheck(file: File | null, e: $.GoError): void {
+	// No-op in JavaScript  
+}
+
+// dirInfo stub for compatibility
+export interface dirInfo {
+	close(): void
+}
+
+// Network file creation stub  
+export function net_newUnixFile(fd: number, name: string): File | null {
+	return null
+}
+
+// File kind enum for compatibility
+export type newFileKind = number
+
+export function newFile(fd: number, name: string, kind: newFileKind, nonBlocking: boolean): File | null {
+	return null
+}
+
+// Directory entry stubs
+export function newUnixDirent(parent: string, name: string, typ: number): [fs.DirEntry | null, $.GoError] {
+	return [null, ErrUnimplemented]
+} 

package/gs/os/getwd_js.gs.ts

@@ -0,0 +1,28 @@
+import * as $ from "@goscript/builtin/builtin.js";
+
+import * as fs from "@goscript/io/fs/index.js"
+
+// JavaScript-specific implementation of Getwd
+// Working directories are not a concept in JavaScript environments
+// Store working directory in a global variable
+
+// Global working directory variable, defaults to test directory
+let currentWorkingDir: string = "/"
+
+export function Getwd(): [string, $.GoError] {
+	return [currentWorkingDir, null]
+}
+
+// Set the working directory (for internal use)
+export function setWorkingDir(dir: string): void {
+	currentWorkingDir = dir
+}
+
+// Additional functions that may be imported by other files
+export function statNolog(name: string): [fs.FileInfo | null, $.GoError] {
+	return [null, fs.ErrNotExist]
+}
+
+export function lstatNolog(name: string): [fs.FileInfo | null, $.GoError] {
+	return [null, fs.ErrNotExist]
+} 

package/gs/os/index.ts

@@ -0,0 +1,19 @@
+export { CopyFS, ReadDir } from "./dir.gs.js"
+export { Clearenv, Environ, Expand, ExpandEnv, Getenv, LookupEnv, Setenv, Unsetenv } from "./env.gs.js"
+export { ErrClosed, ErrDeadlineExceeded, ErrExist, ErrInvalid, ErrNoDeadline, ErrNotExist, ErrPermission, ErrUnimplemented, IsExist, IsNotExist, IsPermission, IsTimeout, NewSyscallError, PathError, SyscallError } from "./error.gs.js"
+export { ErrProcessDone, FindProcess, Getpid, Getppid, ProcAttr, Process, Signal, StartProcess } from "./exec.gs.js"
+export { Interrupt, Kill, ProcessState } from "./exec_posix.gs.js"
+export { Executable } from "./executable.gs.js"
+export { Chdir, Chmod, Create, DirFS, Mkdir, Open, OpenFile, ReadFile, Rename, WriteFile, MkdirAll, RemoveAll } from "./file_js.gs.js"
+export { LinkError, O_APPEND, O_CREATE, O_EXCL, O_RDONLY, O_RDWR, O_SYNC, O_TRUNC, O_WRONLY, Readlink, SEEK_CUR, SEEK_END, SEEK_SET, TempDir, UserCacheDir, UserConfigDir, UserHomeDir } from "./file_constants_js.gs.js"
+export { DevNull, Link, NewFile, Remove, Stderr, Stdin, Stdout, Symlink, Truncate } from "./file_unix_js.gs.js"
+export { Chown, Chtimes, Lchown } from "./file_posix_js.gs.js"
+export { Getwd } from "./getwd_js.gs.js"
+export { IsPathSeparator, PathListSeparator, PathSeparator } from "./path_unix.gs.js"
+export { Pipe } from "./pipe_wasm.gs.js"
+export { Args, Exit, Getegid, Geteuid, Getgid, Getgroups, Getuid } from "./proc.gs.js"
+export { OpenInRoot, OpenRoot, Root } from "./root_js.gs.js"
+export { Lstat, Stat } from "./stat_js.gs.js"
+export { Hostname } from "./sys.gs.js"
+export { CreateTemp, MkdirTemp } from "./tempfile.gs.js"
+export { DirEntry, File, FileInfo, FileMode, Getpagesize, ModeAppend, ModeCharDevice, ModeDevice, ModeDir, ModeExclusive, ModeIrregular, ModeNamedPipe, ModePerm, ModeSetgid, ModeSetuid, ModeSocket, ModeSticky, ModeSymlink, ModeTemporary, ModeType, SameFile } from "./types_js.gs.js"

package/gs/os/path.gs.ts

@@ -0,0 +1,35 @@
+import * as $ from "@goscript/builtin/builtin.js";
+import { ErrUnimplemented } from "./error.gs.js";
+import { IsPathSeparator } from "./path_unix.gs.js";
+
+// MkdirAll creates a directory named path,
+// along with any necessary parents, and returns nil,
+// or else returns an error.
+// The permission bits perm (before umask) are used for all
+// directories that MkdirAll creates.
+// If path is already a directory, MkdirAll does nothing
+// and returns nil.
+export function MkdirAll(path: string, perm: number): $.GoError {
+	return ErrUnimplemented
+}
+
+// RemoveAll removes path and any children it contains.
+// It removes everything it can but returns the first error
+// it encounters. If the path does not exist, RemoveAll
+// returns nil (no error).
+// If there is an error, it will be of type [*PathError].
+export function RemoveAll(path: string): $.GoError {
+	return ErrUnimplemented
+}
+
+// endsWithDot reports whether the final component of path is ".".
+export function endsWithDot(path: string): boolean {
+	if (path == ".") {
+		return true
+	}
+	if ($.len(path) >= 2 && $.indexString(path, $.len(path) - 1) == 46 && IsPathSeparator($.indexString(path, $.len(path) - 2))) {
+		return true
+	}
+	return false
+}
+

package/gs/os/path_unix.gs.ts

@@ -0,0 +1,49 @@
+import * as $ from "@goscript/builtin/builtin.js";
+
+// OS-specific path separator
+export let PathSeparator: number = 47
+
+// OS-specific path list separator
+export let PathListSeparator: number = 58
+
+// IsPathSeparator reports whether c is a directory separator character.
+export function IsPathSeparator(c: number): boolean {
+	return 47 == c
+}
+
+// splitPath returns the base name and parent directory.
+export function splitPath(path: string): [string, string] {
+	// if no better parent is found, the path is relative from "here"
+	let dirname = "."
+
+	// Remove all but one leading slash.
+	for (; $.len(path) > 1 && $.indexString(path, 0) == 47 && $.indexString(path, 1) == 47; ) {
+		path = $.sliceString(path, 1, undefined)
+	}
+
+	let i = $.len(path) - 1
+
+	// Remove trailing slashes.
+	for (; i > 0 && $.indexString(path, i) == 47; i--) {
+		path = $.sliceString(path, undefined, i)
+	}
+
+	// if no slashes in path, base is path
+	let basename = path
+
+	// Remove leading directory path
+	for (i--; i >= 0; i--) {
+		if ($.indexString(path, i) == 47) {
+			if (i == 0) {
+				dirname = $.sliceString(path, undefined, 1)
+			} else {
+				dirname = $.sliceString(path, undefined, i)
+			}
+			basename = $.sliceString(path, i + 1, undefined)
+			break
+		}
+	}
+
+	return [dirname, basename]
+}
+

package/gs/os/pidfd_js.gs.ts

@@ -0,0 +1,25 @@
+import * as $ from "@goscript/builtin/builtin.js";
+import { ErrUnimplemented } from "./error.gs.js";
+
+// JavaScript-specific stubs for pidfd operations
+// These operations are Linux-specific and not available in JavaScript
+
+// SysProcAttr stub for compatibility
+export interface SysProcAttr {
+	// Stub interface for process attributes
+}
+
+// ensurePidfd ensures pidfd support - stub implementation
+export function ensurePidfd(sysAttr: SysProcAttr | null): [SysProcAttr | null, boolean] {
+	return [null, false]
+}
+
+// getPidfd gets a process file descriptor - stub implementation  
+export function getPidfd(_: SysProcAttr | null, _usePidfd: boolean): [number, boolean] {
+	return [0, false]
+}
+
+// pidfdFind finds a process by pidfd - stub implementation
+export function pidfdFind(_: number): [number, $.GoError] {
+	return [0, ErrUnimplemented]
+} 

package/gs/os/pipe_wasm.gs.ts

@@ -0,0 +1,17 @@
+import * as $ from "@goscript/builtin/builtin.js";
+import { NewSyscallError } from "./error.gs.js";
+
+import * as syscall from "@goscript/syscall/index.js"
+
+// Pipe returns a connected pair of Files; reads from r return bytes written to w.
+// It returns the files and an error, if any.
+export function Pipe(): [File | null, File | null, $.GoError] {
+	let r: File | null = null
+	let w: File | null = null
+	let err: $.GoError = null
+	{
+		// Neither GOOS=js nor GOOS=wasip1 have pipes.
+		return [null, null, NewSyscallError("pipe", syscall.ENOSYS)]
+	}
+}
+