cstr

(cstr-len [s :cstr] :int)

byte length of a NUL-terminated C string.

(cstr-len "hello")  ; => 5

(cstr-nth [s :cstr i :int] :int)

byte at index i in a NUL-terminated C string.

(cstr-nth "1+2" 1)  ; => 43  ('+')

(cstr-byte-is? [s :cstr i :int c :Char] :bool)

is the byte at index i of s the character c?

Unlike cstr-nth this checks the index: it is false when i is negative or at or past the terminator, so a scanner needs no separate length test and no magic numbers. c should be ASCII, as for string/byte-is?. A cstr stores no length, so every call measures s: cheap for a line or a token, but a byte-by-byte walk over a long text should make it a String once and use string/byte-is?.

(cstr-byte-is? "a,b" 1 #\,)  ; => true
(cstr-byte-is? "a,b" 3 #\,)  ; => false

Since: markdown-library-plan S1

(cstr-char-at [s :cstr i :int] :(Option Char))

the byte at index i of s as a Char, or (none).

The checked counterpart of cstr-nth, for comparing with character literals. Measures s on every call, like cstr-byte-is?.

(cstr-char-at "hi" 1)  ; => (some #\i)

Since: markdown-library-plan S1

(cstr-starts-with? [s :cstr prefix :cstr] :bool)

true iff s begins with prefix.

(cstr-starts-with? "# Title" "# ")  ; => true

Since: markdown-library-plan S2

(cstr-ends-with? [s :cstr suffix :cstr] :bool)

true iff s ends with suffix.

(cstr-ends-with? "guide.md" ".md")  ; => true

Since: markdown-library-plan S2

(cstr-index-of [s :cstr needle :cstr] :(Option int))

byte offset of the first occurrence of needle in s.

(cstr-index-of "key: value" ": ")  ; => (some 3)

Since: markdown-library-plan S2

(cstr-index-of-char [s :cstr c :Char] :(Option int))

byte offset of the first c in s.

(cstr-index-of-char "a=b" #\=)  ; => (some 1)

Since: markdown-library-plan S2

(cstr-span-while [s :cstr start :int pred :(fn [Char] bool)] :int)

the index where a run of bytes satisfying pred ends.

string/span-while for a cstr: scans from start while pred holds.

(cstr-span-while "  - item" 0 space?)  ; => 2

Since: markdown-library-plan S2

(cstr-sub [s :cstr start :int end :int] :cstr)

substring [start, end) of a NUL-terminated C string.

(cstr-sub "hello" 1 4)  ; => "ell"

(cstr-eq? [a :cstr b :cstr] :bool)

content equality on two NUL-terminated C strings.

The = operator has no cstr overload at all (comparing two cstr values with it is a TUR-E0006 operator-lookup error), so a byte-wise comparison needs a named function. (eq? a b) from the auto-loaded Eq[cstr] instance is the same comparison reached through typeclass dispatch; this is the direct call, for code that walks bytes with the rest of this module and does not otherwise want typeclass machinery.

(cstr-eq? "abc" (cstr-sub "abcdef" 0 3))  ; => true
(cstr-eq? "abc" "abd")                    ; => false

(cstr-free [s :cstr] :void)

release a cstr this module heap-allocated.

cstr-sub hands back a malloc'd string and documents that the caller frees it, but drop! wants a ref<T> and rejects a bare cstr, so without this there is no way to honor that contract from Turmeric -- every caller had to drop into inline C. Pass only a pointer this module allocated: a string literal is static, and freeing one is undefined. NULL is accepted and ignored, matching free(3).

(let [t (cstr-sub "hello world" 0 5)]
  (println t)
  (cstr-free t))