1
//
2
// Copyright (c) 2011-2019 Canonical Ltd
3
// Copyright (c) 2006-2010 Kirill Simonov
4
//
5
// Permission is hereby granted, free of charge, to any person obtaining a copy of
6
// this software and associated documentation files (the "Software"), to deal in
7
// the Software without restriction, including without limitation the rights to
8
// use, copy, modify, merge, publish, distribute, sublicense, and/or sell copies
9
// of the Software, and to permit persons to whom the Software is furnished to do
10
// so, subject to the following conditions:
11
//
12
// The above copyright notice and this permission notice shall be included in all
13
// copies or substantial portions of the Software.
14
//
15
// THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
16
// IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
17
// FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
18
// AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
19
// LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
20
// OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
21
// SOFTWARE.
22

23
package yaml
24

25
const (
26
	// The size of the input raw buffer.
27
	input_raw_buffer_size = 512
28

29
	// The size of the input buffer.
30
	// It should be possible to decode the whole raw buffer.
31
	input_buffer_size = input_raw_buffer_size * 3
32

33
	// The size of the output buffer.
34
	output_buffer_size = 128
35

36
	// The size of the output raw buffer.
37
	// It should be possible to encode the whole output buffer.
38
	output_raw_buffer_size = (output_buffer_size*2 + 2)
39

40
	// The size of other stacks and queues.
41
	initial_stack_size  = 16
42
	initial_queue_size  = 16
43
	initial_string_size = 16
44
)
45

46
// Check if the character at the specified position is an alphabetical
47
// character, a digit, '_', or '-'.
48
func is_alpha(b []byte, i int) bool {
49
	return b[i] >= '0' && b[i] <= '9' || b[i] >= 'A' && b[i] <= 'Z' || b[i] >= 'a' && b[i] <= 'z' || b[i] == '_' || b[i] == '-'
50
}
51

52
// Check if the character at the specified position is a digit.
53
func is_digit(b []byte, i int) bool {
54
	return b[i] >= '0' && b[i] <= '9'
55
}
56

57
// Get the value of a digit.
58
func as_digit(b []byte, i int) int {
59
	return int(b[i]) - '0'
60
}
61

62
// Check if the character at the specified position is a hex-digit.
63
func is_hex(b []byte, i int) bool {
64
	return b[i] >= '0' && b[i] <= '9' || b[i] >= 'A' && b[i] <= 'F' || b[i] >= 'a' && b[i] <= 'f'
65
}
66

67
// Get the value of a hex-digit.
68
func as_hex(b []byte, i int) int {
69
	bi := b[i]
70
	if bi >= 'A' && bi <= 'F' {
71
		return int(bi) - 'A' + 10
72
	}
73
	if bi >= 'a' && bi <= 'f' {
74
		return int(bi) - 'a' + 10
75
	}
76
	return int(bi) - '0'
77
}
78

79
// Check if the character is ASCII.
80
func is_ascii(b []byte, i int) bool {
81
	return b[i] <= 0x7F
82
}
83

84
// Check if the character at the start of the buffer can be printed unescaped.
85
func is_printable(b []byte, i int) bool {
86
	return ((b[i] == 0x0A) || // . == #x0A
87
		(b[i] >= 0x20 && b[i] <= 0x7E) || // #x20 <= . <= #x7E
88
		(b[i] == 0xC2 && b[i+1] >= 0xA0) || // #0xA0 <= . <= #xD7FF
89
		(b[i] > 0xC2 && b[i] < 0xED) ||
90
		(b[i] == 0xED && b[i+1] < 0xA0) ||
91
		(b[i] == 0xEE) ||
92
		(b[i] == 0xEF && // #xE000 <= . <= #xFFFD
93
			!(b[i+1] == 0xBB && b[i+2] == 0xBF) && // && . != #xFEFF
94
			!(b[i+1] == 0xBF && (b[i+2] == 0xBE || b[i+2] == 0xBF))))
95
}
96

97
// Check if the character at the specified position is NUL.
98
func is_z(b []byte, i int) bool {
99
	return b[i] == 0x00
100
}
101

102
// Check if the beginning of the buffer is a BOM.
103
func is_bom(b []byte, i int) bool {
104
	return b[0] == 0xEF && b[1] == 0xBB && b[2] == 0xBF
105
}
106

107
// Check if the character at the specified position is space.
108
func is_space(b []byte, i int) bool {
109
	return b[i] == ' '
110
}
111

112
// Check if the character at the specified position is tab.
113
func is_tab(b []byte, i int) bool {
114
	return b[i] == '\t'
115
}
116

117
// Check if the character at the specified position is blank (space or tab).
118
func is_blank(b []byte, i int) bool {
119
	//return is_space(b, i) || is_tab(b, i)
120
	return b[i] == ' ' || b[i] == '\t'
121
}
122

123
// Check if the character at the specified position is a line break.
124
func is_break(b []byte, i int) bool {
125
	return (b[i] == '\r' || // CR (#xD)
126
		b[i] == '\n' || // LF (#xA)
127
		b[i] == 0xC2 && b[i+1] == 0x85 || // NEL (#x85)
128
		b[i] == 0xE2 && b[i+1] == 0x80 && b[i+2] == 0xA8 || // LS (#x2028)
129
		b[i] == 0xE2 && b[i+1] == 0x80 && b[i+2] == 0xA9) // PS (#x2029)
130
}
131

132
func is_crlf(b []byte, i int) bool {
133
	return b[i] == '\r' && b[i+1] == '\n'
134
}
135

136
// Check if the character is a line break or NUL.
137
func is_breakz(b []byte, i int) bool {
138
	//return is_break(b, i) || is_z(b, i)
139
	return (
140
	// is_break:
141
	b[i] == '\r' || // CR (#xD)
142
		b[i] == '\n' || // LF (#xA)
143
		b[i] == 0xC2 && b[i+1] == 0x85 || // NEL (#x85)
144
		b[i] == 0xE2 && b[i+1] == 0x80 && b[i+2] == 0xA8 || // LS (#x2028)
145
		b[i] == 0xE2 && b[i+1] == 0x80 && b[i+2] == 0xA9 || // PS (#x2029)
146
		// is_z:
147
		b[i] == 0)
148
}
149

150
// Check if the character is a line break, space, or NUL.
151
func is_spacez(b []byte, i int) bool {
152
	//return is_space(b, i) || is_breakz(b, i)
153
	return (
154
	// is_space:
155
	b[i] == ' ' ||
156
		// is_breakz:
157
		b[i] == '\r' || // CR (#xD)
158
		b[i] == '\n' || // LF (#xA)
159
		b[i] == 0xC2 && b[i+1] == 0x85 || // NEL (#x85)
160
		b[i] == 0xE2 && b[i+1] == 0x80 && b[i+2] == 0xA8 || // LS (#x2028)
161
		b[i] == 0xE2 && b[i+1] == 0x80 && b[i+2] == 0xA9 || // PS (#x2029)
162
		b[i] == 0)
163
}
164

165
// Check if the character is a line break, space, tab, or NUL.
166
func is_blankz(b []byte, i int) bool {
167
	//return is_blank(b, i) || is_breakz(b, i)
168
	return (
169
	// is_blank:
170
	b[i] == ' ' || b[i] == '\t' ||
171
		// is_breakz:
172
		b[i] == '\r' || // CR (#xD)
173
		b[i] == '\n' || // LF (#xA)
174
		b[i] == 0xC2 && b[i+1] == 0x85 || // NEL (#x85)
175
		b[i] == 0xE2 && b[i+1] == 0x80 && b[i+2] == 0xA8 || // LS (#x2028)
176
		b[i] == 0xE2 && b[i+1] == 0x80 && b[i+2] == 0xA9 || // PS (#x2029)
177
		b[i] == 0)
178
}
179

180
// Determine the width of the character.
181
func width(b byte) int {
182
	// Don't replace these by a switch without first
183
	// confirming that it is being inlined.
184
	if b&0x80 == 0x00 {
185
		return 1
186
	}
187
	if b&0xE0 == 0xC0 {
188
		return 2
189
	}
190
	if b&0xF0 == 0xE0 {
191
		return 3
192
	}
193
	if b&0xF8 == 0xF0 {
194
		return 4
195
	}
196
	return 0
197

198
}
199

200