goscript 0.1.0 → 0.1.1

package/gs/sync/atomic/type.gs.ts

@@ -4,6 +4,8 @@ import { AddInt64, AddUint64, AndInt64, AndUint64, CompareAndSwapInt64, CompareA
 
 import * as unsafe from "@goscript/unsafe/index.js"
 
+export type PointerValue<T> = T | $.VarRef<T> | null
+
 export class Bool {
 	public get v(): number {
 		return this._fields.v.value
@@ -74,18 +76,18 @@ export function b32(b: boolean): number {
 
 
 export class Pointer<T> {
-	public get v(): $.VarRef<T> | null {
+	public get v(): PointerValue<T> {
 		return this._fields.v.value
 	}
-	public set v(value: $.VarRef<T> | null) {
+	public set v(value: PointerValue<T>) {
 		this._fields.v.value = value
 	}
 
 	public _fields: {
-		v: $.VarRef<$.VarRef<T> | null>;
+		v: $.VarRef<PointerValue<T>>;
 	}
 
-	constructor(init?: Partial<{v?: $.VarRef<T> | null}>) {
+	constructor(init?: Partial<{v?: PointerValue<T>}>) {
 		this._fields = {
 			v: $.varRef(init?.v ?? null)
 		}
@@ -100,14 +102,13 @@ export class Pointer<T> {
 	}
 
 	// Load atomically loads and returns the value stored in x.
-	public Load(): $.VarRef<T> | null {
+	public Load(): PointerValue<T> {
 		const x = this
-		return LoadPointer(x._fields.v) as $.VarRef<T> | null
+		return LoadPointer(x._fields.v) as PointerValue<T>
 	}
 
 	// Store atomically stores val into x.
-	// In Go, this takes *T which can be nil, so we accept VarRef<T> | null
-	public Store(val: $.VarRef<T> | null): void {
+	public Store(val: PointerValue<T>): void {
 		const x = this
 		if (val === null) {
 			StorePointer(x._fields.v, null)
@@ -117,17 +118,16 @@ export class Pointer<T> {
 	}
 
 	// Swap atomically stores new into x and returns the previous value.
-	// In Go, this takes *T which can be nil, so we accept VarRef<T> | null
-	public Swap(_new: $.VarRef<T> | null): $.VarRef<T> | null {
+	public Swap(_new: PointerValue<T>): PointerValue<T> {
 		const x = this
 		if (_new === null) {
-			return SwapPointer(x._fields.v, null) as $.VarRef<T> | null
+			return SwapPointer(x._fields.v, null) as PointerValue<T>
 		}
-		return SwapPointer(x._fields.v, unsafe.Pointer(_new)) as $.VarRef<T> | null
+		return SwapPointer(x._fields.v, unsafe.Pointer(_new)) as PointerValue<T>
 	}
 
 	// CompareAndSwap executes the compare-and-swap operation for x.
-	public CompareAndSwap(old: $.VarRef<T> | null, _new: $.VarRef<T> | null): boolean {
+	public CompareAndSwap(old: PointerValue<T>, _new: PointerValue<T>): boolean {
 		const x = this
 		return CompareAndSwapPointer(x._fields.v, old ? unsafe.Pointer(old) : null, _new ? unsafe.Pointer(_new) : null)
 	}
@@ -598,4 +598,3 @@ class align64 {
 	  {}
 	);
 }
-

package/gs/sync/meta.json

@@ -9,11 +9,13 @@
     "WaitGroup.Wait": true,
     "Once.Do": true,
     "Cond.Wait": true,
+    "Map.CompareAndDelete": true,
     "Map.Delete": true,
     "Map.Load": true,
     "Map.LoadAndDelete": true,
     "Map.LoadOrStore": true,
     "Map.Range": true,
-    "Map.Store": true
+    "Map.Store": true,
+    "Map.Swap": true
   }
 }

package/gs/sync/sync.test.ts

@@ -1,6 +1,6 @@
 import { describe, expect, it } from 'vitest'
 
-import { WaitGroup } from './sync.js'
+import { Map, WaitGroup } from './sync.js'
 
 describe('sync.WaitGroup', () => {
   it('Go tracks scheduled work and unblocks Wait after completion', async () => {
@@ -22,3 +22,15 @@ describe('sync.WaitGroup', () => {
     expect(events).toEqual(['worker start', 'worker done', 'wait done'])
   })
 })
+
+describe('sync.Map', () => {
+  it('CompareAndDelete deletes only matching entries', async () => {
+    const m = new Map()
+
+    await m.Store('key', 'value')
+    expect(await m.CompareAndDelete('key', 'other')).toBe(false)
+    expect(await m.Load('key')).toEqual(['value', true])
+    expect(await m.CompareAndDelete('key', 'value')).toBe(true)
+    expect(await m.Load('key')).toEqual([undefined, false])
+  })
+})

package/gs/sync/sync.ts

@@ -321,6 +321,20 @@ export class Map {
     }
   }
 
+  // CompareAndDelete deletes the entry for key if its value is equal to old.
+  public async CompareAndDelete(key: any, old: any): Promise<boolean> {
+    await this._m.Lock()
+    try {
+      if (!this._data.has(key) || this._data.get(key) !== old) {
+        return false
+      }
+      this._data.delete(key)
+      return true
+    } finally {
+      this._m.Unlock()
+    }
+  }
+
   // Load returns the value stored in the map for a key, or nil if no value is present
   public async Load(key: any): Promise<[any, boolean]> {
     await this._m.RLock()
@@ -383,6 +397,19 @@ export class Map {
     }
   }
 
+  // Swap swaps the value for a key and returns the previous value if any
+  public async Swap(key: any, value: any): Promise<[any, boolean]> {
+    await this._m.Lock()
+    try {
+      const previous = this._data.get(key)
+      const loaded = this._data.has(key)
+      this._data.set(key, value)
+      return [previous, loaded]
+    } finally {
+      this._m.Unlock()
+    }
+  }
+
   // clone returns a copy of this Map instance
   public clone(): Map {
     return new Map()

package/gs/syscall/constants.ts

@@ -1,29 +1,44 @@
 // 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 O_RDONLY: number = 0
+export const O_WRONLY: number = 1
+export const O_RDWR: number = 2
+export const O_APPEND: number = 8
+export const O_CREATE: number = 64
+export const O_EXCL: number = 128
+export const O_SYNC: number = 256
+export const O_TRUNC: number = 512
 
-export const Stdin = 0
-export const Stdout = 1
-export const Stderr = 2
+export const Stdin: number = 0
+export const Stdout: number = 1
+export const Stderr: number = 2
 
-export const SIGINT = 2
-export const SIGTERM = 15
+export const SIGINT: number = 2
+export const SIGTERM: number = 15
+
+export const AF_UNIX: number = 1
+export const AF_INET: number = 2
+export const AF_INET6: number = 10
+
+export const SOCK_STREAM: number = 1
+export const SOCK_DGRAM: number = 2
+export const SOCK_RAW: number = 3
+export const SOCK_SEQPACKET: number = 5
+
+export const IPPROTO_IPV6: number = 0x29
+export const IPPROTO_TCP: number = 6
+export const IPV6_V6ONLY: number = 0x1a
+export const SOMAXCONN: number = 0x80
+export const F_DUPFD_CLOEXEC: number = 1
 
 // 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
+export const S_IFMT: number = 0o170000
+export const S_IFREG: number = 0o100000
+export const S_IFDIR: number = 0o040000
+export const S_IFLNK: number = 0o120000
+export const S_IFBLK: number = 0o060000
+export const S_IFCHR: number = 0o020000
+export const S_IFIFO: number = 0o010000
+export const S_IFSOCK: number = 0o140000
+export const S_ISUID: number = 0o004000
+export const S_ISGID: number = 0o002000
+export const S_ISVTX: number = 0o001000

package/gs/syscall/errors.ts

@@ -1,6 +1,10 @@
 import * as $ from '@goscript/builtin/index.js'
 import { Errno } from './types.js'
 
+export function Errno_Error(errno: Errno): string {
+  return errno.Error()
+}
+
 export const EPERM: Errno = {
   Error: () => 'operation not permitted',
   Is: (target: $.GoError) => target === EPERM,
@@ -217,6 +221,12 @@ export const ENOSYS: Errno = {
   Errno: () => 38,
 }
 
+export const ENOTSUP: Errno = {
+  Error: () => 'operation not supported',
+  Is: (target: $.GoError) => target === ENOTSUP,
+  Errno: () => 95,
+}
+
 export const ENOTEMPTY: Errno = {
   Error: () => 'directory not empty',
   Is: (target: $.GoError) => target === ENOTEMPTY,

package/gs/syscall/fs.ts

@@ -1,5 +1,7 @@
 import * as $ from '@goscript/builtin/index.js'
+import { RWMutex } from '@goscript/sync/index.js'
 import { ENOSYS } from './errors.js'
+import type { Iovec, Sockaddr } from './types.js'
 
 // Dirent structure with Reclen field
 export class Dirent {
@@ -54,9 +56,202 @@ export function Sysctl(_name: string): [string, $.GoError] {
   return ['', ENOSYS]
 }
 
+export function Unlink(_path: string): $.GoError {
+  return ENOSYS
+}
+
+export const ForkLock = new RWMutex()
+
+export function Close(_fd: number): $.GoError {
+  return null
+}
+
+export function CloseOnExec(_fd: number): void {}
+
+export function SetNonblock(_fd: number, _nonblocking: boolean): $.GoError {
+  return null
+}
+
+export function Fchdir(_fd: number): $.GoError {
+  return ENOSYS
+}
+
+export function Fchmod(_fd: number, _mode: number): $.GoError {
+  return ENOSYS
+}
+
+export function Fchown(_fd: number, _uid: number, _gid: number): $.GoError {
+  return ENOSYS
+}
+
+export function Fstat(
+  _fd: number,
+  _stat: Stat_t | $.VarRef<Stat_t> | null,
+): $.GoError {
+  return ENOSYS
+}
+
+export function Fsync(_fd: number): $.GoError {
+  return ENOSYS
+}
+
+export function Ftruncate(_fd: number, _length: number): $.GoError {
+  return ENOSYS
+}
+
+export function Read(_fd: number, _b: $.Bytes | null): [number, $.GoError] {
+  return [0, ENOSYS]
+}
+
+export function ReadDirent(
+  _fd: number,
+  _buf: $.Bytes | null,
+): [number, $.GoError] {
+  return [0, ENOSYS]
+}
+
+export function Pread(
+  _fd: number,
+  _b: $.Bytes | null,
+  _offset: number,
+): [number, $.GoError] {
+  return [0, ENOSYS]
+}
+
+export function Pwrite(
+  _fd: number,
+  _b: $.Bytes | null,
+  _offset: number,
+): [number, $.GoError] {
+  return [0, ENOSYS]
+}
+
+export function Seek(
+  _fd: number,
+  _offset: number,
+  _whence: number,
+): [number, $.GoError] {
+  return [0, ENOSYS]
+}
+
+export function Write(_fd: number, _b: $.Bytes | null): [number, $.GoError] {
+  return [0, ENOSYS]
+}
+
+export function Dup(_fd: number): [number, $.GoError] {
+  return [0, 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
 }
+
+export function Socket(
+  _domain: number,
+  _typ: number,
+  _proto: number,
+): [number, $.GoError] {
+  return [-1, ENOSYS]
+}
+
+export function Connect(_fd: number, _sa: Sockaddr | null): $.GoError {
+  return ENOSYS
+}
+
+export function Listen(_fd: number, _backlog: number): $.GoError {
+  return ENOSYS
+}
+
+export function Bind(_fd: number, _sa: Sockaddr | null): $.GoError {
+  return ENOSYS
+}
+
+export function StopIO(_fd: number): $.GoError {
+  return ENOSYS
+}
+
+export function Accept(_fd: number): [number, Sockaddr | null, $.GoError] {
+  return [0, null, ENOSYS]
+}
+
+export function Recvfrom(
+  _fd: number,
+  _p: $.Bytes | null,
+  _flags: number,
+): [number, Sockaddr | null, $.GoError] {
+  return [0, null, ENOSYS]
+}
+
+export function Sendto(
+  _fd: number,
+  _p: $.Bytes | null,
+  _flags: number,
+  _to: Sockaddr | null,
+): $.GoError {
+  return ENOSYS
+}
+
+export function Recvmsg(
+  _fd: number,
+  _p: $.Bytes | null,
+  _oob: $.Bytes | null,
+  _flags: number,
+): [number, number, number, Sockaddr | null, $.GoError] {
+  return [0, 0, 0, null, ENOSYS]
+}
+
+export function SendmsgN(
+  _fd: number,
+  _p: $.Bytes | null,
+  _oob: $.Bytes | null,
+  _to: Sockaddr | null,
+  _flags: number,
+): [number, $.GoError] {
+  return [0, ENOSYS]
+}
+
+export function SetReadDeadline(_fd: number, _t: number): $.GoError {
+  return ENOSYS
+}
+
+export function SetWriteDeadline(_fd: number, _t: number): $.GoError {
+  return ENOSYS
+}
+
+export function Shutdown(_fd: number, _how: number): $.GoError {
+  return ENOSYS
+}
+
+export function GetsockoptInt(
+  _fd: number,
+  _level: number,
+  _opt: number,
+): [number, $.GoError] {
+  return [0, ENOSYS]
+}
+
+export function SetsockoptInt(
+  _fd: number,
+  _level: number,
+  _opt: number,
+  _value: number,
+): $.GoError {
+  return null
+}
+
+export function readv(_fd: number, _iovecs: $.Slice<Iovec> | null): [
+  number,
+  $.GoError,
+] {
+  return [0, ENOSYS]
+}
+
+export function writev(_fd: number, _iovecs: $.Slice<Iovec> | null): [
+  number,
+  $.GoError,
+] {
+  return [0, ENOSYS]
+}