goscript 0.0.36 → 0.0.37

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
+

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" } }
+	);
+}
+