goscript 0.1.0 → 0.1.2

package/gs/strings/replace.ts

@@ -396,12 +396,12 @@ class trieNode {
         // what is currently t.prefix[0] will lead to prefixNode, and
         // looking up key[0] will lead to keyNode.
         const prefixNode =
-          $.len(t!.prefix) == 1
-            ? t!.next
-            : new trieNode({
-                next: t!.next,
-                prefix: $.sliceString(t!.prefix, 1, undefined),
-              })
+          $.len(t!.prefix) == 1 ?
+            t!.next
+          : new trieNode({
+              next: t!.next,
+              prefix: $.sliceString(t!.prefix, 1, undefined),
+            })
         let keyNode = new trieNode()
         t!.table = $.makeSlice<trieNode | null>(r!.tableSize)
         t!.table![r!.mapping![$.indexString(t!.prefix, 0)]] = prefixNode

package/gs/strings/strings.test.ts

@@ -203,6 +203,7 @@ describe('strings', () => {
       expect(Index('hello world', 'xyz')).toBe(-1)
       expect(Index('hello', 'hello')).toBe(0)
       expect(Index('', '')).toBe(0)
+      expect(Index('世界,你好', ',')).toBe(6)
     })
   })
 
@@ -219,6 +220,7 @@ describe('strings', () => {
       expect(IndexByte('hello', 101)).toBe(1) // 'e'
       expect(IndexByte('hello', 120)).toBe(-1) // 'x'
       expect(IndexByte('', 97)).toBe(-1) // 'a'
+      expect(IndexByte('世界,你好', 44)).toBe(6)
     })
   })
 
@@ -257,6 +259,7 @@ describe('strings', () => {
       expect(LastIndex('hello world hello', 'hello')).toBe(12)
       expect(LastIndex('hello world', 'xyz')).toBe(-1)
       expect(LastIndex('hello', 'hello')).toBe(0)
+      expect(LastIndex('世界,你好', '你好')).toBe(7)
     })
   })
 
@@ -273,6 +276,7 @@ describe('strings', () => {
       expect(LastIndexByte('hello', 108)).toBe(3) // 'l'
       expect(LastIndexByte('hello', 120)).toBe(-1) // 'x'
       expect(LastIndexByte('', 97)).toBe(-1) // 'a'
+      expect(LastIndexByte('世界,你好', 44)).toBe(6)
     })
   })
 

package/gs/strings/strings.ts

@@ -56,18 +56,31 @@ export function ContainsFunc(
 
 // Index returns the index of the first instance of substr in s, or -1 if substr is not present in s.
 export function Index(s: string, substr: string): number {
-  return s.indexOf(substr)
+  if (substr === '') {
+    return 0
+  }
+  return indexBytes($.stringToBytes(s), $.stringToBytes(substr))
 }
 
 // LastIndex returns the index of the last instance of substr in s, or -1 if substr is not present in s.
 export function LastIndex(s: string, substr: string): number {
-  return s.lastIndexOf(substr)
+  const haystack = $.stringToBytes(s)
+  const needle = $.stringToBytes(substr)
+  if (needle.length === 0) {
+    return haystack.length
+  }
+  return lastIndexBytes(haystack, needle)
 }
 
 // IndexByte returns the index of the first instance of c in s, or -1 if c is not present in s.
 export function IndexByte(s: string, c: number): number {
-  const char = String.fromCharCode(c)
-  return s.indexOf(char)
+  const bytes = $.stringToBytes(s)
+  for (let i = 0; i < bytes.length; i++) {
+    if (bytes[i] === (c & 0xff)) {
+      return i
+    }
+  }
+  return -1
 }
 
 // IndexRune returns the index of the first instance of the Unicode code point r, or -1 if rune is not present in s.
@@ -98,8 +111,43 @@ export function LastIndexAny(s: string, chars: string): number {
 
 // LastIndexByte returns the index of the last instance of c in s, or -1 if c is not present in s.
 export function LastIndexByte(s: string, c: number): number {
-  const char = String.fromCharCode(c)
-  return s.lastIndexOf(char)
+  const bytes = $.stringToBytes(s)
+  for (let i = bytes.length - 1; i >= 0; i--) {
+    if (bytes[i] === (c & 0xff)) {
+      return i
+    }
+  }
+  return -1
+}
+
+function indexBytes(haystack: Uint8Array, needle: Uint8Array): number {
+  if (needle.length === 0) {
+    return 0
+  }
+  outer: for (let i = 0; i <= haystack.length - needle.length; i++) {
+    for (let j = 0; j < needle.length; j++) {
+      if (haystack[i + j] !== needle[j]) {
+        continue outer
+      }
+    }
+    return i
+  }
+  return -1
+}
+
+function lastIndexBytes(haystack: Uint8Array, needle: Uint8Array): number {
+  if (needle.length === 0) {
+    return haystack.length
+  }
+  outer: for (let i = haystack.length - needle.length; i >= 0; i--) {
+    for (let j = 0; j < needle.length; j++) {
+      if (haystack[i + j] !== needle[j]) {
+        continue outer
+      }
+    }
+    return i
+  }
+  return -1
 }
 
 // IndexFunc returns the index into s of the first Unicode code point satisfying f(c), or -1 if none do.

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 { Cond, Map, Mutex, RWMutex, WaitGroup } from './sync.js'
 
 describe('sync.WaitGroup', () => {
   it('Go tracks scheduled work and unblocks Wait after completion', async () => {
@@ -22,3 +22,71 @@ describe('sync.WaitGroup', () => {
     expect(events).toEqual(['worker start', 'worker done', 'wait done'])
   })
 })
+
+describe('sync.Cond', () => {
+  it('exposes the Locker as public field L', async () => {
+    const mutex = new Mutex()
+    const cond = new Cond(mutex)
+
+    expect(cond.L).toBe(mutex)
+    await cond.L.Lock()
+    cond.L.Unlock()
+  })
+})
+
+describe('sync.RWMutex', () => {
+  it('exposes RLocker as a read-lock Locker', async () => {
+    const rw = new RWMutex()
+    const locker = rw.RLocker()
+
+    await locker.Lock()
+    locker.Unlock()
+  })
+})
+
+describe('sync.Map', () => {
+  it('Clear deletes all entries', async () => {
+    const m = new Map()
+
+    await m.Store('first', 1)
+    await m.Store('second', 2)
+    await m.Clear()
+
+    expect(await m.Load('first')).toEqual([undefined, false])
+    expect(await m.Load('second')).toEqual([undefined, false])
+  })
+
+  it('CompareAndSwap swaps only matching entries', async () => {
+    const m = new Map()
+
+    await m.Store('key', 'value')
+    expect(await m.CompareAndSwap('key', 'other', 'next')).toBe(false)
+    expect(await m.Load('key')).toEqual(['value', true])
+    expect(await m.CompareAndSwap('key', 'value', 'next')).toBe(true)
+    expect(await m.Load('key')).toEqual(['next', true])
+  })
+
+  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])
+  })
+
+  it('Range accepts generated async-shaped callbacks', async () => {
+    const m = new Map()
+    const visited: string[] = []
+
+    await m.Store('a', 1)
+    await m.Store('b', 2)
+    await m.Range(async (key, value) => {
+      visited.push(`${key}:${value}`)
+      return key !== 'a'
+    })
+
+    expect(visited).toEqual(['a:1'])
+  })
+})

package/gs/sync/sync.ts

@@ -143,6 +143,15 @@ export class RWMutex {
     }
   }
 
+  // RLocker returns a Locker interface that implements Lock and Unlock by
+  // calling RLock and RUnlock.
+  public RLocker(): Locker {
+    return {
+      Lock: () => this.RLock(),
+      Unlock: () => this.RUnlock(),
+    }
+  }
+
   private _wakeUpWaiters(): void {
     // Prioritize writers
     if (this._writerWaitQueue.length > 0 && this._readers === 0) {
@@ -232,7 +241,7 @@ export class Once {
   }
 
   // Do calls the function f if and only if Do is being called for the first time for this instance of Once
-  public async Do(f: () => void): Promise<void> {
+  public async Do(f: () => void | Promise<void>): Promise<void> {
     if (this._done) {
       return
     }
@@ -240,7 +249,7 @@ export class Once {
     await this._m.Lock()
     try {
       if (!this._done) {
-        f()
+        await f()
         this._done = true
       }
     } finally {
@@ -256,11 +265,11 @@ export class Once {
 
 // Cond implements a condition variable, a rendezvous point for goroutines waiting for or announcing the occurrence of an event
 export class Cond {
-  private _l: Locker
+  public L: Locker
   private _waiters: Array<() => void> = []
 
   constructor(l: Locker) {
-    this._l = l
+    this.L = l
   }
 
   // Broadcast wakes all goroutines waiting on c
@@ -281,11 +290,11 @@ export class Cond {
 
   // Wait atomically unlocks c.L and suspends execution of the calling goroutine
   public async Wait(): Promise<void> {
-    this._l.Unlock()
+    this.L.Unlock()
 
     return new Promise<void>((resolve) => {
       this._waiters.push(async () => {
-        await this._l.Lock()
+        await this.L.Lock()
         resolve()
       })
     })
@@ -293,7 +302,7 @@ export class Cond {
 
   // clone returns a copy of this Cond instance
   public clone(): Cond {
-    return new Cond(this._l)
+    return new Cond(this.L)
   }
 }
 
@@ -311,6 +320,16 @@ export class Map {
     // Map has no public fields to initialize
   }
 
+  // Clear deletes all entries.
+  public async Clear(): Promise<void> {
+    await this._m.Lock()
+    try {
+      this._data.clear()
+    } finally {
+      this._m.Unlock()
+    }
+  }
+
   // Delete deletes the value for a key
   public async Delete(key: any): Promise<void> {
     await this._m.Lock()
@@ -321,6 +340,29 @@ 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()
+    }
+  }
+
+  // CompareAndSwap swaps the old and new values for key if the stored value is old.
+  public CompareAndSwap(key: any, old: any, value: any): boolean {
+    if (!this._data.has(key) || this._data.get(key) !== old) {
+      return false
+    }
+    this._data.set(key, value)
+    return true
+  }
+
   // 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()
@@ -360,17 +402,21 @@ export class Map {
   }
 
   // Range calls f sequentially for each key and value present in the map
-  public async Range(f: (key: any, value: any) => boolean): Promise<void> {
+  public async Range(
+    f: (key: any, value: any) => boolean | globalThis.Promise<boolean>,
+  ): Promise<void> {
     await this._m.RLock()
+    let entries: [any, any][]
     try {
-      for (const [key, value] of this._data) {
-        if (!f(key, value)) {
-          break
-        }
-      }
+      entries = Array.from(this._data)
     } finally {
       this._m.RUnlock()
     }
+    for (const [key, value] of entries) {
+      if (!(await f(key, value))) {
+        break
+      }
+    }
   }
 
   // Store sets the value for a key
@@ -383,6 +429,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