strings.textscanner #
fn new #
fn new(input string) TextScanner
new returns a stack allocated instance of TextScanner.
struct TextScanner #
struct TextScanner {
pub:
input string
ilen int
pub mut:
pos int // current position; pos is *always* kept in [0,ilen]
}
TextScanner simplifies writing small scanners/parsers by providing safe methods to scan texts character by character, peek for the next characters, go back, etc.
fn (TextScanner) free #
fn (mut ss TextScanner) free()
free frees all allocated resources.
fn (TextScanner) remaining #
fn (ss &TextScanner) remaining() int
remaining returns how many characters remain from current position.
fn (TextScanner) next #
fn (mut ss TextScanner) next() int
next returns the next character code from the input text. next returns -1
if it can't reach the next character. next advances the scanner position.
fn (TextScanner) skip #
fn (mut ss TextScanner) skip()
skip skips one character ahead; skip()
is slightly faster than .next()
. skip()
does not return a result.
fn (TextScanner) skip_n #
fn (mut ss TextScanner) skip_n(n int)
skip_n skips ahead n
characters, stopping at the end of the input.
fn (TextScanner) peek #
fn (ss &TextScanner) peek() int
peek returns the next character code from the input text. peek returns -1
if it can't peek the next character. unlike next()
, peek()
does not change the state of the scanner.
fn (TextScanner) peek_u8 #
fn (ss &TextScanner) peek_u8() u8
peek_u8 returns the next character code from the input text, as a byte/u8. unlike next()
, peek_u8()
does not change the state of the scanner.
Note: peek_u8 returns 0
, if it can't peek the next character.
Note: use peek()
, instead of peek_u8()
, if your input itself can legitimately contain bytes with value 0
.
fn (TextScanner) peek_n #
fn (ss &TextScanner) peek_n(n int) int
peek_n returns the character code from the input text at position + n
. peek_n returns -1
if it can't peek n
characters ahead. ts.peek_n(0) == ts.current() . ts.peek_n(1) == ts.peek() .
fn (TextScanner) peek_n_u8 #
fn (ss &TextScanner) peek_n_u8(n int) u8
peek_n_u8 returns the character code from the input text, at position + n
, as a byte/u8.
Note: peek_n_u8 returns 0
, if it can't peek the next character.
Note: use peek_n()
, instead of peek_n_u8()
, if your input itself can legitimately contain bytes with value 0
.
fn (TextScanner) back #
fn (mut ss TextScanner) back()
back goes back one character from the current scanner position.
fn (TextScanner) back_n #
fn (mut ss TextScanner) back_n(n int)
back_n goes back n
characters from the current scanner position.
fn (TextScanner) peek_back #
fn (ss &TextScanner) peek_back() int
peek_back returns the previous character code from the input text. peek_back returns -1
if it can't peek the previous character. unlike back()
, peek_back()
does not change the state of the scanner.
fn (TextScanner) peek_back_n #
fn (ss &TextScanner) peek_back_n(n int) int
peek_back_n returns the character code from the input text at position - n
. peek_back_n returns -1
if it can't peek n
characters back. ts.peek_back_n(0) == ts.current() ts.peek_back_n(1) == ts.peek_back()
fn (TextScanner) current #
fn (mut ss TextScanner) current() int
current returns the current character code from the input text. current returns -1
at the start of the input text.
Note: after c := ts.next()
, ts.current()
will also return c
.
fn (TextScanner) reset #
fn (mut ss TextScanner) reset()
reset resets the internal state of the scanner After calling .reset(), .next() will start reading again from the start of the input text.
fn (TextScanner) goto_end #
fn (mut ss TextScanner) goto_end()
goto_end has the same effect as for ts.next() != -1 {}
i.e. after calling .goto_end(), the scanner will be at the end of the input text. Further .next() calls will return -1, unless you go back.
fn (TextScanner) skip_whitespace #
fn (mut ss TextScanner) skip_whitespace()
skip_whitespace advances the scanner pass any space characters in the input.