goscript 0.0.28 → 0.0.29

package/gs/path/match.ts

@@ -0,0 +1,307 @@
+import * as $ from "@goscript/builtin/builtin.js";
+
+import * as errors from "@goscript/errors/index.js"
+
+import * as utf8 from "@goscript/unicode/utf8/index.js"
+
+export let ErrBadPattern: $.GoError = errors.New("syntax error in pattern")
+
+// Match reports whether name matches the shell pattern.
+// The pattern syntax is:
+//
+//	pattern:
+//		{ term }
+//	term:
+//		'*'         matches any sequence of non-/ characters
+//		'?'         matches any single non-/ character
+//		'[' [ '^' ] { character-range } ']'
+//		            character class (must be non-empty)
+//		c           matches character c (c != '*', '?', '\\', '[')
+//		'\\' c      matches character c
+//
+//	character-range:
+//		c           matches character c (c != '\\', '-', ']')
+//		'\\' c      matches character c
+//		lo '-' hi   matches character c for lo <= c <= hi
+//
+// Match requires pattern to match all of name, not just a substring.
+// The only possible returned error is [ErrBadPattern], when pattern
+// is malformed.
+export function Match(pattern: string, name: string): [boolean, $.GoError] {
+	let matched: boolean = false
+	let err: $.GoError = null
+	{
+
+		// Trailing * matches rest of string unless it has a /.
+
+		// Look for match at current position.
+
+		// if we're the last chunk, make sure we've exhausted the name
+		// otherwise we'll give a false result even if we could still match
+		// using the star
+
+		// Look for match skipping i+1 bytes.
+		// Cannot skip /.
+
+		// if we're the last chunk, make sure we exhausted the name
+
+		// Before returning false with no error,
+		// check that the remainder of the pattern is syntactically valid.
+		Pattern: for (; $.len(pattern) > 0; ) {
+			let star: boolean = false
+			let chunk: string = ""
+			let rest: string = ""
+			let scanResult = scanChunk(pattern)
+			star = scanResult[0]
+			chunk = scanResult[1]
+			rest = scanResult[2]
+			pattern = rest
+
+			// Trailing * matches rest of string unless it has a /.
+			if (star && chunk == "") {
+				// Trailing * matches rest of string unless it has a /.
+				return [name.indexOf("/") < 0, null]
+			}
+			// Look for match at current position.
+			let [t, ok, err] = matchChunk(chunk, name)
+			// if we're the last chunk, make sure we've exhausted the name
+			// otherwise we'll give a false result even if we could still match
+			// using the star
+			if (ok && ($.len(t) == 0 || $.len(pattern) > 0)) {
+				name = t
+				continue
+			}
+			if (err != null) {
+				return [false, err]
+			}
+
+			// Look for match skipping i+1 bytes.
+			// Cannot skip /.
+
+			// if we're the last chunk, make sure we exhausted the name
+			if (star) {
+				// Look for match skipping i+1 bytes.
+				// Cannot skip /.
+
+				// if we're the last chunk, make sure we exhausted the name
+				for (let i = 0; i < $.len(name) && $.indexString(name, i) != 47; i++) {
+					let [t, ok, err] = matchChunk(chunk, $.sliceString(name, i, undefined))
+
+					// if we're the last chunk, make sure we exhausted the name
+					if (ok) {
+						// if we're the last chunk, make sure we exhausted the name
+						if ($.len(pattern) == 0 && $.len(t) > 0) {
+							continue
+						}
+						name = t
+						continue Pattern
+					}
+					if (err != null) {
+						return [false, err]
+					}
+				}
+			}
+			// Before returning false with no error,
+			// check that the remainder of the pattern is syntactically valid.
+			for (; $.len(pattern) > 0; ) {
+				let star2: boolean = false
+				let chunk2: string = ""
+				let rest2: string = ""
+				let scanResult2 = scanChunk(pattern)
+				star2 = scanResult2[0]
+				chunk2 = scanResult2[1]
+				rest2 = scanResult2[2]
+				pattern = rest2
+				{
+					let [, , err] = matchChunk(chunk2, "")
+					if (err != null) {
+						return [false, err]
+					}
+				}
+			}
+			return [false, null]
+		}
+		return [$.len(name) == 0, null]
+	}
+}
+
+// scanChunk gets the next segment of pattern, which is a non-star string
+// possibly preceded by a star.
+export function scanChunk(pattern: string): [boolean, string, string] {
+	let star: boolean = false
+	let chunk: string = ""
+	let rest: string = ""
+	{
+		for (; $.len(pattern) > 0 && $.indexString(pattern, 0) == 42; ) {
+			pattern = $.sliceString(pattern, 1, undefined)
+			star = true
+		}
+		let inrange = false
+		let i: number = 0
+
+		// error check handled in matchChunk: bad pattern.
+		Scan: for (i = 0; i < $.len(pattern); i++) {
+
+			// error check handled in matchChunk: bad pattern.
+			switch ($.indexString(pattern, i)) {
+				case 92:
+					if (i + 1 < $.len(pattern)) {
+						i++
+					}
+					break
+				case 91:
+					inrange = true
+					break
+				case 93:
+					inrange = false
+					break
+				case 42:
+					if (!inrange) {
+						break Scan
+					}
+					break
+			}
+		}
+		return [star, $.sliceString(pattern, 0, i), $.sliceString(pattern, i, undefined)]
+	}
+}
+
+// matchChunk checks whether chunk matches the beginning of s.
+// If so, it returns the remainder of s (after the match).
+// Chunk is all single-character operators: literals, char classes, and ?.
+export function matchChunk(chunk: string, s: string): [string, boolean, $.GoError] {
+	let rest: string = ""
+	let ok: boolean = false
+	let err: $.GoError = null
+	{
+		// failed records whether the match has failed.
+		// After the match fails, the loop continues on processing chunk,
+		// checking that the pattern is well-formed but no longer reading s.
+		let failed = false
+
+		// character class
+
+		// possibly negated
+
+		// parse all ranges
+		for (; $.len(chunk) > 0; ) {
+			if (!failed && $.len(s) == 0) {
+				failed = true
+			}
+
+			// character class
+
+			// possibly negated
+
+			// parse all ranges
+			switch ($.indexString(chunk, 0)) {
+				case 91:
+					let r: number = 0
+					if (!failed) {
+						let n: number = 0
+						let decoded = utf8.DecodeRuneInString(s)
+						r = decoded[0]
+						n = decoded[1]
+						s = $.sliceString(s, n, undefined)
+					}
+					chunk = $.sliceString(chunk, 1, undefined)
+					let negated = false
+					if ($.len(chunk) > 0 && $.indexString(chunk, 0) == 94) {
+						negated = true
+						chunk = $.sliceString(chunk, 1, undefined)
+					}
+					let match = false
+					let nrange = 0
+					for (; ; ) {
+						if ($.len(chunk) > 0 && $.indexString(chunk, 0) == 93 && nrange > 0) {
+							chunk = $.sliceString(chunk, 1, undefined)
+							break
+						}
+						let lo: number = 0
+						let hi: number = 0
+						{
+							let escResult = getEsc(chunk)
+							lo = escResult[0]
+							chunk = escResult[1]
+							err = escResult[2]
+							if (err != null) {
+								return ["", false, err]
+							}
+						}
+						hi = lo
+						if ($.indexString(chunk, 0) == 45) {
+							{
+								let escResult2 = getEsc($.sliceString(chunk, 1, undefined))
+								hi = escResult2[0]
+								chunk = escResult2[1]
+								err = escResult2[2]
+								if (err != null) {
+									return ["", false, err]
+								}
+							}
+						}
+						if (lo <= r && r <= hi) {
+							match = true
+						}
+						nrange++
+					}
+					if (match == negated) {
+						failed = true
+					}
+					break
+				case 63:
+					if (!failed) {
+						if ($.indexString(s, 0) == 47) {
+							failed = true
+						}
+						let [, n] = utf8.DecodeRuneInString(s)
+						s = $.sliceString(s, n, undefined)
+					}
+					chunk = $.sliceString(chunk, 1, undefined)
+					break
+				case 92:
+					chunk = $.sliceString(chunk, 1, undefined)
+					if ($.len(chunk) == 0) {
+						return ["", false, ErrBadPattern]
+					}
+					// unhandled branch statement token: fallthrough
+					break
+				default:
+					if (!failed) {
+						if ($.indexString(chunk, 0) != $.indexString(s, 0)) {
+							failed = true
+						}
+						s = $.sliceString(s, 1, undefined)
+					}
+					chunk = $.sliceString(chunk, 1, undefined)
+					break
+			}
+		}
+		if (failed) {
+			return ["", false, null]
+		}
+		return [s, true, null]
+	}
+}
+
+export function getEsc(chunk: string): [number, string, $.GoError] {
+	if ($.len(chunk) == 0 || $.indexString(chunk, 0) == 45 || $.indexString(chunk, 0) == 93) {
+		return [0, "", ErrBadPattern]
+	}
+	if ($.indexString(chunk, 0) == 92) {
+		chunk = $.sliceString(chunk, 1, undefined)
+		if ($.len(chunk) == 0) {
+			return [0, "", ErrBadPattern]
+		}
+	}
+	let [r, n] = utf8.DecodeRuneInString(chunk)
+	if (r == utf8.RuneError && n == 1) {
+		return [0, "", ErrBadPattern]
+	}
+	chunk = $.sliceString(chunk, n, undefined)
+	if ($.len(chunk) == 0 || $.indexString(chunk, 0) != 45 || $.len(chunk) == 1) {
+		return [r, chunk, null]
+	}
+	return [r, chunk, null]
+}
+

package/gs/path/path.ts

@@ -0,0 +1,301 @@
+import * as $ from "@goscript/builtin/builtin.js";
+
+class lazybuf {
+	public get s(): string {
+		return this._fields.s.value
+	}
+	public set s(value: string) {
+		this._fields.s.value = value
+	}
+
+	public get buf(): Uint8Array | null {
+		return this._fields.buf.value
+	}
+	public set buf(value: Uint8Array | null) {
+		this._fields.buf.value = value
+	}
+
+	public get w(): number {
+		return this._fields.w.value
+	}
+	public set w(value: number) {
+		this._fields.w.value = value
+	}
+
+	public _fields: {
+		s: $.VarRef<string>;
+		buf: $.VarRef<Uint8Array | null>;
+		w: $.VarRef<number>;
+	}
+
+	constructor(init?: Partial<{buf?: Uint8Array, s?: string, w?: number}>) {
+		this._fields = {
+			s: $.varRef(init?.s ?? ""),
+			buf: $.varRef(init?.buf ?? null),
+			w: $.varRef(init?.w ?? 0)
+		}
+	}
+
+	public clone(): lazybuf {
+		const cloned = new lazybuf()
+		cloned._fields = {
+			s: $.varRef(this._fields.s.value),
+			buf: $.varRef(this._fields.buf.value),
+			w: $.varRef(this._fields.w.value)
+		}
+		return cloned
+	}
+
+	public index(i: number): number {
+		const b = this
+		if (b!.buf != null) {
+			return b!.buf![i]
+		}
+		return $.indexString(b!.s, i)
+	}
+
+	public append(c: number): void {
+		const b = this
+		if (b!.buf == null) {
+			if (b!.w < $.len(b!.s) && $.indexString(b!.s, b!.w) == c) {
+				b!.w++
+				return 
+			}
+			b!.buf = new Uint8Array($.len(b!.s))
+			$.copy(b!.buf, $.stringToBytes($.sliceString(b!.s, undefined, b!.w)))
+		}
+		b!.buf![b!.w] = c
+		b!.w++
+	}
+
+	public _string(): string {
+		const b = this
+		if (b!.buf == null) {
+			return $.sliceString(b!.s, undefined, b!.w)
+		}
+		return $.bytesToString(b!.buf.subarray(0, b!.w))
+	}
+
+	// Register this type with the runtime type system
+	static __typeInfo = $.registerStructType(
+	  'lazybuf',
+	  new lazybuf(),
+	  [{ name: "index", args: [{ name: "i", type: { kind: $.TypeKind.Basic, name: "number" } }], returns: [{ type: { kind: $.TypeKind.Basic, name: "number" } }] }, { name: "append", args: [{ name: "c", type: { kind: $.TypeKind.Basic, name: "number" } }], returns: [] }, { name: "string", args: [], returns: [{ type: { kind: $.TypeKind.Basic, name: "string" } }] }],
+	  lazybuf,
+	  {"s": { kind: $.TypeKind.Basic, name: "string" }, "buf": { kind: $.TypeKind.Slice, elemType: { kind: $.TypeKind.Basic, name: "number" } }, "w": { kind: $.TypeKind.Basic, name: "number" }}
+	);
+}
+
+// Clean returns the shortest path name equivalent to path
+// by purely lexical processing. It applies the following rules
+// iteratively until no further processing can be done:
+//
+//  1. Replace multiple slashes with a single slash.
+//  2. Eliminate each . path name element (the current directory).
+//  3. Eliminate each inner .. path name element (the parent directory)
+//     along with the non-.. element that precedes it.
+//  4. Eliminate .. elements that begin a rooted path:
+//     that is, replace "/.." by "/" at the beginning of a path.
+//
+// The returned path ends in a slash only if it is the root "/".
+//
+// If the result of this process is an empty string, Clean
+// returns the string ".".
+//
+// See also Rob Pike, "Lexical File Names in Plan 9 or
+// Getting Dot-Dot Right,"
+// https://9p.io/sys/doc/lexnames.html
+export function Clean(path: string): string {
+	if (path == "") {
+		return "."
+	}
+
+	let rooted = $.indexString(path, 0) == 47
+	let n = $.len(path)
+
+	// Invariants:
+	//	reading from path; r is index of next byte to process.
+	//	writing to buf; w is index of next byte to write.
+	//	dotdot is index in buf where .. must stop, either because
+	//		it is the leading slash or it is a leading ../../.. prefix.
+	let out = new lazybuf({s: path})
+	let r = 0
+	let dotdot = 0
+	if (rooted) {
+		out.append(47)
+		r = 1
+		dotdot = 1
+	}
+
+	// empty path element
+
+	// . element
+
+	// .. element: remove to last /
+
+	// can backtrack
+
+	// cannot backtrack, but not rooted, so append .. element.
+
+	// real path element.
+	// add slash if needed
+
+	// copy element
+	for (; r < n; ) {
+
+		// empty path element
+
+		// . element
+
+		// .. element: remove to last /
+
+		// can backtrack
+
+		// cannot backtrack, but not rooted, so append .. element.
+
+		// real path element.
+		// add slash if needed
+
+		// copy element
+		switch (true) {
+			case $.indexString(path, r) == 47:
+				r++
+				break
+			case $.indexString(path, r) == 46 && (r + 1 == n || $.indexString(path, r + 1) == 47):
+				r++
+				break
+			case $.indexString(path, r) == 46 && $.indexString(path, r + 1) == 46 && (r + 2 == n || $.indexString(path, r + 2) == 47):
+				r += 2
+				switch (true) {
+					case out.w > dotdot:
+						out.w--
+						for (; out.w > dotdot && out.index(out.w) != 47; ) {
+							out.w--
+						}
+						break
+					case !rooted:
+						if (out.w > 0) {
+							out.append(47)
+						}
+						out.append(46)
+						out.append(46)
+						dotdot = out.w
+						break
+				}
+				break
+			default:
+				if (rooted && out.w != 1 || !rooted && out.w != 0) {
+					out.append(47)
+				}
+				for (; r < n && $.indexString(path, r) != 47; r++) {
+					out.append($.indexString(path, r))
+				}
+				break
+		}
+	}
+
+	// Turn empty string into "."
+	if (out.w == 0) {
+		return "."
+	}
+
+	return out._string()
+}
+
+// Split splits path immediately following the final slash,
+// separating it into a directory and file name component.
+// If there is no slash in path, Split returns an empty dir and
+// file set to path.
+// The returned values have the property that path = dir+file.
+export function Split(path: string): [string, string] {
+	let i = path.lastIndexOf("/")
+	return [$.sliceString(path, undefined, i + 1), $.sliceString(path, i + 1, undefined)]
+}
+
+// Join joins any number of path elements into a single path,
+// separating them with slashes. Empty elements are ignored.
+// The result is Cleaned. However, if the argument list is
+// empty or all its elements are empty, Join returns
+// an empty string.
+export function Join(...elem: string[]): string {
+	let size = 0
+	for (let _i = 0; _i < $.len(elem); _i++) {
+		const e = elem![_i]
+		{
+			size += $.len(e)
+		}
+	}
+	if (size == 0) {
+		return ""
+	}
+	let buf: string[] = []
+	for (let _i = 0; _i < $.len(elem); _i++) {
+		const e = elem![_i]
+		{
+			if ($.len(buf) > 0 || e != "") {
+				if ($.len(buf) > 0) {
+					buf.push("/")
+				}
+				buf.push(e)
+			}
+		}
+	}
+	return Clean(buf.join(""))
+}
+
+// Ext returns the file name extension used by path.
+// The extension is the suffix beginning at the final dot
+// in the final slash-separated element of path;
+// it is empty if there is no dot.
+export function Ext(path: string): string {
+	for (let i = $.len(path) - 1; i >= 0 && $.indexString(path, i) != 47; i--) {
+		if ($.indexString(path, i) == 46) {
+			return $.sliceString(path, i, undefined)
+		}
+	}
+	return ""
+}
+
+// Base returns the last element of path.
+// Trailing slashes are removed before extracting the last element.
+// If the path is empty, Base returns ".".
+// If the path consists entirely of slashes, Base returns "/".
+export function Base(path: string): string {
+	if (path == "") {
+		return "."
+	}
+	// Strip trailing slashes.
+	for (; $.len(path) > 0 && $.indexString(path, $.len(path) - 1) == 47; ) {
+		path = $.sliceString(path, 0, $.len(path) - 1)
+	}
+	// Find the last element
+	{
+		let i = path.lastIndexOf("/")
+		if (i >= 0) {
+			path = $.sliceString(path, i + 1, undefined)
+		}
+	}
+	// If empty now, it had only slashes.
+	if (path == "") {
+		return "/"
+	}
+	return path
+}
+
+// IsAbs reports whether the path is absolute.
+export function IsAbs(path: string): boolean {
+	return $.len(path) > 0 && $.indexString(path, 0) == 47
+}
+
+// Dir returns all but the last element of path, typically the path's directory.
+// After dropping the final element using [Split], the path is Cleaned and trailing
+// slashes are removed.
+// If the path is empty, Dir returns ".".
+// If the path consists entirely of slashes followed by non-slash bytes, Dir
+// returns a single slash. In any other case, the returned path does not end in a
+// slash.
+export function Dir(path: string): string {
+	let [dir, ] = Split(path)
+	return Clean(dir)
+}
+

package/gs/strings/reader.test.ts

@@ -1,5 +1,4 @@
 import { describe, it, expect } from 'vitest'
-import * as $ from '@goscript/builtin/builtin.js'
 import { Reader, NewReader } from './reader.js'
 import * as io from '@goscript/io/index.js'