goscript 0.0.35 → 0.0.37

package/gs/sync/atomic/value.gs.ts

@@ -0,0 +1,158 @@
+import * as $ from "@goscript/builtin/builtin.js";
+import { CompareAndSwapPointer, LoadPointer, StorePointer, SwapPointer } from "./doc.gs.js";
+
+import * as unsafe from "@goscript/unsafe/index.js"
+
+// Pointer type for use in efaceWords
+type Pointer = any;
+
+// firstStoreInProgress is a placeholder value used during the first store operation
+const firstStoreInProgress = Symbol('firstStoreInProgress');
+
+export class Value {
+	public get v(): null | any {
+		return this._fields.v.value
+	}
+	public set v(value: null | any) {
+		this._fields.v.value = value
+	}
+
+	public _fields: {
+		v: $.VarRef<null | any>;
+	}
+
+	constructor(init?: Partial<{v?: null | any}>) {
+		this._fields = {
+			v: $.varRef(init?.v ?? null)
+		}
+	}
+
+	public clone(): Value {
+		const cloned = new Value()
+		cloned._fields = {
+			v: $.varRef(this._fields.v.value)
+		}
+		return cloned
+	}
+
+	// Load returns the value set by the most recent Store.
+	// It returns nil if there has been no call to Store for this Value.
+	public Load(): null | any {
+		const v = this
+		// For JavaScript, we can simplify this since we're single-threaded
+		// Just return the stored value directly
+		return v._fields.v.value
+	}
+
+	// Store sets the value of the [Value] v to val.
+	// All calls to Store for a given Value must use values of the same concrete type.
+	// Store of an inconsistent type panics, as does Store(nil).
+	public Store(val: null | any): void {
+		const v = this
+		if (val == null) {
+			$.panic("sync/atomic: store of nil value into Value")
+		}
+		// For JavaScript, store the value directly
+		v._fields.v.value = val
+	}
+
+	// Swap stores new into Value and returns the previous value. It returns nil if
+	// the Value is empty.
+	//
+	// All calls to Swap for a given Value must use values of the same concrete
+	// type. Swap of an inconsistent type panics, as does Swap(nil).
+	public Swap(_new: null | any): null | any {
+		const v = this
+		if (_new == null) {
+			$.panic("sync/atomic: swap of nil value into Value")
+		}
+		// For JavaScript, swap the values directly
+		const old = v._fields.v.value
+		v._fields.v.value = _new
+		return old
+	}
+
+	// CompareAndSwap executes the compare-and-swap operation for the [Value].
+	//
+	// All calls to CompareAndSwap for a given Value must use values of the same
+	// concrete type. CompareAndSwap of an inconsistent type panics, as does
+	// CompareAndSwap(old, nil).
+	public CompareAndSwap(old: null | any, _new: null | any): boolean {
+		const v = this
+		if (_new == null) {
+			$.panic("sync/atomic: compare and swap of nil value into Value")
+		}
+		// For JavaScript, compare and swap directly
+		if (v._fields.v.value === old) {
+			v._fields.v.value = _new
+			return true
+		}
+		return false
+	}
+
+	// Register this type with the runtime type system
+	static __typeInfo = $.registerStructType(
+	  'Value',
+	  new Value(),
+	  [{ name: "Load", args: [], returns: [{ type: { kind: $.TypeKind.Interface, methods: [] } }] }, { name: "Store", args: [{ name: "val", type: { kind: $.TypeKind.Interface, methods: [] } }], returns: [] }, { name: "Swap", args: [{ name: "new", type: { kind: $.TypeKind.Interface, methods: [] } }], returns: [{ type: { kind: $.TypeKind.Interface, methods: [] } }] }, { name: "CompareAndSwap", args: [{ name: "old", type: { kind: $.TypeKind.Interface, methods: [] } }, { name: "new", type: { kind: $.TypeKind.Interface, methods: [] } }], returns: [{ type: { kind: $.TypeKind.Basic, name: "boolean" } }] }],
+	  Value,
+	  {"v": { kind: $.TypeKind.Interface, methods: [] }}
+	);
+}
+
+
+class efaceWords {
+	public get typ(): Pointer {
+		return this._fields.typ.value
+	}
+	public set typ(value: Pointer) {
+		this._fields.typ.value = value
+	}
+
+	public get data(): Pointer {
+		return this._fields.data.value
+	}
+	public set data(value: Pointer) {
+		this._fields.data.value = value
+	}
+
+	public _fields: {
+		typ: $.VarRef<Pointer>;
+		data: $.VarRef<Pointer>;
+	}
+
+	constructor(init?: Partial<{data?: Pointer, typ?: Pointer}>) {
+		this._fields = {
+			typ: $.varRef(init?.typ ?? null),
+			data: $.varRef(init?.data ?? null)
+		}
+	}
+
+	public clone(): efaceWords {
+		const cloned = new efaceWords()
+		cloned._fields = {
+			typ: $.varRef(this._fields.typ.value),
+			data: $.varRef(this._fields.data.value)
+		}
+		return cloned
+	}
+
+	// Register this type with the runtime type system
+	static __typeInfo = $.registerStructType(
+	  'efaceWords',
+	  new efaceWords(),
+	  [],
+	  efaceWords,
+	  {"data": { kind: $.TypeKind.Basic, name: "Pointer" }, "typ": { kind: $.TypeKind.Basic, name: "Pointer" }}
+	);
+}
+
+// Runtime functions for pinning/unpinning (no-ops in JavaScript)
+export function runtime_procPin(): number {
+	return 0; // No-op in JavaScript
+}
+
+export function runtime_procUnpin(): void {
+	// No-op in JavaScript
+}
+

package/gs/syscall/index.ts

@@ -0,0 +1,204 @@
+import * as $ from "@goscript/builtin/builtin.js";
+
+// Essential type aliases
+export type uintptr = number
+
+// Errno type for syscall errors
+export interface Errno {
+  Error(): string
+  Is(target: $.GoError): boolean
+  Errno(): number
+}
+
+// Essential syscall constants
+export const O_RDONLY = 0
+export const O_WRONLY = 1
+export const O_RDWR = 2
+export const O_APPEND = 8
+export const O_CREATE = 64
+export const O_EXCL = 128
+export const O_SYNC = 256
+export const O_TRUNC = 512
+
+export const Stdin = 0
+export const Stdout = 1
+export const Stderr = 2
+
+export const SIGINT = 2
+export const SIGTERM = 15
+
+// File mode constants  
+export const S_IFMT = 0o170000
+export const S_IFREG = 0o100000
+export const S_IFDIR = 0o040000
+export const S_IFLNK = 0o120000
+export const S_IFBLK = 0o060000
+export const S_IFCHR = 0o020000
+export const S_IFIFO = 0o010000
+export const S_IFSOCK = 0o140000
+export const S_ISUID = 0o004000
+export const S_ISGID = 0o002000
+export const S_ISVTX = 0o001000
+
+// Environment variable functions using Node.js/browser APIs
+export function Getenv(key: string): [string, boolean] {
+  if (typeof process !== 'undefined' && process.env) {
+    const value = process.env[key]
+    return value !== undefined ? [value, true] : ["", false]
+  }
+  return ["", false]
+}
+
+export function Setenv(key: string, value: string): $.GoError {
+  if (typeof process !== 'undefined' && process.env) {
+    process.env[key] = value
+    return null
+  }
+  return { Error: () => "setenv not supported" }
+}
+
+export function Unsetenv(key: string): $.GoError {
+  if (typeof process !== 'undefined' && process.env) {
+    delete process.env[key]
+    return null
+  }
+  return { Error: () => "unsetenv not supported" }
+}
+
+export function Clearenv(): void {
+  if (typeof process !== 'undefined' && process.env) {
+    for (const key in process.env) {
+      delete process.env[key]
+    }
+  }
+}
+
+export function Environ(): $.Slice<string> {
+  if (typeof process !== 'undefined' && process.env) {
+    const env: string[] = []
+    for (const [key, value] of Object.entries(process.env)) {
+      if (value !== undefined) {
+        env.push(`${key}=${value}`)
+      }
+    }
+    return $.arrayToSlice(env)
+  }
+  return $.arrayToSlice([])
+}
+
+// Dirent structure with Reclen field
+export class Dirent {
+  public Name: $.Bytes = new Uint8Array(0)
+  public Reclen: number = 0
+  constructor(init?: any) {
+    if (init?.Name) this.Name = init.Name
+    if (init?.Reclen) this.Reclen = init.Reclen
+  }
+}
+
+// Stat_t structure stub  
+export class Stat_t {
+  public Dev: number = 0
+  public Ino: number = 0  
+  public Mode: number = 0
+  public Nlink: number = 0
+  public Uid: number = 0
+  public Gid: number = 0
+  public Rdev: number = 0
+  public Size: number = 0
+  public Blksize: number = 0
+  public Blocks: number = 0
+  public Atime: number = 0
+  public Mtime: number = 0
+  public Ctime: number = 0
+  public AtimeNsec: number = 0
+  public MtimeNsec: number = 0
+  public CtimeNsec: number = 0
+  
+  constructor(init?: any) {
+    if (init) {
+      Object.assign(this, init)
+    }
+  }
+  
+  public clone(): Stat_t {
+    return new Stat_t(this)
+  }
+}
+
+// RawConn interface - stub implementation for JavaScript environment
+export interface RawConn {
+  Control(f: (fd: uintptr) => void): $.GoError
+  Read(f: (fd: uintptr) => boolean): $.GoError  
+  Write(f: (fd: uintptr) => boolean): $.GoError
+}
+
+// Stub implementation of RawConn that always returns ErrUnimplemented
+export class StubRawConn implements RawConn {
+  Control(f: (fd: uintptr) => void): $.GoError {
+    return { Error: () => "operation not implemented in JavaScript environment" }
+  }
+  
+  Read(f: (fd: uintptr) => boolean): $.GoError {
+    return { Error: () => "operation not implemented in JavaScript environment" }
+  }
+  
+  Write(f: (fd: uintptr) => boolean): $.GoError {
+    return { Error: () => "operation not implemented in JavaScript environment" }
+  }
+}
+
+// Additional error constants - implement as Errno type
+export const ENOSYS: Errno = {
+  Error: () => "function not implemented",
+  Is: (target: $.GoError) => target === ENOSYS,
+  Errno: () => 38
+}
+
+export const EISDIR: Errno = {
+  Error: () => "is a directory", 
+  Is: (target: $.GoError) => target === EISDIR,
+  Errno: () => 21
+}
+
+export const ENOTDIR: Errno = {
+  Error: () => "not a directory",
+  Is: (target: $.GoError) => target === ENOTDIR,
+  Errno: () => 20
+}
+
+export const ERANGE: Errno = {
+  Error: () => "result too large",
+  Is: (target: $.GoError) => target === ERANGE,
+  Errno: () => 34
+}
+
+export const ENOMEM: Errno = {
+  Error: () => "out of memory",
+  Is: (target: $.GoError) => target === ENOMEM,
+  Errno: () => 12
+}
+
+export const ESRCH: Errno = {
+  Error: () => "no such process",
+  Is: (target: $.GoError) => target === ESRCH,
+  Errno: () => 3
+}
+
+// Additional missing syscall functions
+export function Open(path: string, flag: number, perm: number): [number, $.GoError] {
+  return [-1, ENOSYS]
+}
+
+export function Sysctl(name: string): [string, $.GoError] {
+  return ["", ENOSYS]
+}
+
+
+
+// Getpagesize returns the underlying system's memory page size.
+export function Getpagesize(): number {
+  // Return a standard page size for JavaScript environment
+  // Most systems use 4096 bytes as the default page size
+  return 4096
+} 

package/gs/unsafe/unsafe.ts

@@ -75,3 +75,9 @@ export function StringData(_str: string): Pointer {
     'unsafe.StringData is not supported in JavaScript/TypeScript: direct memory access is not available in JavaScript',
   )
 }
+
+// Pointer converts a value to an unsafe.Pointer for atomic operations
+// In JavaScript/TypeScript, this is just a pass-through function
+export function Pointer(value: any): Pointer {
+  return value;
+}

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "goscript",
   "description": "Go to TypeScript transpiler",
-  "version": "0.0.35",
+  "version": "0.0.37",
   "author": {
     "name": "Aperture Robotics LLC.",
     "email": "support@aperture.us",