1234567891011121314151617181920212223242526272829303132333435363738394041424344454647484950515253545556575859606162636465666768697071727374757677787980818283848586878889909192939495969798991001011021031041051061071081091101111121131141151161171181191201211221231241251261271281291301311321331341351361371381391401411421431441451461471481491501511521531541551561571581591601611621631641651661671681691701711721731741751761771781791801811821831841851861871881891901911921931941951961971981992002012022032042052062072082092102112122132142152162172182192202212222232242252262272282292302312322332342352362372382392402412422432442452462472482492502512522532542552562572582592602612622632642652662672682692702712722732742752762772782792802812822832842852862872882892902912922932942952962972982993003013023033043053063073083093103113123133143153163173183193203213223233243253263273283293303313323333343353363373383393403413423433443453463473483493503513523533543553563573583593603613623633643653663673683693703713723733743753763773783793803813823833843853863873883893903913923933943953963973983994004014024034044054064074084094104114124134144154164174184194204214224234244254264274284294304314324334344354364374384394404414424434444454464474484494504514524534544554564574584594604614624634644654664674684694704714724734744754764774784794804814824834844854864874884894904914924934944954964974984995005015025035045055065075085095105115125135145155165175185195205215225235245255265275285295305315325335345355365375385395405415425435445455465475485495505515525535545555565575585595605615625635645655665675685695705715725735745755765775785795805815825835845855865875885895905915925935945955965975985996006016026036046056066076086096106116126136146156166176186196206216226236246256266276286296306316326336346356366376386396406416426436446456466476486496506516526536546556566576586596606616626636646656666676686696706716726736746756766776786796806816826836846856866876886896906916926936946956966976986997007017027037047057067077087097107117127137147157167177187197207217227237247257267277287297307317327337347357367377387397407417427437447457467477487497507517527537547557567577587597607617627637647657667677687697707717727737747757767777787797807817827837847857867877887897907917927937947957967977987998008018028038048058068078088098108118128138148158168178188198208218228238248258268278288298308318328338348358368378388398408418428438448458468478488498508518528538548558568578588598608618628638648658668678688698708718728738748758768778788798808818828838848858868878888898908918928938948958968978988999009019029039049059069079089099109119129139149159169179189199209219229239249259269279289299309319329339349359369379389399409419429439449459469479489499509519529539549559569579589599609619629639649659669679689699709719729739749759769779789799809819829839849859869879889899909919929939949959969979989991000100110021003100410051006100710081009101010111012101310141015101610171018101910201021102210231024102510261027102810291030103110321033103410351036103710381039104010411042104310441045104610471048104910501051105210531054105510561057105810591060106110621063106410651066106710681069107010711072107310741075107610771078107910801081108210831084108510861087108810891090109110921093109410951096109710981099110011011102110311041105110611071108110911101111111211131114111511161117111811191120112111221123112411251126112711281129113011311132113311341135113611371138113911401141114211431144114511461147114811491150115111521153115411551156115711581159116011611162116311641165116611671168116911701171117211731174117511761177117811791180118111821183118411851186118711881189119011911192119311941195119611971198119912001201120212031204120512061207120812091210121112121213121412151216121712181219122012211222122312241225122612271228122912301231123212331234123512361237123812391240124112421243124412451246124712481249125012511252125312541255125612571258125912601261126212631264126512661267126812691270127112721273127412751276127712781279128012811282128312841285128612871288128912901291129212931294129512961297129812991300130113021303130413051306130713081309131013111312131313141315131613171318131913201321132213231324132513261327132813291330133113321333133413351336133713381339134013411342134313441345134613471348134913501351135213531354135513561357135813591360136113621363136413651366136713681369137013711372137313741375137613771378137913801381138213831384138513861387138813891390139113921393139413951396139713981399140014011402140314041405140614071408140914101411141214131414141514161417141814191420142114221423142414251426142714281429143014311432143314341435143614371438143914401441144214431444144514461447144814491450145114521453145414551456145714581459146014611462146314641465146614671468146914701471147214731474147514761477147814791480148114821483148414851486148714881489149014911492149314941495149614971498149915001501150215031504150515061507150815091510151115121513151415151516151715181519152015211522152315241525152615271528152915301531153215331534153515361537153815391540154115421543154415451546154715481549155015511552155315541555155615571558155915601561156215631564156515661567156815691570157115721573157415751576157715781579158015811582158315841585158615871588158915901591159215931594159515961597159815991600160116021603160416051606160716081609161016111612161316141615161616171618161916201621162216231624162516261627162816291630163116321633163416351636163716381639164016411642164316441645164616471648164916501651165216531654165516561657165816591660166116621663166416651666166716681669167016711672167316741675167616771678167916801681168216831684168516861687168816891690169116921693169416951696169716981699170017011702170317041705170617071708170917101711171217131714171517161717171817191720172117221723172417251726172717281729173017311732173317341735173617371738173917401741174217431744174517461747174817491750175117521753175417551756175717581759176017611762176317641765176617671768176917701771177217731774177517761777177817791780178117821783178417851786178717881789179017911792179317941795179617971798179918001801180218031804180518061807180818091810181118121813181418151816181718181819182018211822182318241825182618271828182918301831183218331834183518361837183818391840184118421843184418451846184718481849185018511852185318541855185618571858185918601861186218631864186518661867186818691870187118721873187418751876187718781879188018811882188318841885188618871888188918901891189218931894189518961897189818991900190119021903190419051906190719081909191019111912191319141915191619171918191919201921192219231924192519261927192819291930193119321933193419351936193719381939194019411942194319441945194619471948194919501951195219531954195519561957195819591960196119621963196419651966196719681969197019711972197319741975197619771978197919801981198219831984198519861987198819891990199119921993199419951996199719981999200020012002200320042005200620072008200920102011201220132014201520162017201820192020202120222023202420252026202720282029203020312032203320342035203620372038203920402041204220432044204520462047204820492050205120522053205420552056205720582059206020612062206320642065206620672068206920702071207220732074207520762077207820792080208120822083208420852086208720882089209020912092209320942095209620972098209921002101210221032104210521062107210821092110211121122113211421152116211721182119212021212122212321242125212621272128212921302131213221332134213521362137213821392140214121422143214421452146214721482149215021512152215321542155215621572158215921602161216221632164216521662167216821692170217121722173217421752176217721782179218021812182218321842185218621872188218921902191219221932194219521962197219821992200220122022203220422052206220722082209221022112212221322142215221622172218221922202221222222232224222522262227222822292230223122322233223422352236223722382239224022412242224322442245224622472248224922502251225222532254225522562257225822592260226122622263226422652266226722682269227022712272227322742275227622772278227922802281228222832284228522862287228822892290229122922293229422952296229722982299230023012302230323042305230623072308230923102311231223132314231523162317231823192320232123222323232423252326232723282329233023312332233323342335233623372338233923402341234223432344234523462347234823492350235123522353235423552356235723582359236023612362236323642365236623672368236923702371237223732374237523762377237823792380238123822383238423852386238723882389239023912392239323942395239623972398239924002401240224032404240524062407240824092410241124122413241424152416241724182419242024212422242324242425242624272428242924302431243224332434243524362437243824392440244124422443244424452446244724482449245024512452245324542455245624572458245924602461246224632464246524662467246824692470247124722473247424752476247724782479248024812482248324842485248624872488248924902491249224932494249524962497249824992500250125022503250425052506250725082509251025112512251325142515251625172518251925202521252225232524252525262527252825292530253125322533253425352536253725382539254025412542254325442545254625472548254925502551255225532554255525562557255825592560256125622563256425652566256725682569257025712572257325742575257625772578257925802581258225832584258525862587258825892590259125922593259425952596259725982599260026012602260326042605260626072608260926102611261226132614261526162617261826192620262126222623262426252626262726282629263026312632263326342635263626372638263926402641264226432644264526462647264826492650265126522653265426552656265726582659266026612662266326642665266626672668266926702671267226732674267526762677267826792680268126822683268426852686268726882689269026912692269326942695269626972698269927002701270227032704270527062707270827092710271127122713271427152716271727182719272027212722272327242725272627272728272927302731273227332734273527362737273827392740274127422743274427452746274727482749275027512752275327542755275627572758275927602761276227632764276527662767276827692770277127722773277427752776277727782779278027812782278327842785278627872788278927902791279227932794279527962797279827992800280128022803280428052806280728082809281028112812281328142815281628172818281928202821282228232824282528262827282828292830283128322833283428352836283728382839284028412842284328442845284628472848284928502851285228532854285528562857285828592860286128622863286428652866286728682869287028712872287328742875287628772878287928802881288228832884288528862887288828892890289128922893289428952896289728982899290029012902290329042905290629072908290929102911291229132914291529162917291829192920292129222923292429252926292729282929293029312932293329342935293629372938293929402941294229432944294529462947294829492950295129522953295429552956295729582959296029612962296329642965296629672968296929702971297229732974297529762977297829792980298129822983298429852986298729882989299029912992299329942995299629972998299930003001300230033004300530063007300830093010301130123013301430153016301730183019302030213022302330243025302630273028302930303031303230333034303530363037303830393040304130423043304430453046304730483049305030513052305330543055305630573058305930603061306230633064306530663067306830693070307130723073307430753076307730783079308030813082308330843085308630873088308930903091309230933094309530963097309830993100310131023103310431053106310731083109311031113112311331143115311631173118311931203121312231233124312531263127312831293130313131323133313431353136313731383139314031413142314331443145314631473148314931503151315231533154315531563157315831593160316131623163316431653166316731683169317031713172317331743175317631773178317931803181318231833184318531863187318831893190319131923193319431953196319731983199320032013202320332043205320632073208320932103211321232133214321532163217321832193220322132223223322432253226322732283229323032313232323332343235323632373238323932403241324232433244324532463247324832493250325132523253325432553256325732583259326032613262326332643265326632673268326932703271327232733274327532763277327832793280328132823283328432853286328732883289329032913292329332943295329632973298329933003301330233033304330533063307330833093310331133123313 |
- // Procedures to manipulate UTF-8 encoded strings
- package strings
- import "core:io"
- import "core:mem"
- import "core:unicode"
- import "core:unicode/utf8"
- /*
- Clones a string
- *Allocates Using Provided Allocator*
- Inputs:
- - s: The string to be cloned
- - allocator: (default: context.allocator)
- - loc: The caller location for debugging purposes (default: #caller_location)
- Returns:
- - res: The cloned string
- - err: An optional allocator error if one occured, `nil` otherwise
- */
- clone :: proc(s: string, allocator := context.allocator, loc := #caller_location) -> (res: string, err: mem.Allocator_Error) #optional_allocator_error {
- c := make([]byte, len(s), allocator, loc) or_return
- copy(c, s)
- return string(c[:len(s)]), nil
- }
- /*
- Clones a string safely (returns early with an allocation error on failure)
- *Allocates Using Provided Allocator*
- Inputs:
- - s: The string to be cloned
- - allocator: (default: context.allocator)
- - loc: The caller location for debugging purposes (default: #caller_location)
- Returns:
- - res: The cloned string
- - err: An allocator error if one occured, `nil` otherwise
- */
- @(deprecated="Prefer clone. It now returns an optional allocator error")
- clone_safe :: proc(s: string, allocator := context.allocator, loc := #caller_location) -> (res: string, err: mem.Allocator_Error) {
- return clone(s, allocator, loc)
- }
- /*
- Clones a string and appends a null-byte to make it a cstring
- *Allocates Using Provided Allocator*
- Inputs:
- - s: The string to be cloned
- - allocator: (default: context.allocator)
- - loc: The caller location for debugging purposes (default: #caller_location)
- Returns:
- - res: A cloned cstring with an appended null-byte
- - err: An optional allocator error if one occured, `nil` otherwise
- */
- clone_to_cstring :: proc(s: string, allocator := context.allocator, loc := #caller_location) -> (res: cstring, err: mem.Allocator_Error) #optional_allocator_error {
- c := make([]byte, len(s)+1, allocator, loc) or_return
- copy(c, s)
- c[len(s)] = 0
- return cstring(&c[0]), nil
- }
- /*
- Transmutes a raw pointer into a string. Non-allocating.
- Inputs:
- - ptr: A pointer to the start of the byte sequence
- - len: The length of the byte sequence
- NOTE: The created string is only valid as long as the pointer and length are valid.
- Returns:
- - res: A string created from the byte pointer and length
- */
- string_from_ptr :: proc(ptr: ^byte, len: int) -> (res: string) {
- return transmute(string)mem.Raw_String{ptr, len}
- }
- /*
- Transmutes a raw pointer (null-terminated) into a string. Non-allocating. Searches for a null-byte from `0..<len`, otherwise `len` will be the end size
- NOTE: The created string is only valid as long as the pointer and length are valid.
- The string is truncated at the first null-byte encountered.
- Inputs:
- - ptr: A pointer to the start of the null-terminated byte sequence
- - len: The length of the byte sequence
- Returns:
- - res: A string created from the null-terminated byte pointer and length
- */
- string_from_null_terminated_ptr :: proc(ptr: ^byte, len: int) -> (res: string) {
- s := transmute(string)mem.Raw_String{ptr, len}
- s = truncate_to_byte(s, 0)
- return s
- }
- /*
- Gets the raw byte pointer for the start of a string `str`
- Inputs:
- - str: The input string
- Returns:
- - res: A pointer to the start of the string's bytes
- */
- @(deprecated="Prefer the builtin raw_data.")
- ptr_from_string :: proc(str: string) -> (res: ^byte) {
- d := transmute(mem.Raw_String)str
- return d.data
- }
- /*
- Converts a string `str` to a cstring
- Inputs:
- - str: The input string
- WARNING: This is unsafe because the original string may not contain a null-byte.
- Returns:
- - res: The converted cstring
- */
- unsafe_string_to_cstring :: proc(str: string) -> (res: cstring) {
- d := transmute(mem.Raw_String)str
- return cstring(d.data)
- }
- /*
- Truncates a string `str` at the first occurrence of char/byte `b`
- Inputs:
- - str: The input string
- - b: The byte to truncate the string at
- NOTE: Failure to find the byte results in returning the entire string.
- Returns:
- - res: The truncated string
- */
- truncate_to_byte :: proc(str: string, b: byte) -> (res: string) {
- n := index_byte(str, b)
- if n < 0 {
- n = len(str)
- }
- return str[:n]
- }
- /*
- Truncates a string `str` at the first occurrence of rune `r` as a slice of the original, entire string if not found
- Inputs:
- - str: The input string
- - r: The rune to truncate the string at
- Returns:
- - res: The truncated string
- */
- truncate_to_rune :: proc(str: string, r: rune) -> (res: string) {
- n := index_rune(str, r)
- if n < 0 {
- n = len(str)
- }
- return str[:n]
- }
- /*
- Clones a byte array `s` and appends a null-byte
- *Allocates Using Provided Allocator*
- Inputs:
- - s: The byte array to be cloned
- - allocator: (default: context.allocator)
- - loc: The caller location for debugging purposes (default: `#caller_location`)
- Returns:
- - res: The cloned string from the byte array with a null-byte
- - err: An optional allocator error if one occured, `nil` otherwise
- */
- clone_from_bytes :: proc(s: []byte, allocator := context.allocator, loc := #caller_location) -> (res: string, err: mem.Allocator_Error) #optional_allocator_error {
- c := make([]byte, len(s)+1, allocator, loc) or_return
- copy(c, s)
- c[len(s)] = 0
- return string(c[:len(s)]), nil
- }
- /*
- Clones a cstring `s` as a string
- *Allocates Using Provided Allocator*
- Inputs:
- - s: The cstring to be cloned
- - allocator: (default: context.allocator)
- - loc: The caller location for debugging purposes (default: `#caller_location`)
- Returns:
- - res: The cloned string from the cstring
- - err: An optional allocator error if one occured, `nil` otherwise
- */
- clone_from_cstring :: proc(s: cstring, allocator := context.allocator, loc := #caller_location) -> (res: string, err: mem.Allocator_Error) #optional_allocator_error {
- return clone(string(s), allocator, loc)
- }
- /*
- Clones a string from a byte pointer `ptr` and a byte length `len`
- *Allocates Using Provided Allocator*
- Inputs:
- - ptr: A pointer to the start of the byte sequence
- - len: The length of the byte sequence
- - allocator: (default: context.allocator)
- - loc: The caller location for debugging purposes (default: `#caller_location`)
- NOTE: Same as `string_from_ptr`, but perform an additional `clone` operation
- Returns:
- - res: The cloned string from the byte pointer and length
- - err: An optional allocator error if one occured, `nil` otherwise
- */
- clone_from_ptr :: proc(ptr: ^byte, len: int, allocator := context.allocator, loc := #caller_location) -> (res: string, err: mem.Allocator_Error) #optional_allocator_error {
- s := string_from_ptr(ptr, len)
- return clone(s, allocator, loc)
- }
- // Overloaded procedure to clone from a string, `[]byte`, `cstring` or a `^byte` + length
- clone_from :: proc{
- clone,
- clone_from_bytes,
- clone_from_cstring,
- clone_from_ptr,
- }
- /*
- Clones a string from a null-terminated cstring `ptr` and a byte length `len`
- *Allocates Using Provided Allocator*
- Inputs:
- - ptr: A pointer to the start of the null-terminated cstring
- - len: The byte length of the cstring
- - allocator: (default: context.allocator)
- - loc: The caller location for debugging purposes (default: `#caller_location`)
- NOTE: Truncates at the first null-byte encountered or the byte length.
- Returns:
- - res: The cloned string from the null-terminated cstring and byte length
- - err: An optional allocator error if one occured, `nil` otherwise
- */
- clone_from_cstring_bounded :: proc(ptr: cstring, len: int, allocator := context.allocator, loc := #caller_location) -> (res: string, err: mem.Allocator_Error) #optional_allocator_error {
- s := string_from_ptr((^u8)(ptr), len)
- s = truncate_to_byte(s, 0)
- return clone(s, allocator, loc)
- }
- /*
- Compares two strings, returning a value representing which one comes first lexicographically.
- -1 for `lhs`; 1 for `rhs`, or 0 if they are equal.
- Inputs:
- - lhs: First string for comparison
- - rhs: Second string for comparison
- Returns:
- - result: `-1` if `lhs` comes first, `1` if `rhs` comes first, or `0` if they are equal
- */
- compare :: proc(lhs, rhs: string) -> (result: int) {
- return mem.compare(transmute([]byte)lhs, transmute([]byte)rhs)
- }
- /*
- Checks if rune `r` in the string `s`
- Inputs:
- - s: The input string
- - r: The rune to search for
- Returns:
- - result: `true` if the rune `r` in the string `s`, `false` otherwise
- */
- contains_rune :: proc(s: string, r: rune) -> (result: bool) {
- for c in s {
- if c == r {
- return true
- }
- }
- return false
- }
- /*
- Returns true when the string `substr` is contained inside the string `s`
- Inputs:
- - s: The input string
- - substr: The substring to search for
- Returns:
- - res: `true` if `substr` is contained inside the string `s`, `false` otherwise
- Example:
- import "core:fmt"
- import "core:strings"
- contains_example :: proc() {
- fmt.println(strings.contains("testing", "test"))
- fmt.println(strings.contains("testing", "ing"))
- fmt.println(strings.contains("testing", "text"))
- }
- Output:
- true
- true
- false
- */
- contains :: proc(s, substr: string) -> (res: bool) {
- return index(s, substr) >= 0
- }
- /*
- Returns `true` when the string `s` contains any of the characters inside the string `chars`
- Inputs:
- - s: The input string
- - chars: The characters to search for
- Returns:
- - res: `true` if the string `s` contains any of the characters in `chars`, `false` otherwise
- Example:
- import "core:fmt"
- import "core:strings"
- contains_any_example :: proc() {
- fmt.println(strings.contains_any("test", "test"))
- fmt.println(strings.contains_any("test", "ts"))
- fmt.println(strings.contains_any("test", "et"))
- fmt.println(strings.contains_any("test", "a"))
- }
- Output:
- true
- true
- true
- false
- */
- contains_any :: proc(s, chars: string) -> (res: bool) {
- return index_any(s, chars) >= 0
- }
- /*
- Returns the UTF-8 rune count of the string `s`
- Inputs:
- - s: The input string
- Returns:
- - res: The UTF-8 rune count of the string `s`
- Example:
- import "core:fmt"
- import "core:strings"
- rune_count_example :: proc() {
- fmt.println(strings.rune_count("test"))
- fmt.println(strings.rune_count("testö")) // where len("testö") == 6
- }
- Output:
- 4
- 5
- */
- rune_count :: proc(s: string) -> (res: int) {
- return utf8.rune_count_in_string(s)
- }
- /*
- Returns whether the strings `u` and `v` are the same alpha characters, ignoring different casings
- Works with UTF-8 string content
- Inputs:
- - u: The first string for comparison
- - v: The second string for comparison
- Returns:
- - res: `true` if the strings `u` and `v` are the same alpha characters (ignoring case)
- Example:
- import "core:fmt"
- import "core:strings"
- equal_fold_example :: proc() {
- fmt.println(strings.equal_fold("test", "test"))
- fmt.println(strings.equal_fold("Test", "test"))
- fmt.println(strings.equal_fold("Test", "tEsT"))
- fmt.println(strings.equal_fold("test", "tes"))
- }
- Output:
- true
- true
- true
- false
- */
- equal_fold :: proc(u, v: string) -> (res: bool) {
- s, t := u, v
- loop: for s != "" && t != "" {
- sr, tr: rune
- if s[0] < utf8.RUNE_SELF {
- sr, s = rune(s[0]), s[1:]
- } else {
- r, size := utf8.decode_rune_in_string(s)
- sr, s = r, s[size:]
- }
- if t[0] < utf8.RUNE_SELF {
- tr, t = rune(t[0]), t[1:]
- } else {
- r, size := utf8.decode_rune_in_string(t)
- tr, t = r, t[size:]
- }
- if tr == sr { // easy case
- continue loop
- }
- if tr < sr {
- tr, sr = sr, tr
- }
- if tr < utf8.RUNE_SELF {
- switch sr {
- case 'A'..='Z':
- if tr == (sr+'a')-'A' {
- continue loop
- }
- }
- return false
- }
- // TODO(bill): Unicode folding
- return false
- }
- return s == t
- }
- /*
- Returns the prefix length common between strings `a` and `b`
- Inputs:
- - a: The first input string
- - b: The second input string
- Returns:
- - n: The prefix length common between strings `a` and `b`
- Example:
- import "core:fmt"
- import "core:strings"
- prefix_length_example :: proc() {
- fmt.println(strings.prefix_length("testing", "test"))
- fmt.println(strings.prefix_length("testing", "te"))
- fmt.println(strings.prefix_length("telephone", "te"))
- fmt.println(strings.prefix_length("testing", "est"))
- }
- Output:
- 4
- 2
- 2
- 0
- */
- prefix_length :: proc(a, b: string) -> (n: int) {
- _len := min(len(a), len(b))
- // Scan for matches including partial codepoints.
- #no_bounds_check for n < _len && a[n] == b[n] {
- n += 1
- }
- // Now scan to ignore partial codepoints.
- if n > 0 {
- s := a[:n]
- n = 0
- for {
- r0, w := utf8.decode_rune(s[n:])
- if r0 != utf8.RUNE_ERROR {
- n += w
- } else {
- break
- }
- }
- }
- return
- }
- /*
- Determines if a string `s` starts with a given `prefix`
- Inputs:
- - s: The string to check for the `prefix`
- - prefix: The prefix to look for
- Returns:
- - result: `true` if the string `s` starts with the `prefix`, otherwise `false`
- Example:
- import "core:fmt"
- import "core:strings"
- has_prefix_example :: proc() {
- fmt.println(strings.has_prefix("testing", "test"))
- fmt.println(strings.has_prefix("testing", "te"))
- fmt.println(strings.has_prefix("telephone", "te"))
- fmt.println(strings.has_prefix("testing", "est"))
- }
- Output:
- true
- true
- true
- false
- */
- has_prefix :: proc(s, prefix: string) -> (result: bool) {
- return len(s) >= len(prefix) && s[0:len(prefix)] == prefix
- }
- /*
- Determines if a string `s` ends with a given `suffix`
- Inputs:
- - s: The string to check for the `suffix`
- - suffix: The suffix to look for
- Returns:
- - result: `true` if the string `s` ends with the `suffix`, otherwise `false`
- Example:
- import "core:fmt"
- import "core:strings"
- has_suffix_example :: proc() {
- fmt.println(strings.has_suffix("todo.txt", ".txt"))
- fmt.println(strings.has_suffix("todo.doc", ".txt"))
- fmt.println(strings.has_suffix("todo.doc.txt", ".txt"))
- }
- Output:
- true
- false
- true
- */
- has_suffix :: proc(s, suffix: string) -> (result: bool) {
- return len(s) >= len(suffix) && s[len(s)-len(suffix):] == suffix
- }
- /*
- Joins a slice of strings `a` with a `sep` string
- *Allocates Using Provided Allocator*
- Inputs:
- - a: A slice of strings to join
- - sep: The separator string
- - allocator: (default is context.allocator)
- Returns:
- - res: A combined string from the slice of strings `a` separated with the `sep` string
- - err: An optional allocator error if one occured, `nil` otherwise
- Example:
- import "core:fmt"
- import "core:strings"
- join_example :: proc() {
- a := [?]string { "a", "b", "c" }
- fmt.println(strings.join(a[:], " "))
- fmt.println(strings.join(a[:], "-"))
- fmt.println(strings.join(a[:], "..."))
- }
- Output:
- a b c
- a-b-c
- a...b...c
- */
- join :: proc(a: []string, sep: string, allocator := context.allocator, loc := #caller_location) -> (res: string, err: mem.Allocator_Error) #optional_allocator_error {
- if len(a) == 0 {
- return "", nil
- }
- n := len(sep) * (len(a) - 1)
- for s in a {
- n += len(s)
- }
- b := make([]byte, n, allocator, loc) or_return
- i := copy(b, a[0])
- for s in a[1:] {
- i += copy(b[i:], sep)
- i += copy(b[i:], s)
- }
- return string(b), nil
- }
- /*
- Joins a slice of strings `a` with a `sep` string, returns an error on allocation failure
- *Allocates Using Provided Allocator*
- Inputs:
- - a: A slice of strings to join
- - sep: The separator string
- - allocator: (default is context.allocator)
- Returns:
- - str: A combined string from the slice of strings `a` separated with the `sep` string
- - err: An allocator error if one occured, `nil` otherwise
- */
- @(deprecated="Prefer join. It now returns an optional allocator error")
- join_safe :: proc(a: []string, sep: string, allocator := context.allocator) -> (res: string, err: mem.Allocator_Error) {
- return join(a, sep, allocator)
- }
- /*
- Returns a combined string from the slice of strings `a` without a separator
- *Allocates Using Provided Allocator*
- Inputs:
- - a: A slice of strings to concatenate
- - allocator: (default is context.allocator)
- Returns:
- - res: The concatenated string
- - err: An optional allocator error if one occured, `nil` otherwise
- Example:
- import "core:fmt"
- import "core:strings"
- concatenate_example :: proc() {
- a := [?]string { "a", "b", "c" }
- fmt.println(strings.concatenate(a[:]))
- }
- Output:
- abc
- */
- concatenate :: proc(a: []string, allocator := context.allocator, loc := #caller_location) -> (res: string, err: mem.Allocator_Error) #optional_allocator_error {
- if len(a) == 0 {
- return "", nil
- }
- n := 0
- for s in a {
- n += len(s)
- }
- b := make([]byte, n, allocator, loc) or_return
- i := 0
- for s in a {
- i += copy(b[i:], s)
- }
- return string(b), nil
- }
- /*
- Returns a combined string from the slice of strings `a` without a separator, or an error if allocation fails
- *Allocates Using Provided Allocator*
- Inputs:
- - a: A slice of strings to concatenate
- - allocator: (default is context.allocator)
- Returns:
- The concatenated string, and an error if allocation fails
- */
- @(deprecated="Prefer concatenate. It now returns an optional allocator error")
- concatenate_safe :: proc(a: []string, allocator := context.allocator) -> (res: string, err: mem.Allocator_Error) {
- return concatenate(a, allocator)
- }
- /*
- Returns a substring of the input string `s` with the specified rune offset and length
- *Allocates Using Provided Allocator*
- Inputs:
- - s: The input string to cut
- - rune_offset: The starting rune index (default is 0). In runes, not bytes.
- - rune_length: The number of runes to include in the substring (default is 0, which returns the remainder of the string). In runes, not bytes.
- - allocator: (default is context.allocator)
- Returns:
- - res: The substring
- - err: An optional allocator error if one occured, `nil` otherwise
- Example:
- import "core:fmt"
- import "core:strings"
- cut_example :: proc() {
- fmt.println(strings.cut("some example text", 0, 4)) // -> "some"
- fmt.println(strings.cut("some example text", 2, 2)) // -> "me"
- fmt.println(strings.cut("some example text", 5, 7)) // -> "example"
- }
- Output:
- some
- me
- example
- */
- cut :: proc(s: string, rune_offset := int(0), rune_length := int(0), allocator := context.allocator, loc := #caller_location) -> (res: string, err: mem.Allocator_Error) #optional_allocator_error {
- s := s; rune_length := rune_length
- context.allocator = allocator
- // If we signal that we want the entire remainder (length <= 0) *and*
- // the offset is zero, then we can early out by cloning the input
- if rune_offset == 0 && rune_length <= 0 {
- return clone(s)
- }
- // We need to know if we have enough runes to cover offset + length.
- rune_count := utf8.rune_count_in_string(s)
- // We're asking for a substring starting after the end of the input string.
- // That's just an empty string.
- if rune_offset >= rune_count {
- return "", nil
- }
- // If we don't specify the length of the substring, use the remainder.
- if rune_length <= 0 {
- rune_length = rune_count - rune_offset
- }
- // We don't yet know how many bytes we need exactly.
- // But we do know it's bounded by the number of runes * 4 bytes,
- // and can be no more than the size of the input string.
- bytes_needed := min(rune_length * 4, len(s))
- buf := make([]u8, bytes_needed, allocator, loc) or_return
- byte_offset := 0
- for i := 0; i < rune_count; i += 1 {
- _, w := utf8.decode_rune_in_string(s)
- // If the rune is part of the substring, copy it to the output buffer.
- if i >= rune_offset {
- for j := 0; j < w; j += 1 {
- buf[byte_offset+j] = s[j]
- }
- byte_offset += w
- }
- // We're done if we reach the end of the input string, *or*
- // if we've reached a specified length in runes.
- if rune_length > 0 {
- if i == rune_offset + rune_length - 1 { break }
- }
- s = s[w:]
- }
- return string(buf[:byte_offset]), nil
- }
- /*
- Splits the input string `s` into a slice of substrings separated by the specified `sep` string
- *Allocates Using Provided Allocator*
- *Used Internally - Private Function*
- Inputs:
- - s: The input string to split
- - sep: The separator string
- - sep_save: A flag determining if the separator should be saved in the resulting substrings
- - n: The maximum number of substrings to return, returns `nil` without alloc when `n=0`
- - allocator: (default is context.allocator)
- NOTE: Allocation occurs for the array, the splits are all views of the original string.
- Returns:
- - res: The slice of substrings
- - err: An optional allocator error if one occured, `nil` otherwise
- */
- @private
- _split :: proc(s_, sep: string, sep_save, n_: int, allocator := context.allocator, loc := #caller_location) -> (res: []string, err: mem.Allocator_Error) {
- s, n := s_, n_
- if n == 0 {
- return nil, nil
- }
- if sep == "" {
- l := utf8.rune_count_in_string(s)
- if n < 0 || n > l {
- n = l
- }
- res := make([]string, n, allocator, loc) or_return
- for i := 0; i < n-1; i += 1 {
- _, w := utf8.decode_rune_in_string(s)
- res[i] = s[:w]
- s = s[w:]
- }
- if n > 0 {
- res[n-1] = s
- }
- return res[:], nil
- }
- if n < 0 {
- n = count(s, sep) + 1
- }
- res = make([]string, n, allocator, loc) or_return
- n -= 1
- i := 0
- for ; i < n; i += 1 {
- m := index(s, sep)
- if m < 0 {
- break
- }
- res[i] = s[:m+sep_save]
- s = s[m+len(sep):]
- }
- res[i] = s
- return res[:i+1], nil
- }
- /*
- Splits a string into parts based on a separator.
- *Allocates Using Provided Allocator*
- Inputs:
- - s: The string to split.
- - sep: The separator string used to split the input string.
- - allocator: (default is context.allocator).
- Returns:
- - res: The slice of strings, each representing a part of the split string.
- - err: An optional allocator error if one occured, `nil` otherwise
- NOTE: Allocation occurs for the array, the splits are all views of the original string.
- Example:
- import "core:fmt"
- import "core:strings"
- split_example :: proc() {
- s := "aaa.bbb.ccc.ddd.eee" // 5 parts
- ss := strings.split(s, ".")
- fmt.println(ss)
- }
- Output:
- ["aaa", "bbb", "ccc", "ddd", "eee"]
- */
- split :: proc(s, sep: string, allocator := context.allocator) -> (res: []string, err: mem.Allocator_Error) #optional_allocator_error {
- return _split(s, sep, 0, -1, allocator)
- }
- /*
- Splits a string into parts based on a separator. If n < count of seperators, the remainder of the string is returned in the last entry.
- *Allocates Using Provided Allocator*
- Inputs:
- - s: The string to split.
- - sep: The separator string used to split the input string.
- - n: The maximum amount of parts to split the string into.
- - allocator: (default is context.allocator)
- Returns:
- - res: The slice of strings, each representing a part of the split string.
- - err: An optional allocator error if one occured, `nil` otherwise
- NOTE: Allocation occurs for the array, the splits are all views of the original string.
- Example:
- import "core:fmt"
- import "core:strings"
- split_n_example :: proc() {
- s := "aaa.bbb.ccc.ddd.eee" // 5 parts present
- ss := strings.split_n(s, ".",3) // total of 3 wanted
- fmt.println(ss)
- }
- Output:
- ["aaa", "bbb", "ccc.ddd.eee"]
- */
- split_n :: proc(s, sep: string, n: int, allocator := context.allocator) -> (res: []string, err: mem.Allocator_Error) #optional_allocator_error {
- return _split(s, sep, 0, n, allocator)
- }
- /*
- Splits a string into parts after the separator, retaining it in the substrings.
- *Allocates Using Provided Allocator*
- Inputs:
- - s: The string to split.
- - sep: The separator string used to split the input string.
- - allocator: (default is context.allocator).
- Returns:
- - res: The slice of strings, each representing a part of the split string after the separator
- - err: An optional allocator error if one occured, `nil` otherwise
- NOTE: Allocation occurs for the array, the splits are all views of the original string.
- Example:
- import "core:fmt"
- import "core:strings"
- split_after_example :: proc() {
- a := "aaa.bbb.ccc.ddd.eee" // 5 parts
- aa := strings.split_after(a, ".")
- fmt.println(aa)
- }
- Output:
- ["aaa.", "bbb.", "ccc.", "ddd.", "eee"]
- */
- split_after :: proc(s, sep: string, allocator := context.allocator) -> (res: []string, err: mem.Allocator_Error) #optional_allocator_error {
- return _split(s, sep, len(sep), -1, allocator)
- }
- /*
- Splits a string into a total of `n` parts after the separator.
- *Allocates Using Provided Allocator*
- Inputs:
- - s: The string to split.
- - sep: The separator string used to split the input string.
- - n: The maximum number of parts to split the string into.
- - allocator: (default is context.allocator)
- Returns:
- - res: The slice of strings with `n` parts or fewer if there weren't
- - err: An optional allocator error if one occured, `nil` otherwise
- NOTE: Allocation occurs for the array, the splits are all views of the original string.
- Example:
- import "core:fmt"
- import "core:strings"
- split_after_n_example :: proc() {
- a := "aaa.bbb.ccc.ddd.eee"
- aa := strings.split_after_n(a, ".", 3)
- fmt.println(aa)
- }
- Output:
- ["aaa.", "bbb.", "ccc.ddd.eee"]
- */
- split_after_n :: proc(s, sep: string, n: int, allocator := context.allocator) -> (res: []string, err: mem.Allocator_Error) #optional_allocator_error {
- return _split(s, sep, len(sep), n, allocator)
- }
- /*
- Searches for the first occurrence of `sep` in the given string and returns the substring
- up to (but not including) the separator, as well as a boolean indicating success.
- *Used Internally - Private Function*
- Inputs:
- - s: Pointer to the input string, which is modified during the search.
- - sep: The separator string to search for.
- - sep_save: Number of characters from the separator to include in the result.
- Returns:
- - res: The resulting substring
- - ok: `true` if an iteration result was returned, `false` if the iterator has reached the end
- */
- @private
- _split_iterator :: proc(s: ^string, sep: string, sep_save: int) -> (res: string, ok: bool) {
- // stop once the string is empty or nil
- if s == nil || len(s^) == 0 {
- return
- }
- if sep == "" {
- res = s[:]
- ok = true
- s^ = s[len(s):]
- return
- }
- m := index(s^, sep)
- if m < 0 {
- // not found
- res = s[:]
- ok = res != ""
- s^ = s[len(s):]
- } else {
- res = s[:m+sep_save]
- ok = true
- s^ = s[m+len(sep):]
- }
- return
- }
- /*
- Splits the input string by the byte separator in an iterator fashion.
- Inputs:
- - s: Pointer to the input string, which is modified during the search.
- - sep: The byte separator to search for.
- Returns:
- - res: The resulting substring
- - ok: `true` if an iteration result was returned, `false` if the iterator has reached the end
- Example:
- import "core:fmt"
- import "core:strings"
- split_by_byte_iterator_example :: proc() {
- text := "a.b.c.d.e"
- for str in strings.split_by_byte_iterator(&text, '.') {
- fmt.println(str) // every loop -> a b c d e
- }
- }
- Output:
- a
- b
- c
- d
- e
- */
- split_by_byte_iterator :: proc(s: ^string, sep: u8) -> (res: string, ok: bool) {
- m := index_byte(s^, sep)
- if m < 0 {
- // not found
- res = s[:]
- ok = res != ""
- s^ = {}
- } else {
- res = s[:m]
- ok = true
- s^ = s[m+1:]
- }
- return
- }
- /*
- Splits the input string by the separator string in an iterator fashion.
- Inputs:
- - s: Pointer to the input string, which is modified during the search.
- - sep: The separator string to search for.
- Returns:
- - res: The resulting substring
- - ok: `true` if an iteration result was returned, `false` if the iterator has reached the end
- Example:
- import "core:fmt"
- import "core:strings"
- split_iterator_example :: proc() {
- text := "a.b.c.d.e"
- for str in strings.split_iterator(&text, ".") {
- fmt.println(str)
- }
- }
- Output:
- a
- b
- c
- d
- e
- */
- split_iterator :: proc(s: ^string, sep: string) -> (res: string, ok: bool) {
- return _split_iterator(s, sep, 0)
- }
- /*
- Splits the input string after every separator string in an iterator fashion.
- Inputs:
- - s: Pointer to the input string, which is modified during the search.
- - sep: The separator string to search for.
- Returns:
- - res: The resulting substring
- - ok: `true` if an iteration result was returned, `false` if the iterator has reached the end
- Example:
- import "core:fmt"
- import "core:strings"
- split_after_iterator_example :: proc() {
- text := "a.b.c.d.e"
- for str in strings.split_after_iterator(&text, ".") {
- fmt.println(str)
- }
- }
- Output:
- a.
- b.
- c.
- d.
- e
- */
- split_after_iterator :: proc(s: ^string, sep: string) -> (res: string, ok: bool) {
- return _split_iterator(s, sep, len(sep))
- }
- /*
- Trims the carriage return character from the end of the input string.
- *Used Internally - Private Function*
- Inputs:
- - s: The input string to trim.
- Returns:
- - res: The trimmed string as a slice of the original.
- */
- @(private)
- _trim_cr :: proc(s: string) -> (res: string) {
- n := len(s)
- if n > 0 {
- if s[n-1] == '\r' {
- return s[:n-1]
- }
- }
- return s
- }
- /*
- Splits the input string at every line break `\n`.
- *Allocates Using Provided Allocator*
- Inputs:
- - s: The input string to split.
- - allocator: (default is context.allocator)
- Returns:
- - res: The slice (allocated) of the split string (slices into original string)
- - err: An optional allocator error if one occured, `nil` otherwise
- Example:
- import "core:fmt"
- import "core:strings"
- split_lines_example :: proc() {
- a := "a\nb\nc\nd\ne"
- b := strings.split_lines(a)
- fmt.println(b)
- }
- Output:
- ["a", "b", "c", "d", "e"]
- */
- split_lines :: proc(s: string, allocator := context.allocator) -> (res: []string, err: mem.Allocator_Error) #optional_allocator_error {
- sep :: "\n"
- lines := _split(s, sep, 0, -1, allocator) or_return
- for &line in lines {
- line = _trim_cr(line)
- }
- return lines, nil
- }
- /*
- Splits the input string at every line break `\n` for `n` parts.
- *Allocates Using Provided Allocator*
- Inputs:
- - s: The input string to split.
- - n: The number of parts to split into.
- - allocator: (default is context.allocator)
- Returns:
- - res: The slice (allocated) of the split string (slices into original string)
- - err: An optional allocator error if one occured, `nil` otherwise
- NOTE: Allocation occurs for the array, the splits are all views of the original string.
- Example:
- import "core:fmt"
- import "core:strings"
- split_lines_n_example :: proc() {
- a := "a\nb\nc\nd\ne"
- b := strings.split_lines_n(a, 3)
- fmt.println(b)
- }
- Output:
- ["a", "b", "c\nd\ne"]
- */
- split_lines_n :: proc(s: string, n: int, allocator := context.allocator) -> (res: []string, err: mem.Allocator_Error) #optional_allocator_error {
- sep :: "\n"
- lines := _split(s, sep, 0, n, allocator) or_return
- for &line in lines {
- line = _trim_cr(line)
- }
- return lines, nil
- }
- /*
- Splits the input string at every line break `\n` leaving the `\n` in the resulting strings.
- *Allocates Using Provided Allocator*
- Inputs:
- - s: The input string to split.
- - allocator: (default is context.allocator)
- Returns:
- - res: The slice (allocated) of the split string (slices into original string), with `\n` included
- - err: An optional allocator error if one occured, `nil` otherwise
- NOTE: Allocation occurs for the array, the splits are all views of the original string.
- Example:
- import "core:fmt"
- import "core:strings"
- split_lines_after_example :: proc() {
- a := "a\nb\nc\nd\ne"
- b := strings.split_lines_after(a)
- fmt.println(b)
- }
- Output:
- ["a\n", "b\n", "c\n", "d\n", "e"]
- */
- split_lines_after :: proc(s: string, allocator := context.allocator) -> (res: []string, err: mem.Allocator_Error) #optional_allocator_error {
- sep :: "\n"
- lines := _split(s, sep, len(sep), -1, allocator) or_return
- for &line in lines {
- line = _trim_cr(line)
- }
- return lines, nil
- }
- /*
- Splits the input string at every line break `\n` leaving the `\n` in the resulting strings.
- Only runs for n parts.
- *Allocates Using Provided Allocator*
- Inputs:
- - s: The input string to split.
- - n: The number of parts to split into.
- - allocator: (default is context.allocator)
- Returns:
- - res: The slice (allocated) of the split string (slices into original string), with `\n` included
- - err: An optional allocator error if one occured, `nil` otherwise
- NOTE: Allocation occurs for the array, the splits are all views of the original string.
- Example:
- import "core:fmt"
- import "core:strings"
- split_lines_after_n_example :: proc() {
- a := "a\nb\nc\nd\ne"
- b := strings.split_lines_after_n(a, 3)
- fmt.println(b)
- }
- Output:
- ["a\n", "b\n", "c\nd\ne"]
- */
- split_lines_after_n :: proc(s: string, n: int, allocator := context.allocator) -> (res: []string, err: mem.Allocator_Error) #optional_allocator_error {
- sep :: "\n"
- lines := _split(s, sep, len(sep), n, allocator) or_return
- for &line in lines {
- line = _trim_cr(line)
- }
- return lines, nil
- }
- /*
- Splits the input string at every line break `\n`.
- Returns the current split string every iteration until the string is consumed.
- Inputs:
- - s: Pointer to the input string, which is modified during the search.
- Returns:
- - line: The resulting substring
- - ok: `true` if an iteration result was returned, `false` if the iterator has reached the end
- Example:
- import "core:fmt"
- import "core:strings"
- split_lines_iterator_example :: proc() {
- text := "a\nb\nc\nd\ne"
- for str in strings.split_lines_iterator(&text) {
- fmt.print(str) // every loop -> a b c d e
- }
- fmt.print("\n")
- }
- Output:
- abcde
- */
- split_lines_iterator :: proc(s: ^string) -> (line: string, ok: bool) {
- sep :: "\n"
- line = _split_iterator(s, sep, 0) or_return
- return _trim_cr(line), true
- }
- /*
- Splits the input string at every line break `\n`.
- Returns the current split string with line breaks included every iteration until the string is consumed.
- Inputs:
- - s: Pointer to the input string, which is modified during the search.
- Returns:
- - line: The resulting substring with line breaks included
- - ok: `true` if an iteration result was returned, `false` if the iterator has reached the end
- Example:
- import "core:fmt"
- import "core:strings"
- split_lines_after_iterator_example :: proc() {
- text := "a\nb\nc\nd\ne\n"
- for str in strings.split_lines_after_iterator(&text) {
- fmt.print(str) // every loop -> a\n b\n c\n d\n e\n
- }
- }
- Output:
- a
- b
- c
- d
- e
- */
- split_lines_after_iterator :: proc(s: ^string) -> (line: string, ok: bool) {
- sep :: "\n"
- line = _split_iterator(s, sep, len(sep)) or_return
- return _trim_cr(line), true
- }
- /*
- Returns the byte offset of the first byte `c` in the string s it finds, -1 when not found.
- NOTE: Can't find UTF-8 based runes.
- Inputs:
- - s: The input string to search in.
- - c: The byte to search for.
- Returns:
- - res: The byte offset of the first occurrence of `c` in `s`, or -1 if not found.
- Example:
- import "core:fmt"
- import "core:strings"
- index_byte_example :: proc() {
- fmt.println(strings.index_byte("test", 't'))
- fmt.println(strings.index_byte("test", 'e'))
- fmt.println(strings.index_byte("test", 'x'))
- fmt.println(strings.index_byte("teäst", 'ä'))
- }
- Output:
- 0
- 1
- -1
- -1
- */
- index_byte :: proc(s: string, c: byte) -> (res: int) {
- for i := 0; i < len(s); i += 1 {
- if s[i] == c {
- return i
- }
- }
- return -1
- }
- /*
- Returns the byte offset of the last byte `c` in the string `s`, -1 when not found.
- Inputs:
- - s: The input string to search in.
- - c: The byte to search for.
- Returns:
- - res: The byte offset of the last occurrence of `c` in `s`, or -1 if not found.
- NOTE: Can't find UTF-8 based runes.
- Example:
- import "core:fmt"
- import "core:strings"
- last_index_byte_example :: proc() {
- fmt.println(strings.last_index_byte("test", 't'))
- fmt.println(strings.last_index_byte("test", 'e'))
- fmt.println(strings.last_index_byte("test", 'x'))
- fmt.println(strings.last_index_byte("teäst", 'ä'))
- }
- Output:
- 3
- 1
- -1
- -1
- */
- last_index_byte :: proc(s: string, c: byte) -> (res: int) {
- for i := len(s)-1; i >= 0; i -= 1 {
- if s[i] == c {
- return i
- }
- }
- return -1
- }
- /*
- Returns the byte offset of the first rune `r` in the string `s` it finds, -1 when not found.
- Invalid runes return -1
- Inputs:
- - s: The input string to search in.
- - r: The rune to search for.
- Returns:
- - res: The byte offset of the first occurrence of `r` in `s`, or -1 if not found.
- Example:
- import "core:fmt"
- import "core:strings"
- index_rune_example :: proc() {
- fmt.println(strings.index_rune("abcädef", 'x'))
- fmt.println(strings.index_rune("abcädef", 'a'))
- fmt.println(strings.index_rune("abcädef", 'b'))
- fmt.println(strings.index_rune("abcädef", 'c'))
- fmt.println(strings.index_rune("abcädef", 'ä'))
- fmt.println(strings.index_rune("abcädef", 'd'))
- fmt.println(strings.index_rune("abcädef", 'e'))
- fmt.println(strings.index_rune("abcädef", 'f'))
- }
- Output:
- -1
- 0
- 1
- 2
- 3
- 5
- 6
- 7
- */
- index_rune :: proc(s: string, r: rune) -> (res: int) {
- switch {
- case u32(r) < utf8.RUNE_SELF:
- return index_byte(s, byte(r))
- case r == utf8.RUNE_ERROR:
- for c, i in s {
- if c == utf8.RUNE_ERROR {
- return i
- }
- }
- return -1
- case !utf8.valid_rune(r):
- return -1
- }
- b, w := utf8.encode_rune(r)
- return index(s, string(b[:w]))
- }
- @private PRIME_RABIN_KARP :: 16777619
- /*
- Returns the byte offset of the string `substr` in the string `s`, -1 when not found.
- Inputs:
- - s: The input string to search in.
- - substr: The substring to search for.
- Returns:
- - res: The byte offset of the first occurrence of `substr` in `s`, or -1 if not found.
- Example:
- import "core:fmt"
- import "core:strings"
- index_example :: proc() {
- fmt.println(strings.index("test", "t"))
- fmt.println(strings.index("test", "te"))
- fmt.println(strings.index("test", "st"))
- fmt.println(strings.index("test", "tt"))
- }
- Output:
- 0
- 0
- 2
- -1
- */
- index :: proc(s, substr: string) -> (res: int) {
- hash_str_rabin_karp :: proc(s: string) -> (hash: u32 = 0, pow: u32 = 1) {
- for i := 0; i < len(s); i += 1 {
- hash = hash*PRIME_RABIN_KARP + u32(s[i])
- }
- sq := u32(PRIME_RABIN_KARP)
- for i := len(s); i > 0; i >>= 1 {
- if (i & 1) != 0 {
- pow *= sq
- }
- sq *= sq
- }
- return
- }
- n := len(substr)
- switch {
- case n == 0:
- return 0
- case n == 1:
- return index_byte(s, substr[0])
- case n == len(s):
- if s == substr {
- return 0
- }
- return -1
- case n > len(s):
- return -1
- }
- hash, pow := hash_str_rabin_karp(substr)
- h: u32
- for i := 0; i < n; i += 1 {
- h = h*PRIME_RABIN_KARP + u32(s[i])
- }
- if h == hash && s[:n] == substr {
- return 0
- }
- for i := n; i < len(s); /**/ {
- h *= PRIME_RABIN_KARP
- h += u32(s[i])
- h -= pow * u32(s[i-n])
- i += 1
- if h == hash && s[i-n:i] == substr {
- return i - n
- }
- }
- return -1
- }
- /*
- Returns the last byte offset of the string `substr` in the string `s`, -1 when not found.
- Inputs:
- - s: The input string to search in.
- - substr: The substring to search for.
- Returns:
- - res: The byte offset of the last occurrence of `substr` in `s`, or -1 if not found.
- Example:
- import "core:fmt"
- import "core:strings"
- last_index_example :: proc() {
- fmt.println(strings.last_index("test", "t"))
- fmt.println(strings.last_index("test", "te"))
- fmt.println(strings.last_index("test", "st"))
- fmt.println(strings.last_index("test", "tt"))
- }
- Output:
- 3
- 0
- 2
- -1
- */
- last_index :: proc(s, substr: string) -> (res: int) {
- hash_str_rabin_karp_reverse :: proc(s: string) -> (hash: u32 = 0, pow: u32 = 1) {
- for i := len(s) - 1; i >= 0; i -= 1 {
- hash = hash*PRIME_RABIN_KARP + u32(s[i])
- }
- sq := u32(PRIME_RABIN_KARP)
- for i := len(s); i > 0; i >>= 1 {
- if (i & 1) != 0 {
- pow *= sq
- }
- sq *= sq
- }
- return
- }
- n := len(substr)
- switch {
- case n == 0:
- return len(s)
- case n == 1:
- return last_index_byte(s, substr[0])
- case n == len(s):
- return 0 if substr == s else -1
- case n > len(s):
- return -1
- }
- hash, pow := hash_str_rabin_karp_reverse(substr)
- last := len(s) - n
- h: u32
- for i := len(s)-1; i >= last; i -= 1 {
- h = h*PRIME_RABIN_KARP + u32(s[i])
- }
- if h == hash && s[last:] == substr {
- return last
- }
- for i := last-1; i >= 0; i -= 1 {
- h *= PRIME_RABIN_KARP
- h += u32(s[i])
- h -= pow * u32(s[i+n])
- if h == hash && s[i:i+n] == substr {
- return i
- }
- }
- return -1
- }
- /*
- Returns the index of any first char of `chars` found in `s`, -1 if not found.
- Inputs:
- - s: The input string to search in.
- - chars: The characters to look for
- Returns:
- - res: The index of the first character of `chars` found in `s`, or -1 if not found.
- Example:
- import "core:fmt"
- import "core:strings"
- index_any_example :: proc() {
- fmt.println(strings.index_any("test", "s"))
- fmt.println(strings.index_any("test", "se"))
- fmt.println(strings.index_any("test", "et"))
- fmt.println(strings.index_any("test", "set"))
- fmt.println(strings.index_any("test", "x"))
- }
- Output:
- 2
- 1
- 0
- 0
- -1
- */
- index_any :: proc(s, chars: string) -> (res: int) {
- if chars == "" {
- return -1
- }
-
- if len(chars) == 1 {
- r := rune(chars[0])
- if r >= utf8.RUNE_SELF {
- r = utf8.RUNE_ERROR
- }
- return index_rune(s, r)
- }
-
- if len(s) > 8 {
- if as, ok := ascii_set_make(chars); ok {
- for i in 0..<len(s) {
- if ascii_set_contains(as, s[i]) {
- return i
- }
- }
- return -1
- }
- }
- for c, i in s {
- if index_rune(chars, c) >= 0 {
- return i
- }
- }
- return -1
- }
- /*
- Finds the last occurrence of any character in `chars` within `s`. Iterates in reverse.
- Inputs:
- - s: The string to search in
- - chars: The characters to look for
- Returns:
- - res: The index of the last matching character, or -1 if not found
- Example:
- import "core:fmt"
- import "core:strings"
- last_index_any_example :: proc() {
- fmt.println(strings.last_index_any("test", "s"))
- fmt.println(strings.last_index_any("test", "se"))
- fmt.println(strings.last_index_any("test", "et"))
- fmt.println(strings.last_index_any("test", "set"))
- fmt.println(strings.last_index_any("test", "x"))
- }
- Output:
- 2
- 2
- 3
- 3
- -1
- */
- last_index_any :: proc(s, chars: string) -> (res: int) {
- if chars == "" {
- return -1
- }
-
- if len(s) == 1 {
- r := rune(s[0])
- if r >= utf8.RUNE_SELF {
- r = utf8.RUNE_ERROR
- }
- return index_rune(chars, r)
- }
-
- if len(s) > 8 {
- if as, ok := ascii_set_make(chars); ok {
- for i := len(s)-1; i >= 0; i -= 1 {
- if ascii_set_contains(as, s[i]) {
- return i
- }
- }
- return -1
- }
- }
-
- if len(chars) == 1 {
- r := rune(chars[0])
- if r >= utf8.RUNE_SELF {
- r = utf8.RUNE_ERROR
- }
- for i := len(s); i > 0; /**/ {
- c, w := utf8.decode_last_rune_in_string(s[:i])
- i -= w
- if c == r {
- return i
- }
- }
- return -1
- }
- for i := len(s); i > 0; /**/ {
- r, w := utf8.decode_last_rune_in_string(s[:i])
- i -= w
- if index_rune(chars, r) >= 0 {
- return i
- }
- }
- return -1
- }
- /*
- Finds the first occurrence of any substring in `substrs` within `s`
- Inputs:
- - s: The string to search in
- - substrs: The substrings to look for
- Returns:
- - idx: the index of the first matching substring
- - width: the length of the found substring
- */
- index_multi :: proc(s: string, substrs: []string) -> (idx: int, width: int) {
- idx = -1
- if s == "" || len(substrs) <= 0 {
- return
- }
- // disallow "" substr
- for substr in substrs {
- if len(substr) == 0 {
- return
- }
- }
- lowest_index := len(s)
- found := false
- for substr in substrs {
- if i := index(s, substr); i >= 0 {
- if i < lowest_index {
- lowest_index = i
- width = len(substr)
- found = true
- }
- }
- }
- if found {
- idx = lowest_index
- }
- return
- }
- /*
- Counts the number of non-overlapping occurrences of `substr` in `s`
- Inputs:
- - s: The string to search in
- - substr: The substring to count
- Returns:
- - res: The number of occurrences of `substr` in `s`, returns the rune_count + 1 of the string `s` on empty `substr`
- Example:
- import "core:fmt"
- import "core:strings"
- count_example :: proc() {
- fmt.println(strings.count("abbccc", "a"))
- fmt.println(strings.count("abbccc", "b"))
- fmt.println(strings.count("abbccc", "c"))
- fmt.println(strings.count("abbccc", "ab"))
- fmt.println(strings.count("abbccc", " "))
- }
- Output:
- 1
- 2
- 3
- 1
- 0
- */
- count :: proc(s, substr: string) -> (res: int) {
- if len(substr) == 0 { // special case
- return rune_count(s) + 1
- }
- if len(substr) == 1 {
- c := substr[0]
- switch len(s) {
- case 0:
- return 0
- case 1:
- return int(s[0] == c)
- }
- n := 0
- for i := 0; i < len(s); i += 1 {
- if s[i] == c {
- n += 1
- }
- }
- return n
- }
- // TODO(bill): Use a non-brute for approach
- n := 0
- str := s
- for {
- i := index(str, substr)
- if i == -1 {
- return n
- }
- n += 1
- str = str[i+len(substr):]
- }
- return n
- }
- /*
- Repeats the string `s` `count` times, concatenating the result
- *Allocates Using Provided Allocator*
- Inputs:
- - s: The string to repeat
- - count: The number of times to repeat `s`
- - allocator: (default is context.allocator)
- Returns:
- - res: The concatenated repeated string
- - err: An optional allocator error if one occured, `nil` otherwise
- WARNING: Panics if count < 0
- Example:
- import "core:fmt"
- import "core:strings"
- repeat_example :: proc() {
- fmt.println(strings.repeat("abc", 2))
- }
- Output:
- abcabc
- */
- repeat :: proc(s: string, count: int, allocator := context.allocator, loc := #caller_location) -> (res: string, err: mem.Allocator_Error) #optional_allocator_error {
- if count < 0 {
- panic("strings: negative repeat count")
- } else if count > 0 && (len(s)*count)/count != len(s) {
- panic("strings: repeat count will cause an overflow")
- }
- b := make([]byte, len(s)*count, allocator, loc) or_return
- i := copy(b, s)
- for i < len(b) { // 2^N trick to reduce the need to copy
- copy(b[i:], b[:i])
- i *= 2
- }
- return string(b), nil
- }
- /*
- Replaces all occurrences of `old` in `s` with `new`
- *Allocates Using Provided Allocator*
- Inputs:
- - s: The string to modify
- - old: The substring to replace
- - new: The substring to replace `old` with
- - allocator: The allocator to use for the new string (default is context.allocator)
- Returns:
- - output: The modified string
- - was_allocation: `true` if an allocation occurred during the replacement, `false` otherwise
- Example:
- import "core:fmt"
- import "core:strings"
- replace_all_example :: proc() {
- fmt.println(strings.replace_all("xyzxyz", "xyz", "abc"))
- fmt.println(strings.replace_all("xyzxyz", "abc", "xyz"))
- fmt.println(strings.replace_all("xyzxyz", "xy", "z"))
- }
- Output:
- abcabc true
- xyzxyz false
- zzzz true
- */
- replace_all :: proc(s, old, new: string, allocator := context.allocator) -> (output: string, was_allocation: bool) {
- return replace(s, old, new, -1, allocator)
- }
- /*
- Replaces n instances of old in the string s with the new string
- *Allocates Using Provided Allocator*
- Inputs:
- - s: The input string
- - old: The substring to be replaced
- - new: The replacement string
- - n: The number of instances to replace (if `n < 0`, no limit on the number of replacements)
- - allocator: (default: context.allocator)
- Returns:
- - output: The modified string
- - was_allocation: `true` if an allocation occurred during the replacement, `false` otherwise
- Example:
- import "core:fmt"
- import "core:strings"
- replace_example :: proc() {
- fmt.println(strings.replace("xyzxyz", "xyz", "abc", 2))
- fmt.println(strings.replace("xyzxyz", "xyz", "abc", 1))
- fmt.println(strings.replace("xyzxyz", "abc", "xyz", -1))
- fmt.println(strings.replace("xyzxyz", "xy", "z", -1))
- }
- Output:
- abcabc true
- abcxyz true
- xyzxyz false
- zzzz true
- */
- replace :: proc(s, old, new: string, n: int, allocator := context.allocator, loc := #caller_location) -> (output: string, was_allocation: bool) {
- if old == new || n == 0 {
- was_allocation = false
- output = s
- return
- }
- byte_count := n
- if m := count(s, old); m == 0 {
- was_allocation = false
- output = s
- return
- } else if n < 0 || m < n {
- byte_count = m
- }
- t := make([]byte, len(s) + byte_count*(len(new) - len(old)), allocator, loc)
- was_allocation = true
- w := 0
- start := 0
- for i := 0; i < byte_count; i += 1 {
- j := start
- if len(old) == 0 {
- if i > 0 {
- _, width := utf8.decode_rune_in_string(s[start:])
- j += width
- }
- } else {
- j += index(s[start:], old)
- }
- w += copy(t[w:], s[start:j])
- w += copy(t[w:], new)
- start = j + len(old)
- }
- w += copy(t[w:], s[start:])
- output = string(t[0:w])
- return
- }
- /*
- Removes the key string `n` times from the `s` string
- *Allocates Using Provided Allocator*
- Inputs:
- - s: The input string
- - key: The substring to be removed
- - n: The number of instances to remove (if `n < 0`, no limit on the number of removes)
- - allocator: (default: context.allocator)
- Returns:
- - output: The modified string
- - was_allocation: `true` if an allocation occurred during the replacement, `false` otherwise
- Example:
- import "core:fmt"
- import "core:strings"
- remove_example :: proc() {
- fmt.println(strings.remove("abcabc", "abc", 1))
- fmt.println(strings.remove("abcabc", "abc", -1))
- fmt.println(strings.remove("abcabc", "a", -1))
- fmt.println(strings.remove("abcabc", "x", -1))
- }
- Output:
- abc true
- true
- bcbc true
- abcabc false
- */
- remove :: proc(s, key: string, n: int, allocator := context.allocator) -> (output: string, was_allocation: bool) {
- return replace(s, key, "", n, allocator)
- }
- /*
- Removes all the `key` string instances from the `s` string
- *Allocates Using Provided Allocator*
- Inputs:
- - s: The input string
- - key: The substring to be removed
- - allocator: (default: context.allocator)
- Returns:
- - output: The modified string
- - was_allocation: `true` if an allocation occurred during the replacement, `false` otherwise
- Example:
- import "core:fmt"
- import "core:strings"
- remove_all_example :: proc() {
- fmt.println(strings.remove_all("abcabc", "abc"))
- fmt.println(strings.remove_all("abcabc", "a"))
- fmt.println(strings.remove_all("abcabc", "x"))
- }
- Output:
- true
- bcbc true
- abcabc false
- */
- remove_all :: proc(s, key: string, allocator := context.allocator) -> (output: string, was_allocation: bool) {
- return remove(s, key, -1, allocator)
- }
- // Returns true if is an ASCII space character ('\t', '\n', '\v', '\f', '\r', ' ')
- @(private) _ascii_space := [256]bool{'\t' = true, '\n' = true, '\v' = true, '\f' = true, '\r' = true, ' ' = true}
- /*
- Returns true when the `r` rune is an ASCII whitespace character.
- Inputs:
- - r: the rune to test
- Returns:
- -res: `true` if `r` is a whitespace character, `false` if otherwise
- */
- is_ascii_space :: proc(r: rune) -> (res: bool) {
- if r < utf8.RUNE_SELF {
- return _ascii_space[u8(r)]
- }
- return false
- }
- /*
- Returns true when the `r` rune is an ASCII or UTF-8 whitespace character.
- Inputs:
- - r: the rune to test
- Returns:
- -res: `true` if `r` is a whitespace character, `false` if otherwise
- */
- is_space :: proc(r: rune) -> (res: bool) {
- if r < 0x2000 {
- switch r {
- case '\t', '\n', '\v', '\f', '\r', ' ', 0x85, 0xa0, 0x1680:
- return true
- }
- } else {
- if r <= 0x200a {
- return true
- }
- switch r {
- case 0x2028, 0x2029, 0x202f, 0x205f, 0x3000:
- return true
- }
- }
- return false
- }
- /*
- Returns true when the `r` rune is `0x0`
- Inputs:
- - r: the rune to test
- Returns:
- -res: `true` if `r` is `0x0`, `false` if otherwise
- */
- is_null :: proc(r: rune) -> (res: bool) {
- return r == 0x0000
- }
- /*
- Find the index of the first rune `r` in string `s` for which procedure `p` returns the same as truth, or -1 if no such rune appears.
- Inputs:
- - s: The input string
- - p: A procedure that takes a rune and returns a boolean
- - truth: The boolean value to be matched (default: `true`)
- Returns:
- - res: The index of the first matching rune, or -1 if no match was found
- Example:
- import "core:fmt"
- import "core:strings"
- index_proc_example :: proc() {
- call :: proc(r: rune) -> bool {
- return r == 'a'
- }
- fmt.println(strings.index_proc("abcabc", call))
- fmt.println(strings.index_proc("cbacba", call))
- fmt.println(strings.index_proc("cbacba", call, false))
- fmt.println(strings.index_proc("abcabc", call, false))
- fmt.println(strings.index_proc("xyz", call))
- }
- Output:
- 0
- 2
- 0
- 1
- -1
- */
- index_proc :: proc(s: string, p: proc(rune) -> bool, truth := true) -> (res: int) {
- for r, i in s {
- if p(r) == truth {
- return i
- }
- }
- return -1
- }
- // Same as `index_proc`, but the procedure p takes a raw pointer for state
- index_proc_with_state :: proc(s: string, p: proc(rawptr, rune) -> bool, state: rawptr, truth := true) -> (res: int) {
- for r, i in s {
- if p(state, r) == truth {
- return i
- }
- }
- return -1
- }
- // Finds the index of the *last* rune in the string s for which the procedure p returns the same value as truth
- last_index_proc :: proc(s: string, p: proc(rune) -> bool, truth := true) -> (res: int) {
- // TODO(bill): Probably use Rabin-Karp Search
- for i := len(s); i > 0; {
- r, size := utf8.decode_last_rune_in_string(s[:i])
- i -= size
- if p(r) == truth {
- return i
- }
- }
- return -1
- }
- // Same as `index_proc_with_state`, runs through the string in reverse
- last_index_proc_with_state :: proc(s: string, p: proc(rawptr, rune) -> bool, state: rawptr, truth := true) -> (res: int) {
- // TODO(bill): Probably use Rabin-Karp Search
- for i := len(s); i > 0; {
- r, size := utf8.decode_last_rune_in_string(s[:i])
- i -= size
- if p(state, r) == truth {
- return i
- }
- }
- return -1
- }
- /*
- Trims the input string `s` from the left until the procedure `p` returns false
- Inputs:
- - s: The input string
- - p: A procedure that takes a rune and returns a boolean
- Returns:
- - res: The trimmed string as a slice of the original
- Example:
- import "core:fmt"
- import "core:strings"
- trim_left_proc_example :: proc() {
- find :: proc(r: rune) -> bool {
- return r == 'x'
- }
- fmt.println(strings.trim_left_proc("xxxxxxtesting", find))
- }
- Output:
- testing
- */
- trim_left_proc :: proc(s: string, p: proc(rune) -> bool) -> (res: string) {
- i := index_proc(s, p, false)
- if i == -1 {
- return ""
- }
- return s[i:]
- }
- /*
- Trims the input string `s` from the left until the procedure `p` with state returns false
- Inputs:
- - s: The input string
- - p: A procedure that takes a raw pointer and a rune and returns a boolean
- - state: The raw pointer to be passed to the procedure `p`
- Returns:
- - res: The trimmed string as a slice of the original
- */
- trim_left_proc_with_state :: proc(s: string, p: proc(rawptr, rune) -> bool, state: rawptr) -> (res: string) {
- i := index_proc_with_state(s, p, state, false)
- if i == -1 {
- return ""
- }
- return s[i:]
- }
- /*
- Trims the input string `s` from the right until the procedure `p` returns `false`
- Inputs:
- - s: The input string
- - p: A procedure that takes a rune and returns a boolean
- Returns:
- - res: The trimmed string as a slice of the original
- Example:
- import "core:fmt"
- import "core:strings"
- trim_right_proc_example :: proc() {
- find :: proc(r: rune) -> bool {
- return r != 't'
- }
- fmt.println(strings.trim_right_proc("testing", find))
- }
- Output:
- test
- */
- trim_right_proc :: proc(s: string, p: proc(rune) -> bool) -> (res: string) {
- i := last_index_proc(s, p, false)
- if i >= 0 && s[i] >= utf8.RUNE_SELF {
- _, w := utf8.decode_rune_in_string(s[i:])
- i += w
- } else {
- i += 1
- }
- return s[0:i]
- }
- /*
- Trims the input string `s` from the right until the procedure `p` with state returns `false`
- Inputs:
- - s: The input string
- - p: A procedure that takes a raw pointer and a rune and returns a boolean
- - state: The raw pointer to be passed to the procedure `p`
- Returns:
- - res: The trimmed string as a slice of the original, empty when no match
- */
- trim_right_proc_with_state :: proc(s: string, p: proc(rawptr, rune) -> bool, state: rawptr) -> (res: string) {
- i := last_index_proc_with_state(s, p, state, false)
- if i >= 0 && s[i] >= utf8.RUNE_SELF {
- _, w := utf8.decode_rune_in_string(s[i:])
- i += w
- } else {
- i += 1
- }
- return s[0:i]
- }
- // Procedure for `trim_*_proc` variants, which has a string rawptr cast + rune comparison
- is_in_cutset :: proc(state: rawptr, r: rune) -> (res: bool) {
- if state == nil {
- return false
- }
- cutset := (^string)(state)^
- for c in cutset {
- if r == c {
- return true
- }
- }
- return false
- }
- /*
- Trims the cutset string from the `s` string
- Inputs:
- - s: The input string
- - cutset: The set of characters to be trimmed from the left of the input string
- Returns:
- - res: The trimmed string as a slice of the original
- */
- trim_left :: proc(s: string, cutset: string) -> (res: string) {
- if s == "" || cutset == "" {
- return s
- }
- state := cutset
- return trim_left_proc_with_state(s, is_in_cutset, &state)
- }
- /*
- Trims the cutset string from the `s` string from the right
- Inputs:
- - s: The input string
- - cutset: The set of characters to be trimmed from the right of the input string
- Returns:
- - res: The trimmed string as a slice of the original
- */
- trim_right :: proc(s: string, cutset: string) -> (res: string) {
- if s == "" || cutset == "" {
- return s
- }
- state := cutset
- return trim_right_proc_with_state(s, is_in_cutset, &state)
- }
- /*
- Trims the cutset string from the `s` string, both from left and right
- Inputs:
- - s: The input string
- - cutset: The set of characters to be trimmed from both sides of the input string
- Returns:
- - res: The trimmed string as a slice of the original
- */
- trim :: proc(s: string, cutset: string) -> (res: string) {
- return trim_right(trim_left(s, cutset), cutset)
- }
- /*
- Trims until a valid non-space rune from the left, "\t\txyz\t\t" -> "xyz\t\t"
- Inputs:
- - s: The input string
- Returns:
- - res: The trimmed string as a slice of the original
- */
- trim_left_space :: proc(s: string) -> (res: string) {
- return trim_left_proc(s, is_space)
- }
- /*
- Trims from the right until a valid non-space rune, "\t\txyz\t\t" -> "\t\txyz"
- Inputs:
- - s: The input string
- Returns:
- - res: The trimmed string as a slice of the original
- */
- trim_right_space :: proc(s: string) -> (res: string) {
- return trim_right_proc(s, is_space)
- }
- /*
- Trims from both sides until a valid non-space rune, "\t\txyz\t\t" -> "xyz"
- Inputs:
- - s: The input string
- Returns:
- - res: The trimmed string as a slice of the original
- */
- trim_space :: proc(s: string) -> (res: string) {
- return trim_right_space(trim_left_space(s))
- }
- /*
- Trims null runes from the left, "\x00\x00testing\x00\x00" -> "testing\x00\x00"
- Inputs:
- - s: The input string
- Returns:
- - res: The trimmed string as a slice of the original
- */
- trim_left_null :: proc(s: string) -> (res: string) {
- return trim_left_proc(s, is_null)
- }
- /*
- Trims null runes from the right, "\x00\x00testing\x00\x00" -> "\x00\x00testing"
- Inputs:
- - s: The input string
- Returns:
- - res: The trimmed string as a slice of the original
- */
- trim_right_null :: proc(s: string) -> (res: string) {
- return trim_right_proc(s, is_null)
- }
- /*
- Trims null runes from both sides, "\x00\x00testing\x00\x00" -> "testing"
- Inputs:
- - s: The input string
- Returns:
- - res: The trimmed string as a slice of the original
- */
- trim_null :: proc(s: string) -> (res: string) {
- return trim_right_null(trim_left_null(s))
- }
- /*
- Trims a `prefix` string from the start of the `s` string and returns the trimmed string
- Inputs:
- - s: The input string
- - prefix: The prefix string to be removed
- Returns:
- - res: The trimmed string as a slice of original, or the input string if no prefix was found
- Example:
- import "core:fmt"
- import "core:strings"
- trim_prefix_example :: proc() {
- fmt.println(strings.trim_prefix("testing", "test"))
- fmt.println(strings.trim_prefix("testing", "abc"))
- }
- Output:
- ing
- testing
- */
- trim_prefix :: proc(s, prefix: string) -> (res: string) {
- if has_prefix(s, prefix) {
- return s[len(prefix):]
- }
- return s
- }
- /*
- Trims a `suffix` string from the end of the `s` string and returns the trimmed string
- Inputs:
- - s: The input string
- - suffix: The suffix string to be removed
- Returns:
- - res: The trimmed string as a slice of original, or the input string if no suffix was found
- Example:
- import "core:fmt"
- import "core:strings"
- trim_suffix_example :: proc() {
- fmt.println(strings.trim_suffix("todo.txt", ".txt"))
- fmt.println(strings.trim_suffix("todo.doc", ".txt"))
- }
- Output:
- todo
- todo.doc
- */
- trim_suffix :: proc(s, suffix: string) -> (res: string) {
- if has_suffix(s, suffix) {
- return s[:len(s)-len(suffix)]
- }
- return s
- }
- /*
- Splits the input string `s` by all possible `substrs` and returns an allocated array of strings
- *Allocates Using Provided Allocator*
- Inputs:
- - s: The input string
- - substrs: An array of substrings used for splitting
- - allocator: (default is context.allocator)
- Returns:
- - res: An array of strings, or nil on empty substring or no matches
- - err: An optional allocator error if one occured, `nil` otherwise
- NOTE: Allocation occurs for the array, the splits are all views of the original string.
- Example:
- import "core:fmt"
- import "core:strings"
- split_multi_example :: proc() {
- splits := [?]string { "---", "~~~", ".", "_", "," }
- res := strings.split_multi("testing,this.out_nice---done~~~last", splits[:])
- fmt.println(res) // -> [testing, this, out, nice, done, last]
- }
- Output:
- ["testing", "this", "out", "nice", "done", "last"]
- */
- split_multi :: proc(s: string, substrs: []string, allocator := context.allocator, loc := #caller_location) -> (res: []string, err: mem.Allocator_Error) #optional_allocator_error #no_bounds_check {
- if s == "" || len(substrs) <= 0 {
- return nil, nil
- }
- // disallow "" substr
- for substr in substrs {
- if len(substr) == 0 {
- return nil, nil
- }
- }
- // calculate the needed len of `results`
- n := 1
- for it := s; len(it) > 0; {
- i, w := index_multi(it, substrs)
- if i < 0 {
- break
- }
- n += 1
- it = it[i+w:]
- }
- results := make([dynamic]string, 0, n, allocator, loc) or_return
- {
- it := s
- for len(it) > 0 {
- i, w := index_multi(it, substrs)
- if i < 0 {
- break
- }
- part := it[:i]
- append(&results, part)
- it = it[i+w:]
- }
- append(&results, it)
- }
- assert(len(results) == n)
- return results[:], nil
- }
- /*
- Splits the input string `s` by all possible `substrs` in an iterator fashion. The full string is returned if no match.
- Inputs:
- - it: A pointer to the input string
- - substrs: An array of substrings used for splitting
- Returns:
- - res: The split string
- - ok: `true` if an iteration result was returned, `false` if the iterator has reached the end
- Example:
- import "core:fmt"
- import "core:strings"
- split_multi_iterate_example :: proc() {
- it := "testing,this.out_nice---done~~~last"
- splits := [?]string { "---", "~~~", ".", "_", "," }
- for str in strings.split_multi_iterate(&it, splits[:]) {
- fmt.println(str)
- }
- }
- Output:
- testing
- this
- out
- nice
- done
- last
- */
- split_multi_iterate :: proc(it: ^string, substrs: []string) -> (res: string, ok: bool) #no_bounds_check {
- if it == nil || len(it) == 0 || len(substrs) <= 0 {
- return
- }
- // disallow "" substr
- for substr in substrs {
- if len(substr) == 0 {
- return
- }
- }
- // calculate the needed len of `results`
- i, w := index_multi(it^, substrs)
- if i >= 0 {
- res = it[:i]
- it^ = it[i+w:]
- } else {
- // last value
- res = it^
- it^ = it[len(it):]
- }
- ok = true
- return
- }
- /*
- Replaces invalid UTF-8 characters in the input string with a specified replacement string. Adjacent invalid bytes are only replaced once.
- *Allocates Using Provided Allocator*
- Inputs:
- - s: The input string
- - replacement: The string used to replace invalid UTF-8 characters
- - allocator: (default is context.allocator)
- Returns:
- - res: A new string with invalid UTF-8 characters replaced
- - err: An optional allocator error if one occured, `nil` otherwise
- Example:
- import "core:fmt"
- import "core:strings"
- scrub_example :: proc() {
- text := "Hello\xC0\x80World"
- fmt.println(strings.scrub(text, "?")) // -> "Hello?World"
- }
- Output:
- Hello?
- */
- scrub :: proc(s: string, replacement: string, allocator := context.allocator) -> (res: string, err: mem.Allocator_Error) #optional_allocator_error {
- str := s
- b: Builder
- builder_init(&b, 0, len(s), allocator) or_return
- has_error := false
- cursor := 0
- origin := str
- for len(str) > 0 {
- r, w := utf8.decode_rune_in_string(str)
- if r == utf8.RUNE_ERROR {
- if !has_error {
- has_error = true
- write_string(&b, origin[:cursor])
- }
- } else if has_error {
- has_error = false
- write_string(&b, replacement)
- origin = origin[cursor:]
- cursor = 0
- }
- cursor += w
- str = str[w:]
- }
- return to_string(b), nil
- }
- /*
- Reverses the input string `s`
- *Allocates Using Provided Allocator*
- Inputs:
- - s: The input string
- - allocator: (default is context.allocator)
- Returns:
- - res: A reversed version of the input string
- - err: An optional allocator error if one occured, `nil` otherwise
- Example:
- import "core:fmt"
- import "core:strings"
- reverse_example :: proc() {
- a := "abcxyz"
- b := strings.reverse(a)
- fmt.println(a, b)
- }
- Output:
- abcxyz zyxcba
- */
- reverse :: proc(s: string, allocator := context.allocator, loc := #caller_location) -> (res: string, err: mem.Allocator_Error) #optional_allocator_error {
- str := s
- n := len(str)
- buf := make([]byte, n, allocator, loc) or_return
- i := n
- for len(str) > 0 {
- _, w := utf8.decode_rune_in_string(str)
- i -= w
- copy(buf[i:], str[:w])
- str = str[w:]
- }
- return string(buf), nil
- }
- /*
- Expands the input string by replacing tab characters with spaces to align to a specified tab size
- *Allocates Using Provided Allocator*
- Inputs:
- - s: The input string
- - tab_size: The number of spaces to use for each tab character
- - allocator: (default is context.allocator)
- Returns:
- - res: A new string with tab characters expanded to the specified tab size
- - err: An optional allocator error if one occured, `nil` otherwise
- WARNING: Panics if tab_size <= 0
- Example:
- import "core:fmt"
- import "core:strings"
- expand_tabs_example :: proc() {
- text := "abc1\tabc2\tabc3"
- fmt.println(strings.expand_tabs(text, 4))
- }
- Output:
- abc1 abc2 abc3
- */
- expand_tabs :: proc(s: string, tab_size: int, allocator := context.allocator) -> (res: string, err: mem.Allocator_Error) #optional_allocator_error {
- if tab_size <= 0 {
- panic("tab size must be positive")
- }
- if s == "" {
- return "", nil
- }
- b: Builder
- builder_init(&b, allocator) or_return
- writer := to_writer(&b)
- str := s
- column: int
- for len(str) > 0 {
- r, w := utf8.decode_rune_in_string(str)
- if r == '\t' {
- expand := tab_size - column%tab_size
- for i := 0; i < expand; i += 1 {
- io.write_byte(writer, ' ')
- }
- column += expand
- } else {
- if r == '\n' {
- column = 0
- } else {
- column += w
- }
- io.write_rune(writer, r)
- }
- str = str[w:]
- }
- return to_string(b), nil
- }
- /*
- Splits the input string `str` by the separator `sep` string and returns 3 parts. The values are slices of the original string.
- Inputs:
- - str: The input string
- - sep: The separator string
- Returns:
- - head: the string before the split
- - match: the seperator string
- - tail: the string after the split
- Example:
- import "core:fmt"
- import "core:strings"
- partition_example :: proc() {
- text := "testing this out"
- head, match, tail := strings.partition(text, " this ") // -> head: "testing", match: " this ", tail: "out"
- fmt.println(head, match, tail)
- head, match, tail = strings.partition(text, "hi") // -> head: "testing t", match: "hi", tail: "s out"
- fmt.println(head, match, tail)
- head, match, tail = strings.partition(text, "xyz") // -> head: "testing this out", match: "", tail: ""
- fmt.println(head)
- fmt.println(match == "")
- fmt.println(tail == "")
- }
- Output:
- testing this out
- testing t hi s out
- testing this out
- true
- true
- */
- partition :: proc(str, sep: string) -> (head, match, tail: string) {
- i := index(str, sep)
- if i == -1 {
- head = str
- return
- }
- head = str[:i]
- match = str[i:i+len(sep)]
- tail = str[i+len(sep):]
- return
- }
- // Alias for centre_justify
- center_justify :: centre_justify // NOTE(bill): Because Americans exist
- /*
- Centers the input string within a field of specified length by adding pad string on both sides, if its length is less than the target length.
- *Allocates Using Provided Allocator*
- Inputs:
- - str: The input string
- - length: The desired length of the centered string, in runes
- - pad: The string used for padding on both sides
- - allocator: (default is context.allocator)
- Returns:
- - res: A new string centered within a field of the specified length
- - err: An optional allocator error if one occured, `nil` otherwise
- */
- centre_justify :: proc(str: string, length: int, pad: string, allocator := context.allocator) -> (res: string, err: mem.Allocator_Error) #optional_allocator_error {
- n := rune_count(str)
- if n >= length || pad == "" {
- return clone(str, allocator)
- }
- remains := length-n
- pad_len := rune_count(pad)
- b: Builder
- builder_init(&b, 0, len(str) + (remains/pad_len + 1)*len(pad), allocator) or_return
- w := to_writer(&b)
- write_pad_string(w, pad, pad_len, remains/2)
- io.write_string(w, str)
- write_pad_string(w, pad, pad_len, (remains+1)/2)
- return to_string(b), nil
- }
- /*
- Left-justifies the input string within a field of specified length by adding pad string on the right side, if its length is less than the target length.
- *Allocates Using Provided Allocator*
- Inputs:
- - str: The input string
- - length: The desired length of the left-justified string
- - pad: The string used for padding on the right side
- - allocator: (default is context.allocator)
- Returns:
- - res: A new string left-justified within a field of the specified length
- - err: An optional allocator error if one occured, `nil` otherwise
- */
- left_justify :: proc(str: string, length: int, pad: string, allocator := context.allocator) -> (res: string, err: mem.Allocator_Error) #optional_allocator_error {
- n := rune_count(str)
- if n >= length || pad == "" {
- return clone(str, allocator)
- }
- remains := length-n
- pad_len := rune_count(pad)
- b: Builder
- builder_init(&b, allocator)
- builder_init(&b, 0, len(str) + (remains/pad_len + 1)*len(pad), allocator) or_return
- w := to_writer(&b)
- io.write_string(w, str)
- write_pad_string(w, pad, pad_len, remains)
- return to_string(b), nil
- }
- /*
- Right-justifies the input string within a field of specified length by adding pad string on the left side, if its length is less than the target length.
- *Allocates Using Provided Allocator*
- Inputs:
- - str: The input string
- - length: The desired length of the right-justified string
- - pad: The string used for padding on the left side
- - allocator: (default is context.allocator)
- Returns:
- - res: A new string right-justified within a field of the specified length
- - err: An optional allocator error if one occured, `nil` otherwise
- */
- right_justify :: proc(str: string, length: int, pad: string, allocator := context.allocator) -> (res: string, err: mem.Allocator_Error) #optional_allocator_error {
- n := rune_count(str)
- if n >= length || pad == "" {
- return clone(str, allocator)
- }
- remains := length-n
- pad_len := rune_count(pad)
- b: Builder
- builder_init(&b, allocator)
- builder_init(&b, 0, len(str) + (remains/pad_len + 1)*len(pad), allocator) or_return
- w := to_writer(&b)
- write_pad_string(w, pad, pad_len, remains)
- io.write_string(w, str)
- return to_string(b), nil
- }
- /*
- Writes a given pad string a specified number of times to an `io.Writer`
- Inputs:
- - w: The io.Writer to write the pad string to
- - pad: The pad string to be written
- - pad_len: The length of the pad string, in runes
- - remains: The number of times to write the pad string, in runes
- */
- @private
- write_pad_string :: proc(w: io.Writer, pad: string, pad_len, remains: int) {
- repeats := remains / pad_len
- for i := 0; i < repeats; i += 1 {
- io.write_string(w, pad)
- }
- n := remains % pad_len
- p := pad
- for i := 0; i < n; i += 1 {
- r, width := utf8.decode_rune_in_string(p)
- io.write_rune(w, r)
- p = p[width:]
- }
- }
- /*
- Splits a string into a slice of substrings at each instance of one or more consecutive white space characters, as defined by `unicode.is_space`
- *Allocates Using Provided Allocator*
- Inputs:
- - s: The input string
- - allocator: (default is context.allocator)
- Returns:
- - res: A slice of substrings of the input string, or an empty slice if the input string only contains white space
- - err: An optional allocator error if one occured, `nil` otherwise
- */
- fields :: proc(s: string, allocator := context.allocator, loc := #caller_location) -> (res: []string, err: mem.Allocator_Error) #optional_allocator_error #no_bounds_check {
- n := 0
- was_space := 1
- set_bits := u8(0)
- // check to see
- for i in 0..<len(s) {
- r := s[i]
- set_bits |= r
- is_space := int(_ascii_space[r])
- n += was_space & ~is_space
- was_space = is_space
- }
- if set_bits >= utf8.RUNE_SELF {
- return fields_proc(s, unicode.is_space, allocator)
- }
- if n == 0 {
- return nil, nil
- }
- a := make([]string, n, allocator, loc) or_return
- na := 0
- field_start := 0
- i := 0
- for i < len(s) && _ascii_space[s[i]] {
- i += 1
- }
- field_start = i
- for i < len(s) {
- if !_ascii_space[s[i]] {
- i += 1
- continue
- }
- a[na] = s[field_start : i]
- na += 1
- i += 1
- for i < len(s) && _ascii_space[s[i]] {
- i += 1
- }
- field_start = i
- }
- if field_start < len(s) {
- a[na] = s[field_start:]
- }
- return a, nil
- }
- /*
- Splits a string into a slice of substrings at each run of unicode code points `r` satisfying the predicate `f(r)`
- *Allocates Using Provided Allocator*
- Inputs:
- - s: The input string
- - f: A predicate function to determine the split points
- - allocator: (default is context.allocator)
- NOTE: fields_proc makes no guarantee about the order in which it calls `f(r)`, it assumes that `f` always returns the same value for a given `r`
- Returns:
- - res: A slice of substrings of the input string, or an empty slice if all code points in the input string satisfy the predicate or if the input string is empty
- - err: An optional allocator error if one occured, `nil` otherwise
- */
- fields_proc :: proc(s: string, f: proc(rune) -> bool, allocator := context.allocator, loc := #caller_location) -> (res: []string, err: mem.Allocator_Error) #optional_allocator_error #no_bounds_check {
- substrings := make([dynamic]string, 0, 32, allocator, loc) or_return
- start, end := -1, -1
- for r, offset in s {
- end = offset
- if f(r) {
- if start >= 0 {
- append(&substrings, s[start : end])
- // -1 could be used, but just speed it up through bitwise not
- // gotta love 2's complement
- start = ~start
- }
- } else {
- if start < 0 {
- start = end
- }
- }
- }
- if start >= 0 {
- append(&substrings, s[start : len(s)])
- }
- return substrings[:], nil
- }
- /*
- Retrieves the first non-space substring from a mutable string reference and advances the reference. `s` is advanced from any space after the substring, or be an empty string if the substring was the remaining characters
- Inputs:
- - s: A mutable string reference to be iterated
- Returns:
- - field: The first non-space substring found
- - ok: A boolean indicating if a non-space substring was found
- */
- fields_iterator :: proc(s: ^string) -> (field: string, ok: bool) {
- start, end := -1, -1
- for r, offset in s {
- end = offset
- if unicode.is_space(r) {
- if start >= 0 {
- field = s[start : end]
- ok = true
- s^ = s[end:]
- return
- }
- } else {
- if start < 0 {
- start = end
- }
- }
- }
- // if either of these are true, the string did not contain any characters
- if end < 0 || start < 0 {
- return "", false
- }
- field = s[start:]
- ok = true
- s^ = s[len(s):]
- return
- }
- /*
- Computes the Levenshtein edit distance between two strings
- *Allocates Using Provided Allocator (deletion occurs internal to proc)*
- NOTE: Does not perform internal allocation if length of string `b`, in runes, is smaller than 64
- Inputs:
- - a, b: The two strings to compare
- - allocator: (default is context.allocator)
- Returns:
- - res: The Levenshtein edit distance between the two strings
- - err: An optional allocator error if one occured, `nil` otherwise
- NOTE: This implementation is a single-row-version of the Wagner–Fischer algorithm, based on C code by Martin Ettl.
- */
- levenshtein_distance :: proc(a, b: string, allocator := context.allocator, loc := #caller_location) -> (res: int, err: mem.Allocator_Error) #optional_allocator_error {
- LEVENSHTEIN_DEFAULT_COSTS: []int : {
- 0, 1, 2, 3, 4, 5, 6, 7, 8, 9,
- 10, 11, 12, 13, 14, 15, 16, 17, 18, 19,
- 20, 21, 22, 23, 24, 25, 26, 27, 28, 29,
- 30, 31, 32, 33, 34, 35, 36, 37, 38, 39,
- 40, 41, 42, 43, 44, 45, 46, 47, 48, 49,
- 50, 51, 52, 53, 54, 55, 56, 57, 58, 59,
- 60, 61, 62, 63,
- }
- m, n := utf8.rune_count_in_string(a), utf8.rune_count_in_string(b)
- if m == 0 {
- return n, nil
- }
- if n == 0 {
- return m, nil
- }
- costs: []int
- if n + 1 > len(LEVENSHTEIN_DEFAULT_COSTS) {
- costs = make([]int, n + 1, allocator, loc) or_return
- for k in 0..=n {
- costs[k] = k
- }
- } else {
- costs = LEVENSHTEIN_DEFAULT_COSTS
- }
- defer if n + 1 > len(LEVENSHTEIN_DEFAULT_COSTS) {
- delete(costs, allocator)
- }
- i: int
- for c1 in a {
- costs[0] = i + 1
- corner := i
- j: int
- for c2 in b {
- upper := costs[j + 1]
- if c1 == c2 {
- costs[j + 1] = corner
- } else {
- t := upper if upper < corner else corner
- costs[j + 1] = (costs[j] if costs[j] < t else t) + 1
- }
- corner = upper
- j += 1
- }
- i += 1
- }
- return costs[n], nil
- }
|