goscript 0.0.35 → 0.0.37

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

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