lib/strings+test: port split family from Hare
This commit is contained in:
@@ -1828,6 +1828,7 @@ package strings;
|
||||
import bytes;
|
||||
import encoding.utf8;
|
||||
import os;
|
||||
import types;
|
||||
|
||||
// toutf8 — borrowed []u8 view of `s`. ref/hare/strings/utf8.ha:29.
|
||||
// `cap` equals `len`; the slice does not own a separate allocation.
|
||||
@@ -2404,6 +2405,123 @@ export fn remaining_tokens(s: *tokenizer) str = {
|
||||
return fromutf8_unsafe(bytes.remaining_tokens(b));
|
||||
};
|
||||
|
||||
// rt_ensure is the runtime slice-growth helper invoked by the
|
||||
// `append(s, v)` builtin. Direct bind for the same reason as
|
||||
// lib/shlex.shlex (appendstr, 16B): the builtin's expansion stores
|
||||
// only 8B of the new element, losing the `.len` half of a `str`.
|
||||
@symbol("rt_ensure") fn rtensure(s: *void, membsz: u64) void;
|
||||
|
||||
// appendstr — grow `*slice` by one and store `item` (16B). Mirror of
|
||||
// lib/shlex.shlex appendstr. Collapses when the append builtin learns
|
||||
// to store the full element width.
|
||||
fn appendstr(slice: *[]str, item: str) void = {
|
||||
let newlen: i32 = slice.len + 1;
|
||||
slice.len = newlen;
|
||||
rtensure(slice: *void, 16u64);
|
||||
let dst: *str = &slice.ptr[newlen - 1];
|
||||
dst.ptr = item.ptr;
|
||||
dst.len = item.len;
|
||||
};
|
||||
|
||||
// splitn — split `in` on any byte in `delim`, returning up to `n`
|
||||
// tokens via forward iteration. The trailing slot (when more than
|
||||
// `n - 1` tokens exist) holds the unconsumed remainder. Strings
|
||||
// within the result are borrowed from `in`.
|
||||
//
|
||||
// The caller frees the returned slice via
|
||||
// `os.free(r.ptr: *void, (r.cap: u64) * 16u64)`.
|
||||
//
|
||||
// Hare's `([]str | nomem)` collapses to `[]str` here: ww os.alloc
|
||||
// has no recoverable failure path. Same precedent as
|
||||
// shlex.split / bytes.splitn.
|
||||
//
|
||||
// ref/hare/strings/tokenize.ha:172.
|
||||
export fn splitn(in: str, delim: str, n: i32) []str = {
|
||||
let toks: []str;
|
||||
toks.ptr = nil: *str;
|
||||
toks.len = 0;
|
||||
toks.cap = 0;
|
||||
let tok: tokenizer = tokenize(in, delim);
|
||||
let i: i32 = 0;
|
||||
for (i < n - 1) {
|
||||
match (next_token(&tok)) {
|
||||
case let s: str => { appendstr(&toks, s); };
|
||||
case bytes.done => { return toks; };
|
||||
};
|
||||
i += 1;
|
||||
};
|
||||
match (peek_token(&tok)) {
|
||||
case bytes.done => void;
|
||||
case let pk: str => {
|
||||
let r: str = remaining_tokens(&tok);
|
||||
appendstr(&toks, r);
|
||||
};
|
||||
};
|
||||
return toks;
|
||||
};
|
||||
|
||||
// rsplitn — reverse-direction counterpart to [[splitn]]: tokens are
|
||||
// collected from the end of `in`. The trailing slot holds the
|
||||
// unconsumed prefix (everything before the n-th-from-last delim hit).
|
||||
//
|
||||
// When the input has fewer than n tokens, the `done` short-circuit
|
||||
// returns toks UN-reversed (in last-token-first order). Mirrors Hare
|
||||
// at ref/hare/strings/tokenize.ha:219-224 where the in-place reverse
|
||||
// step is gated behind the n-1 loop running to completion.
|
||||
//
|
||||
// ref/hare/strings/tokenize.ha:200.
|
||||
export fn rsplitn(in: str, delim: str, n: i32) []str = {
|
||||
let toks: []str;
|
||||
toks.ptr = nil: *str;
|
||||
toks.len = 0;
|
||||
toks.cap = 0;
|
||||
let tok: tokenizer = rtokenize(in, delim);
|
||||
let i: i32 = 0;
|
||||
for (i < n - 1) {
|
||||
match (next_token(&tok)) {
|
||||
case let s: str => { appendstr(&toks, s); };
|
||||
case bytes.done => { return toks; };
|
||||
};
|
||||
i += 1;
|
||||
};
|
||||
match (peek_token(&tok)) {
|
||||
case bytes.done => void;
|
||||
case let pk: str => {
|
||||
let r: str = remaining_tokens(&tok);
|
||||
appendstr(&toks, r);
|
||||
};
|
||||
};
|
||||
|
||||
// In-place reverse so callers see argv-order, matching Hare
|
||||
// (ref/hare/strings/tokenize.ha:220). Element copy is field-wise
|
||||
// through `*str` because `toks[i] = toks[j]` (full 16B str store)
|
||||
// lands in the multi-word-store gap noted at cmd/w6c/cgen.c:6515.
|
||||
let a: i32 = 0;
|
||||
let b: i32 = toks.len - 1;
|
||||
for (a < b) {
|
||||
let pa: *str = &toks.ptr[a];
|
||||
let pb: *str = &toks.ptr[b];
|
||||
let tp: *u8 = pa.ptr;
|
||||
let tl: i32 = pa.len;
|
||||
pa.ptr = pb.ptr;
|
||||
pa.len = pb.len;
|
||||
pb.ptr = tp;
|
||||
pb.len = tl;
|
||||
a += 1;
|
||||
b -= 1;
|
||||
};
|
||||
return toks;
|
||||
};
|
||||
|
||||
// split — full split of `in` on `delim` (no token cap). Mirrors
|
||||
// `splitn(in, delim, types::SIZE_MAX)`. ww uses `types.I32_MAX`
|
||||
// because the index type is i32 (lib/CLAUDE.md).
|
||||
//
|
||||
// ref/hare/strings/tokenize.ha:242.
|
||||
export fn split(in: str, delim: str) []str = {
|
||||
return splitn(in, delim, types.I32_MAX);
|
||||
};
|
||||
|
||||
// strconv — number↔string conversions.
|
||||
//
|
||||
// Mirrors Hare's strconv:: surface. The *tos functions return a
|
||||
|
||||
@@ -1828,6 +1828,7 @@ package strings;
|
||||
import bytes;
|
||||
import encoding.utf8;
|
||||
import os;
|
||||
import types;
|
||||
|
||||
// toutf8 — borrowed []u8 view of `s`. ref/hare/strings/utf8.ha:29.
|
||||
// `cap` equals `len`; the slice does not own a separate allocation.
|
||||
@@ -2404,6 +2405,123 @@ export fn remaining_tokens(s: *tokenizer) str = {
|
||||
return fromutf8_unsafe(bytes.remaining_tokens(b));
|
||||
};
|
||||
|
||||
// rt_ensure is the runtime slice-growth helper invoked by the
|
||||
// `append(s, v)` builtin. Direct bind for the same reason as
|
||||
// lib/shlex.shlex (appendstr, 16B): the builtin's expansion stores
|
||||
// only 8B of the new element, losing the `.len` half of a `str`.
|
||||
@symbol("rt_ensure") fn rtensure(s: *void, membsz: u64) void;
|
||||
|
||||
// appendstr — grow `*slice` by one and store `item` (16B). Mirror of
|
||||
// lib/shlex.shlex appendstr. Collapses when the append builtin learns
|
||||
// to store the full element width.
|
||||
fn appendstr(slice: *[]str, item: str) void = {
|
||||
let newlen: i32 = slice.len + 1;
|
||||
slice.len = newlen;
|
||||
rtensure(slice: *void, 16u64);
|
||||
let dst: *str = &slice.ptr[newlen - 1];
|
||||
dst.ptr = item.ptr;
|
||||
dst.len = item.len;
|
||||
};
|
||||
|
||||
// splitn — split `in` on any byte in `delim`, returning up to `n`
|
||||
// tokens via forward iteration. The trailing slot (when more than
|
||||
// `n - 1` tokens exist) holds the unconsumed remainder. Strings
|
||||
// within the result are borrowed from `in`.
|
||||
//
|
||||
// The caller frees the returned slice via
|
||||
// `os.free(r.ptr: *void, (r.cap: u64) * 16u64)`.
|
||||
//
|
||||
// Hare's `([]str | nomem)` collapses to `[]str` here: ww os.alloc
|
||||
// has no recoverable failure path. Same precedent as
|
||||
// shlex.split / bytes.splitn.
|
||||
//
|
||||
// ref/hare/strings/tokenize.ha:172.
|
||||
export fn splitn(in: str, delim: str, n: i32) []str = {
|
||||
let toks: []str;
|
||||
toks.ptr = nil: *str;
|
||||
toks.len = 0;
|
||||
toks.cap = 0;
|
||||
let tok: tokenizer = tokenize(in, delim);
|
||||
let i: i32 = 0;
|
||||
for (i < n - 1) {
|
||||
match (next_token(&tok)) {
|
||||
case let s: str => { appendstr(&toks, s); };
|
||||
case bytes.done => { return toks; };
|
||||
};
|
||||
i += 1;
|
||||
};
|
||||
match (peek_token(&tok)) {
|
||||
case bytes.done => void;
|
||||
case let pk: str => {
|
||||
let r: str = remaining_tokens(&tok);
|
||||
appendstr(&toks, r);
|
||||
};
|
||||
};
|
||||
return toks;
|
||||
};
|
||||
|
||||
// rsplitn — reverse-direction counterpart to [[splitn]]: tokens are
|
||||
// collected from the end of `in`. The trailing slot holds the
|
||||
// unconsumed prefix (everything before the n-th-from-last delim hit).
|
||||
//
|
||||
// When the input has fewer than n tokens, the `done` short-circuit
|
||||
// returns toks UN-reversed (in last-token-first order). Mirrors Hare
|
||||
// at ref/hare/strings/tokenize.ha:219-224 where the in-place reverse
|
||||
// step is gated behind the n-1 loop running to completion.
|
||||
//
|
||||
// ref/hare/strings/tokenize.ha:200.
|
||||
export fn rsplitn(in: str, delim: str, n: i32) []str = {
|
||||
let toks: []str;
|
||||
toks.ptr = nil: *str;
|
||||
toks.len = 0;
|
||||
toks.cap = 0;
|
||||
let tok: tokenizer = rtokenize(in, delim);
|
||||
let i: i32 = 0;
|
||||
for (i < n - 1) {
|
||||
match (next_token(&tok)) {
|
||||
case let s: str => { appendstr(&toks, s); };
|
||||
case bytes.done => { return toks; };
|
||||
};
|
||||
i += 1;
|
||||
};
|
||||
match (peek_token(&tok)) {
|
||||
case bytes.done => void;
|
||||
case let pk: str => {
|
||||
let r: str = remaining_tokens(&tok);
|
||||
appendstr(&toks, r);
|
||||
};
|
||||
};
|
||||
|
||||
// In-place reverse so callers see argv-order, matching Hare
|
||||
// (ref/hare/strings/tokenize.ha:220). Element copy is field-wise
|
||||
// through `*str` because `toks[i] = toks[j]` (full 16B str store)
|
||||
// lands in the multi-word-store gap noted at cmd/w6c/cgen.c:6515.
|
||||
let a: i32 = 0;
|
||||
let b: i32 = toks.len - 1;
|
||||
for (a < b) {
|
||||
let pa: *str = &toks.ptr[a];
|
||||
let pb: *str = &toks.ptr[b];
|
||||
let tp: *u8 = pa.ptr;
|
||||
let tl: i32 = pa.len;
|
||||
pa.ptr = pb.ptr;
|
||||
pa.len = pb.len;
|
||||
pb.ptr = tp;
|
||||
pb.len = tl;
|
||||
a += 1;
|
||||
b -= 1;
|
||||
};
|
||||
return toks;
|
||||
};
|
||||
|
||||
// split — full split of `in` on `delim` (no token cap). Mirrors
|
||||
// `splitn(in, delim, types::SIZE_MAX)`. ww uses `types.I32_MAX`
|
||||
// because the index type is i32 (lib/CLAUDE.md).
|
||||
//
|
||||
// ref/hare/strings/tokenize.ha:242.
|
||||
export fn split(in: str, delim: str) []str = {
|
||||
return splitn(in, delim, types.I32_MAX);
|
||||
};
|
||||
|
||||
// strconv — number↔string conversions.
|
||||
//
|
||||
// Mirrors Hare's strconv:: surface. The *tos functions return a
|
||||
|
||||
@@ -1719,6 +1719,7 @@ package strings;
|
||||
import bytes;
|
||||
import encoding.utf8;
|
||||
import os;
|
||||
import types;
|
||||
|
||||
// toutf8 — borrowed []u8 view of `s`. ref/hare/strings/utf8.ha:29.
|
||||
// `cap` equals `len`; the slice does not own a separate allocation.
|
||||
@@ -2295,6 +2296,123 @@ export fn remaining_tokens(s: *tokenizer) str = {
|
||||
return fromutf8_unsafe(bytes.remaining_tokens(b));
|
||||
};
|
||||
|
||||
// rt_ensure is the runtime slice-growth helper invoked by the
|
||||
// `append(s, v)` builtin. Direct bind for the same reason as
|
||||
// lib/shlex.shlex (appendstr, 16B): the builtin's expansion stores
|
||||
// only 8B of the new element, losing the `.len` half of a `str`.
|
||||
@symbol("rt_ensure") fn rtensure(s: *void, membsz: u64) void;
|
||||
|
||||
// appendstr — grow `*slice` by one and store `item` (16B). Mirror of
|
||||
// lib/shlex.shlex appendstr. Collapses when the append builtin learns
|
||||
// to store the full element width.
|
||||
fn appendstr(slice: *[]str, item: str) void = {
|
||||
let newlen: i32 = slice.len + 1;
|
||||
slice.len = newlen;
|
||||
rtensure(slice: *void, 16u64);
|
||||
let dst: *str = &slice.ptr[newlen - 1];
|
||||
dst.ptr = item.ptr;
|
||||
dst.len = item.len;
|
||||
};
|
||||
|
||||
// splitn — split `in` on any byte in `delim`, returning up to `n`
|
||||
// tokens via forward iteration. The trailing slot (when more than
|
||||
// `n - 1` tokens exist) holds the unconsumed remainder. Strings
|
||||
// within the result are borrowed from `in`.
|
||||
//
|
||||
// The caller frees the returned slice via
|
||||
// `os.free(r.ptr: *void, (r.cap: u64) * 16u64)`.
|
||||
//
|
||||
// Hare's `([]str | nomem)` collapses to `[]str` here: ww os.alloc
|
||||
// has no recoverable failure path. Same precedent as
|
||||
// shlex.split / bytes.splitn.
|
||||
//
|
||||
// ref/hare/strings/tokenize.ha:172.
|
||||
export fn splitn(in: str, delim: str, n: i32) []str = {
|
||||
let toks: []str;
|
||||
toks.ptr = nil: *str;
|
||||
toks.len = 0;
|
||||
toks.cap = 0;
|
||||
let tok: tokenizer = tokenize(in, delim);
|
||||
let i: i32 = 0;
|
||||
for (i < n - 1) {
|
||||
match (next_token(&tok)) {
|
||||
case let s: str => { appendstr(&toks, s); };
|
||||
case bytes.done => { return toks; };
|
||||
};
|
||||
i += 1;
|
||||
};
|
||||
match (peek_token(&tok)) {
|
||||
case bytes.done => void;
|
||||
case let pk: str => {
|
||||
let r: str = remaining_tokens(&tok);
|
||||
appendstr(&toks, r);
|
||||
};
|
||||
};
|
||||
return toks;
|
||||
};
|
||||
|
||||
// rsplitn — reverse-direction counterpart to [[splitn]]: tokens are
|
||||
// collected from the end of `in`. The trailing slot holds the
|
||||
// unconsumed prefix (everything before the n-th-from-last delim hit).
|
||||
//
|
||||
// When the input has fewer than n tokens, the `done` short-circuit
|
||||
// returns toks UN-reversed (in last-token-first order). Mirrors Hare
|
||||
// at ref/hare/strings/tokenize.ha:219-224 where the in-place reverse
|
||||
// step is gated behind the n-1 loop running to completion.
|
||||
//
|
||||
// ref/hare/strings/tokenize.ha:200.
|
||||
export fn rsplitn(in: str, delim: str, n: i32) []str = {
|
||||
let toks: []str;
|
||||
toks.ptr = nil: *str;
|
||||
toks.len = 0;
|
||||
toks.cap = 0;
|
||||
let tok: tokenizer = rtokenize(in, delim);
|
||||
let i: i32 = 0;
|
||||
for (i < n - 1) {
|
||||
match (next_token(&tok)) {
|
||||
case let s: str => { appendstr(&toks, s); };
|
||||
case bytes.done => { return toks; };
|
||||
};
|
||||
i += 1;
|
||||
};
|
||||
match (peek_token(&tok)) {
|
||||
case bytes.done => void;
|
||||
case let pk: str => {
|
||||
let r: str = remaining_tokens(&tok);
|
||||
appendstr(&toks, r);
|
||||
};
|
||||
};
|
||||
|
||||
// In-place reverse so callers see argv-order, matching Hare
|
||||
// (ref/hare/strings/tokenize.ha:220). Element copy is field-wise
|
||||
// through `*str` because `toks[i] = toks[j]` (full 16B str store)
|
||||
// lands in the multi-word-store gap noted at cmd/w6c/cgen.c:6515.
|
||||
let a: i32 = 0;
|
||||
let b: i32 = toks.len - 1;
|
||||
for (a < b) {
|
||||
let pa: *str = &toks.ptr[a];
|
||||
let pb: *str = &toks.ptr[b];
|
||||
let tp: *u8 = pa.ptr;
|
||||
let tl: i32 = pa.len;
|
||||
pa.ptr = pb.ptr;
|
||||
pa.len = pb.len;
|
||||
pb.ptr = tp;
|
||||
pb.len = tl;
|
||||
a += 1;
|
||||
b -= 1;
|
||||
};
|
||||
return toks;
|
||||
};
|
||||
|
||||
// split — full split of `in` on `delim` (no token cap). Mirrors
|
||||
// `splitn(in, delim, types::SIZE_MAX)`. ww uses `types.I32_MAX`
|
||||
// because the index type is i32 (lib/CLAUDE.md).
|
||||
//
|
||||
// ref/hare/strings/tokenize.ha:242.
|
||||
export fn split(in: str, delim: str) []str = {
|
||||
return splitn(in, delim, types.I32_MAX);
|
||||
};
|
||||
|
||||
// strconv — number↔string conversions.
|
||||
//
|
||||
// Mirrors Hare's strconv:: surface. The *tos functions return a
|
||||
|
||||
Reference in New Issue
Block a user