← Back to branch summary

~nskaggs/+junk/xenial-test

« back to all changes in this revision

Viewing changes to src/gopkg.in/yaml.v1/yamlprivateh.go

  • Committer: Nicholas Skaggs
  • Date: 2016-10-24 20:56:05 UTC
  • Revision ID: nicholas.skaggs@canonical.com-20161024205605-z8lta0uvuhtxwzwl
Initi with beta15

Show diffs side-by-side

added added

removed removed

Lines of Context:
src/gopkg.in/yaml.v1/yamlprivateh.go
 
1
package yaml
 
2
 
 
3
const (
 
4
        // The size of the input raw buffer.
 
5
        input_raw_buffer_size = 512
 
6
 
 
7
        // The size of the input buffer.
 
8
        // It should be possible to decode the whole raw buffer.
 
9
        input_buffer_size = input_raw_buffer_size * 3
 
10
 
 
11
        // The size of the output buffer.
 
12
        output_buffer_size = 128
 
13
 
 
14
        // The size of the output raw buffer.
 
15
        // It should be possible to encode the whole output buffer.
 
16
        output_raw_buffer_size = (output_buffer_size*2 + 2)
 
17
 
 
18
        // The size of other stacks and queues.
 
19
        initial_stack_size  = 16
 
20
        initial_queue_size  = 16
 
21
        initial_string_size = 16
 
22
)
 
23
 
 
24
// Check if the character at the specified position is an alphabetical
 
25
// character, a digit, '_', or '-'.
 
26
func is_alpha(b []byte, i int) bool {
 
27
        return b[i] >= '0' && b[i] <= '9' || b[i] >= 'A' && b[i] <= 'Z' || b[i] >= 'a' && b[i] <= 'z' || b[i] == '_' || b[i] == '-'
 
28
}
 
29
 
 
30
// Check if the character at the specified position is a digit.
 
31
func is_digit(b []byte, i int) bool {
 
32
        return b[i] >= '0' && b[i] <= '9'
 
33
}
 
34
 
 
35
// Get the value of a digit.
 
36
func as_digit(b []byte, i int) int {
 
37
        return int(b[i]) - '0'
 
38
}
 
39
 
 
40
// Check if the character at the specified position is a hex-digit.
 
41
func is_hex(b []byte, i int) bool {
 
42
        return b[i] >= '0' && b[i] <= '9' || b[i] >= 'A' && b[i] <= 'F' || b[i] >= 'a' && b[i] <= 'f'
 
43
}
 
44
 
 
45
// Get the value of a hex-digit.
 
46
func as_hex(b []byte, i int) int {
 
47
        bi := b[i]
 
48
        if bi >= 'A' && bi <= 'F' {
 
49
                return int(bi) - 'A' + 10
 
50
        }
 
51
        if bi >= 'a' && bi <= 'f' {
 
52
                return int(bi) - 'a' + 10
 
53
        }
 
54
        return int(bi) - '0'
 
55
}
 
56
 
 
57
// Check if the character is ASCII.
 
58
func is_ascii(b []byte, i int) bool {
 
59
        return b[i] <= 0x7F
 
60
}
 
61
 
 
62
// Check if the character at the start of the buffer can be printed unescaped.
 
63
func is_printable(b []byte, i int) bool {
 
64
        return ((b[i] == 0x0A) || // . == #x0A
 
65
                (b[i] >= 0x20 && b[i] <= 0x7E) || // #x20 <= . <= #x7E
 
66
                (b[i] == 0xC2 && b[i+1] >= 0xA0) || // #0xA0 <= . <= #xD7FF
 
67
                (b[i] > 0xC2 && b[i] < 0xED) ||
 
68
                (b[i] == 0xED && b[i+1] < 0xA0) ||
 
69
                (b[i] == 0xEE) ||
 
70
                (b[i] == 0xEF && // #xE000 <= . <= #xFFFD
 
71
                        !(b[i+1] == 0xBB && b[i+2] == 0xBF) && // && . != #xFEFF
 
72
                        !(b[i+1] == 0xBF && (b[i+2] == 0xBE || b[i+2] == 0xBF))))
 
73
}
 
74
 
 
75
// Check if the character at the specified position is NUL.
 
76
func is_z(b []byte, i int) bool {
 
77
        return b[i] == 0x00
 
78
}
 
79
 
 
80
// Check if the beginning of the buffer is a BOM.
 
81
func is_bom(b []byte, i int) bool {
 
82
        return b[0] == 0xEF && b[1] == 0xBB && b[2] == 0xBF
 
83
}
 
84
 
 
85
// Check if the character at the specified position is space.
 
86
func is_space(b []byte, i int) bool {
 
87
        return b[i] == ' '
 
88
}
 
89
 
 
90
// Check if the character at the specified position is tab.
 
91
func is_tab(b []byte, i int) bool {
 
92
        return b[i] == '\t'
 
93
}
 
94
 
 
95
// Check if the character at the specified position is blank (space or tab).
 
96
func is_blank(b []byte, i int) bool {
 
97
        //return is_space(b, i) || is_tab(b, i)
 
98
        return b[i] == ' ' || b[i] == '\t'
 
99
}
 
100
 
 
101
// Check if the character at the specified position is a line break.
 
102
func is_break(b []byte, i int) bool {
 
103
        return (b[i] == '\r' || // CR (#xD)
 
104
                b[i] == '\n' || // LF (#xA)
 
105
                b[i] == 0xC2 && b[i+1] == 0x85 || // NEL (#x85)
 
106
                b[i] == 0xE2 && b[i+1] == 0x80 && b[i+2] == 0xA8 || // LS (#x2028)
 
107
                b[i] == 0xE2 && b[i+1] == 0x80 && b[i+2] == 0xA9) // PS (#x2029)
 
108
}
 
109
 
 
110
func is_crlf(b []byte, i int) bool {
 
111
        return b[i] == '\r' && b[i+1] == '\n'
 
112
}
 
113
 
 
114
// Check if the character is a line break or NUL.
 
115
func is_breakz(b []byte, i int) bool {
 
116
        //return is_break(b, i) || is_z(b, i)
 
117
        return (        // is_break:
 
118
        b[i] == '\r' || // CR (#xD)
 
119
                b[i] == '\n' || // LF (#xA)
 
120
                b[i] == 0xC2 && b[i+1] == 0x85 || // NEL (#x85)
 
121
                b[i] == 0xE2 && b[i+1] == 0x80 && b[i+2] == 0xA8 || // LS (#x2028)
 
122
                b[i] == 0xE2 && b[i+1] == 0x80 && b[i+2] == 0xA9 || // PS (#x2029)
 
123
                // is_z:
 
124
                b[i] == 0)
 
125
}
 
126
 
 
127
// Check if the character is a line break, space, or NUL.
 
128
func is_spacez(b []byte, i int) bool {
 
129
        //return is_space(b, i) || is_breakz(b, i)
 
130
        return ( // is_space:
 
131
        b[i] == ' ' ||
 
132
                // is_breakz:
 
133
                b[i] == '\r' || // CR (#xD)
 
134
                b[i] == '\n' || // LF (#xA)
 
135
                b[i] == 0xC2 && b[i+1] == 0x85 || // NEL (#x85)
 
136
                b[i] == 0xE2 && b[i+1] == 0x80 && b[i+2] == 0xA8 || // LS (#x2028)
 
137
                b[i] == 0xE2 && b[i+1] == 0x80 && b[i+2] == 0xA9 || // PS (#x2029)
 
138
                b[i] == 0)
 
139
}
 
140
 
 
141
// Check if the character is a line break, space, tab, or NUL.
 
142
func is_blankz(b []byte, i int) bool {
 
143
        //return is_blank(b, i) || is_breakz(b, i)
 
144
        return ( // is_blank:
 
145
        b[i] == ' ' || b[i] == '\t' ||
 
146
                // is_breakz:
 
147
                b[i] == '\r' || // CR (#xD)
 
148
                b[i] == '\n' || // LF (#xA)
 
149
                b[i] == 0xC2 && b[i+1] == 0x85 || // NEL (#x85)
 
150
                b[i] == 0xE2 && b[i+1] == 0x80 && b[i+2] == 0xA8 || // LS (#x2028)
 
151
                b[i] == 0xE2 && b[i+1] == 0x80 && b[i+2] == 0xA9 || // PS (#x2029)
 
152
                b[i] == 0)
 
153
}
 
154
 
 
155
// Determine the width of the character.
 
156
func width(b byte) int {
 
157
        // Don't replace these by a switch without first
 
158
        // confirming that it is being inlined.
 
159
        if b&0x80 == 0x00 {
 
160
                return 1
 
161
        }
 
162
        if b&0xE0 == 0xC0 {
 
163
                return 2
 
164
        }
 
165
        if b&0xF0 == 0xE0 {
 
166
                return 3
 
167
        }
 
168
        if b&0xF8 == 0xF0 {
 
169
                return 4
 
170
        }
 
171
        return 0
 
172
 
 
173
}