goscript 0.0.34 → 0.0.36

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/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.34",
+  "version": "0.0.36",
   "author": {
     "name": "Aperture Robotics LLC.",
     "email": "support@aperture.us",

package/gs/maps/iter.gs.ts

@@ -1,71 +0,0 @@
-import * as $ from "@goscript/builtin/builtin.js";
-
-import * as iter from "@goscript/iter/index.js"
-
-// All returns an iterator over key-value pairs from m.
-// The iteration order is not specified and is not guaranteed
-// to be the same from one call to the next.
-export function All<K extends $.Comparable, V>(m: Map<K, V>): iter.Seq2<K, V> {
-	return (_yield: ((p0: K, p1: V) => boolean) | null): void => {
-		for (const [k, v] of m.entries()) {
-			{
-				if (!_yield!(k, v)) {
-					return 
-				}
-			}
-		}
-	}
-}
-
-// Keys returns an iterator over keys in m.
-// The iteration order is not specified and is not guaranteed
-// to be the same from one call to the next.
-export function Keys<K extends $.Comparable, V>(m: Map<K, V>): iter.Seq<K> {
-	return (_yield: ((p0: K) => boolean) | null): void => {
-		for (const [k, _v] of m.entries()) {
-			{
-				if (!_yield!(k)) {
-					return 
-				}
-			}
-		}
-	}
-}
-
-// Values returns an iterator over values in m.
-// The iteration order is not specified and is not guaranteed
-// to be the same from one call to the next.
-export function Values<K extends $.Comparable, V>(m: Map<K, V>): iter.Seq<V> {
-	return (_yield: ((p0: V) => boolean) | null): void => {
-		for (const [_k, v] of m.entries()) {
-			{
-				if (!_yield!(v)) {
-					return 
-				}
-			}
-		}
-	}
-}
-
-// Insert adds the key-value pairs from seq to m.
-// If a key in seq already exists in m, its value will be overwritten.
-export function Insert<K extends $.Comparable, V>(m: Map<K, V>, seq: iter.Seq2<K, V>): void {
-	;(() => {
-		let shouldContinue = true
-		seq!((k, v) => {
-			{
-				$.mapSet(m, k, v)
-			}
-			return shouldContinue
-		})
-	})()
-}
-
-// Collect collects key-value pairs from seq into a new map
-// and returns it.
-export function Collect<K extends $.Comparable, V extends any>(seq: iter.Seq2<K, V>): Map<K, V> {
-	let m = $.makeMap<K, V>()
-	Insert(m, seq)
-	return m
-}
-

package/gs/maps/maps.gs.ts

@@ -1,87 +0,0 @@
-import * as $ from "@goscript/builtin/builtin.js";
-
-import * as _ from "@goscript/unsafe/index.js"
-
-// Equal reports whether two maps contain the same key/value pairs.
-// Values are compared using ==.
-export function Equal<K extends $.Comparable, V extends $.Comparable>(m1: Map<K, V>, m2: Map<K, V>): boolean {
-	if ($.len(m1) != $.len(m2)) {
-		return false
-	}
-	for (const [k, v1] of m1.entries()) {
-		{
-			{
-				let [v2, ok] = $.mapGet(m2, k, null as any)
-				if (!ok || v1 != v2) {
-					return false
-				}
-			}
-		}
-	}
-	return true
-}
-
-// EqualFunc is like Equal, but compares values using eq.
-// Keys are still compared with ==.
-export function EqualFunc<K extends $.Comparable, V1, V2>(m1: Map<K, V1>, m2: Map<K, V2>, eq: ((p0: V1, p1: V2) => boolean) | null): boolean {
-	if ($.len(m1) != $.len(m2)) {
-		return false
-	}
-	for (const [k, v1] of m1.entries()) {
-		{
-			{
-				let [v2, ok] = $.mapGet(m2, k, null as any)
-				if (!ok || !eq!(v1, v2)) {
-					return false
-				}
-			}
-		}
-	}
-	return true
-}
-
-// clone returns a shallow copy of the map.
-export function clone<K extends $.Comparable, V>(m: Map<K, V> | null): Map<K, V> | null {
-	if (m == null) {
-		return null
-	}
-	const result = $.makeMap<K, V>()
-	for (const [k, v] of m.entries()) {
-		$.mapSet(result, k, v)
-	}
-	return result
-}
-
-// Clone returns a copy of m.  This is a shallow clone:
-// the new keys and values are set using ordinary assignment.
-export function Clone<K extends $.Comparable, V>(m: Map<K, V>): Map<K, V> {
-	// Preserve nil in case it matters.
-	if (m == null) {
-		return null as unknown as Map<K, V>
-	}
-	return clone(m)!
-}
-
-// Copy copies all key/value pairs in src adding them to dst.
-// When a key in src is already present in dst,
-// the value in dst will be overwritten by the value associated
-// with the key in src.
-export function Copy<K extends $.Comparable, V>(dst: Map<K, V>, src: Map<K, V>): void {
-	for (const [k, v] of src.entries()) {
-		{
-			$.mapSet(dst, k, v)
-		}
-	}
-}
-
-// DeleteFunc deletes any key/value pairs from m for which del returns true.
-export function DeleteFunc<K extends $.Comparable, V>(m: Map<K, V>, del: ((p0: K, p1: V) => boolean) | null): void {
-	for (const [k, v] of m.entries()) {
-		{
-			if (del!(k, v)) {
-				$.deleteMapEntry(m, k)
-			}
-		}
-	}
-}
-

package/gs/stringslite/godoc.txt

@@ -1,17 +0,0 @@
-package stringslite // import "internal/stringslite"
-
-Package stringslite implements a subset of strings, only using packages that may
-be imported by "os".
-
-Tests for these functions are in the strings package.
-
-func Clone(s string) string
-func Cut(s, sep string) (before, after string, found bool)
-func CutPrefix(s, prefix string) (after string, found bool)
-func CutSuffix(s, suffix string) (before string, found bool)
-func HasPrefix(s, prefix string) bool
-func HasSuffix(s, suffix string) bool
-func Index(s, substr string) int
-func IndexByte(s string, c byte) int
-func TrimPrefix(s, prefix string) string
-func TrimSuffix(s, suffix string) string

package/gs/stringslite/index.ts

@@ -1 +0,0 @@
-export * from './strings'

package/gs/stringslite/strings.ts

@@ -1,82 +0,0 @@
-import * as $ from '@goscript/builtin/builtin.js'
-
-import * as unsafe from '@goscript/unsafe/index.js'
-
-export function HasPrefix(s: string, prefix: string): boolean {
-  return (
-    $.len(s) >= $.len(prefix) &&
-    $.sliceString(s, undefined, $.len(prefix)) == prefix
-  )
-}
-
-export function HasSuffix(s: string, suffix: string): boolean {
-  return (
-    $.len(s) >= $.len(suffix) &&
-    $.sliceString(s, $.len(s) - $.len(suffix), undefined) == suffix
-  )
-}
-
-export function IndexByte(s: string, c: number): number {
-  const char = String.fromCharCode(c)
-  return s.indexOf(char)
-}
-
-export function Index(s: string, substr: string): number {
-  if (substr === '') {
-    return 0
-  }
-  return s.indexOf(substr)
-}
-
-export function Cut(s: string, sep: string): [string, string, boolean] {
-  let i = Index(s, sep)
-  if (i >= 0) {
-    return [
-      $.sliceString(s, undefined, i),
-      $.sliceString(s, i + $.len(sep), undefined),
-      true,
-    ]
-  }
-  return [s, '', false]
-}
-
-export function CutPrefix(s: string, prefix: string): [string, boolean] {
-  if (!HasPrefix(s, prefix)) {
-    return [s, false]
-  }
-  return [$.sliceString(s, $.len(prefix), undefined), true]
-}
-
-export function CutSuffix(s: string, suffix: string): [string, boolean] {
-  if (!HasSuffix(s, suffix)) {
-    return [s, false]
-  }
-  return [$.sliceString(s, undefined, $.len(s) - $.len(suffix)), true]
-}
-
-export function TrimPrefix(s: string, prefix: string): string {
-  if (HasPrefix(s, prefix)) {
-    return $.sliceString(s, $.len(prefix), undefined)
-  }
-  return s
-}
-
-export function TrimSuffix(s: string, suffix: string): string {
-  if (HasSuffix(s, suffix)) {
-    return $.sliceString(s, undefined, $.len(s) - $.len(suffix))
-  }
-  return s
-}
-
-export function Clone(s: string): string {
-  if ($.len(s) == 0) {
-    return ''
-  }
-  let b = new Uint8Array($.len(s))
-  $.copy(b, s)
-  return unsafe.String(b![0], $.len(b))
-}
-
-export function CopyBytes(b: Uint8Array, s: string): number {
-  return $.copy(b, s)
-}