Gemreq/reader.odin at main · Creativty/Gemreq · GitHub

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
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
package gemreq

import "core:strings"
import "core:strconv"

Reader :: struct {
	length: int,
	index_last: int,
	index_curr: int,
	row, column: int,
	buffer: string,
}

reader_make :: proc(buffer: string) -> (r: Reader) {
	r.row = 1
	r.column = 1
	r.buffer = buffer
	r.length = len(buffer)
	return
}

reader_eof :: proc(r: ^Reader) -> bool {
	return reader_peek(r) == rune(0)
}

reader_peek :: proc(r: ^Reader) -> rune {
	if r.index_curr >= r.length || r.index_curr < 0 do return rune(0)
	return rune(r.buffer[r.index_curr])
}

reader_next :: proc(r: ^Reader) -> rune {
	char := reader_peek(r)
	if char != rune(0) {
		if char == '\n' {
			r.row     = 1
			r.column += 1
		}
		r.index_curr += 1
	}
	return char
}

reader_next_if :: proc(r: ^Reader, cond: proc(c: rune) -> bool) -> rune {
	if char := reader_peek(r); cond(char) do return reader_next(r)
	return rune(0)
}

reader_next_while :: proc(r: ^Reader, cond: proc (i: int, c: rune) -> bool) -> (n: int) {
	if cond == nil do return
	for !reader_eof(r) && cond(n, reader_peek(r)) {
		reader_next(r)
		n += 1
	}
	return n
}

reader_skip_while :: proc(r: ^Reader, cond: proc(i: int, c: rune) -> bool) -> (n: int) {
	n = reader_next_while(r, cond)
	r.index_last = r.index_curr
	return n
}

reader_skip_whitespace :: proc(r: ^Reader) -> (n: int) {
	is_whitespace :: proc(_: int, c: rune) -> bool {
		return c == ' ' || c == '\t' || c == '\f' || c == '\n' || c == '\r' || c == '\v'
	}
	return reader_skip_while(r, is_whitespace)
}

reader_consume :: proc(r: ^Reader) -> (token: string) {
	token = reader_peek_token(r)
	r.index_last = r.index_curr
	return token
}

reader_peek_token :: proc(r: ^Reader) -> (token: string) {
	token = r.buffer[r.index_last:][:r.index_curr - r.index_last]
	return token
}

reader_read_int :: proc(r: ^Reader) -> (n: int) {
	r.index_last = r.index_curr

	is_digit :: proc(_: int, c: rune) -> bool {
		return c >= '0' && c <= '9'
	}
	reader_next_while(r, is_digit)
	token := reader_consume(r)

	n, _ = strconv.parse_int(token)
	return n
}

reader_read_delimiter :: proc(r: ^Reader, delimiter: string) -> (token: string) {
	r.index_last = r.index_curr
	for !reader_eof(r) {
		if strings.has_prefix(r.buffer[r.index_curr:], delimiter) do break
		reader_next(r)
	}
	token = reader_consume(r)

	if strings.has_prefix(r.buffer[r.index_curr:], delimiter) {
		for i in 0..<len(delimiter) {
			reader_next(r)
		}
	}
	return token
}

reader_read_delimiter_whitespace :: proc(r: ^Reader) -> (token: string) {
	is_whitespace :: proc(_: int, c: rune) -> bool {
		return c == ' ' || c == '\t' || c == '\f' || c == '\v'
	}
	is_not_whitespace :: proc(_: int, c: rune) -> bool {
		return c != ' ' && c != '\t' && c != '\f' && c != '\v'
	}

	r.index_last = r.index_curr
	reader_next_while(r, is_not_whitespace)
	token = reader_consume(r)

	reader_next_while(r, is_whitespace)
	return token
}