decode.go raw
1 package toml
2
3 import (
4 "fmt"
5 "math"
6 "strconv"
7 "time"
8
9 "github.com/pelletier/go-toml/v2/unstable"
10 )
11
12 func parseInteger(b []byte) (int64, error) {
13 if len(b) > 2 && b[0] == '0' {
14 switch b[1] {
15 case 'x':
16 return parseIntHex(b)
17 case 'b':
18 return parseIntBin(b)
19 case 'o':
20 return parseIntOct(b)
21 default:
22 panic(fmt.Errorf("invalid base '%c', should have been checked by scanIntOrFloat", b[1]))
23 }
24 }
25
26 return parseIntDec(b)
27 }
28
29 func parseLocalDate(b []byte) (LocalDate, error) {
30 // full-date = date-fullyear "-" date-month "-" date-mday
31 // date-fullyear = 4DIGIT
32 // date-month = 2DIGIT ; 01-12
33 // date-mday = 2DIGIT ; 01-28, 01-29, 01-30, 01-31 based on month/year
34 var date LocalDate
35
36 if len(b) != 10 || b[4] != '-' || b[7] != '-' {
37 return date, unstable.NewParserError(b, "dates are expected to have the format YYYY-MM-DD")
38 }
39
40 var err error
41
42 date.Year, err = parseDecimalDigits(b[0:4])
43 if err != nil {
44 return LocalDate{}, err
45 }
46
47 date.Month, err = parseDecimalDigits(b[5:7])
48 if err != nil {
49 return LocalDate{}, err
50 }
51
52 date.Day, err = parseDecimalDigits(b[8:10])
53 if err != nil {
54 return LocalDate{}, err
55 }
56
57 if !isValidDate(date.Year, date.Month, date.Day) {
58 return LocalDate{}, unstable.NewParserError(b, "impossible date")
59 }
60
61 return date, nil
62 }
63
64 func parseDecimalDigits(b []byte) (int, error) {
65 v := 0
66
67 for i, c := range b {
68 if c < '0' || c > '9' {
69 return 0, unstable.NewParserError(b[i:i+1], "expected digit (0-9)")
70 }
71 v *= 10
72 v += int(c - '0')
73 }
74
75 return v, nil
76 }
77
78 func parseDateTime(b []byte) (time.Time, error) {
79 // offset-date-time = full-date time-delim full-time
80 // full-time = partial-time time-offset
81 // time-offset = "Z" / time-numoffset
82 // time-numoffset = ( "+" / "-" ) time-hour ":" time-minute
83
84 dt, b, err := parseLocalDateTime(b)
85 if err != nil {
86 return time.Time{}, err
87 }
88
89 var zone *time.Location
90
91 if len(b) == 0 {
92 // parser should have checked that when assigning the date time node
93 panic("date time should have a timezone")
94 }
95
96 if b[0] == 'Z' || b[0] == 'z' {
97 b = b[1:]
98 zone = time.UTC
99 } else {
100 const dateTimeByteLen = 6
101 if len(b) != dateTimeByteLen {
102 return time.Time{}, unstable.NewParserError(b, "invalid date-time timezone")
103 }
104 var direction int
105 switch b[0] {
106 case '-':
107 direction = -1
108 case '+':
109 direction = +1
110 default:
111 return time.Time{}, unstable.NewParserError(b[:1], "invalid timezone offset character")
112 }
113
114 if b[3] != ':' {
115 return time.Time{}, unstable.NewParserError(b[3:4], "expected a : separator")
116 }
117
118 hours, err := parseDecimalDigits(b[1:3])
119 if err != nil {
120 return time.Time{}, err
121 }
122 if hours > 23 {
123 return time.Time{}, unstable.NewParserError(b[:1], "invalid timezone offset hours")
124 }
125
126 minutes, err := parseDecimalDigits(b[4:6])
127 if err != nil {
128 return time.Time{}, err
129 }
130 if minutes > 59 {
131 return time.Time{}, unstable.NewParserError(b[:1], "invalid timezone offset minutes")
132 }
133
134 seconds := direction * (hours*3600 + minutes*60)
135 if seconds == 0 {
136 zone = time.UTC
137 } else {
138 zone = time.FixedZone("", seconds)
139 }
140 b = b[dateTimeByteLen:]
141 }
142
143 if len(b) > 0 {
144 return time.Time{}, unstable.NewParserError(b, "extra bytes at the end of the timezone")
145 }
146
147 t := time.Date(
148 dt.Year,
149 time.Month(dt.Month),
150 dt.Day,
151 dt.Hour,
152 dt.Minute,
153 dt.Second,
154 dt.Nanosecond,
155 zone)
156
157 return t, nil
158 }
159
160 func parseLocalDateTime(b []byte) (LocalDateTime, []byte, error) {
161 var dt LocalDateTime
162
163 const localDateTimeByteMinLen = 11
164 if len(b) < localDateTimeByteMinLen {
165 return dt, nil, unstable.NewParserError(b, "local datetimes are expected to have the format YYYY-MM-DDTHH:MM:SS[.NNNNNNNNN]")
166 }
167
168 date, err := parseLocalDate(b[:10])
169 if err != nil {
170 return dt, nil, err
171 }
172 dt.LocalDate = date
173
174 sep := b[10]
175 if sep != 'T' && sep != ' ' && sep != 't' {
176 return dt, nil, unstable.NewParserError(b[10:11], "datetime separator is expected to be T or a space")
177 }
178
179 t, rest, err := parseLocalTime(b[11:])
180 if err != nil {
181 return dt, nil, err
182 }
183 dt.LocalTime = t
184
185 return dt, rest, nil
186 }
187
188 // parseLocalTime is a bit different because it also returns the remaining
189 // []byte that is didn't need. This is to allow parseDateTime to parse those
190 // remaining bytes as a timezone.
191 func parseLocalTime(b []byte) (LocalTime, []byte, error) {
192 var (
193 nspow = [10]int{0, 1e8, 1e7, 1e6, 1e5, 1e4, 1e3, 1e2, 1e1, 1e0}
194 t LocalTime
195 )
196
197 // check if b matches to have expected format HH:MM:SS[.NNNNNN]
198 const localTimeByteLen = 8
199 if len(b) < localTimeByteLen {
200 return t, nil, unstable.NewParserError(b, "times are expected to have the format HH:MM:SS[.NNNNNN]")
201 }
202
203 var err error
204
205 t.Hour, err = parseDecimalDigits(b[0:2])
206 if err != nil {
207 return t, nil, err
208 }
209
210 if t.Hour > 23 {
211 return t, nil, unstable.NewParserError(b[0:2], "hour cannot be greater 23")
212 }
213 if b[2] != ':' {
214 return t, nil, unstable.NewParserError(b[2:3], "expecting colon between hours and minutes")
215 }
216
217 t.Minute, err = parseDecimalDigits(b[3:5])
218 if err != nil {
219 return t, nil, err
220 }
221 if t.Minute > 59 {
222 return t, nil, unstable.NewParserError(b[3:5], "minutes cannot be greater 59")
223 }
224 if b[5] != ':' {
225 return t, nil, unstable.NewParserError(b[5:6], "expecting colon between minutes and seconds")
226 }
227
228 t.Second, err = parseDecimalDigits(b[6:8])
229 if err != nil {
230 return t, nil, err
231 }
232
233 if t.Second > 60 {
234 return t, nil, unstable.NewParserError(b[6:8], "seconds cannot be greater 60")
235 }
236
237 b = b[8:]
238
239 if len(b) >= 1 && b[0] == '.' {
240 frac := 0
241 precision := 0
242 digits := 0
243
244 for i, c := range b[1:] {
245 if !isDigit(c) {
246 if i == 0 {
247 return t, nil, unstable.NewParserError(b[0:1], "need at least one digit after fraction point")
248 }
249 break
250 }
251 digits++
252
253 const maxFracPrecision = 9
254 if i >= maxFracPrecision {
255 // go-toml allows decoding fractional seconds
256 // beyond the supported precision of 9
257 // digits. It truncates the fractional component
258 // to the supported precision and ignores the
259 // remaining digits.
260 //
261 // https://github.com/pelletier/go-toml/discussions/707
262 continue
263 }
264
265 frac *= 10
266 frac += int(c - '0')
267 precision++
268 }
269
270 if precision == 0 {
271 return t, nil, unstable.NewParserError(b[:1], "nanoseconds need at least one digit")
272 }
273
274 t.Nanosecond = frac * nspow[precision]
275 t.Precision = precision
276
277 return t, b[1+digits:], nil
278 }
279 return t, b, nil
280 }
281
282 //nolint:cyclop
283 func parseFloat(b []byte) (float64, error) {
284 if len(b) == 4 && (b[0] == '+' || b[0] == '-') && b[1] == 'n' && b[2] == 'a' && b[3] == 'n' {
285 return math.NaN(), nil
286 }
287
288 cleaned, err := checkAndRemoveUnderscoresFloats(b)
289 if err != nil {
290 return 0, err
291 }
292
293 if cleaned[0] == '.' {
294 return 0, unstable.NewParserError(b, "float cannot start with a dot")
295 }
296
297 if cleaned[len(cleaned)-1] == '.' {
298 return 0, unstable.NewParserError(b, "float cannot end with a dot")
299 }
300
301 dotAlreadySeen := false
302 for i, c := range cleaned {
303 if c == '.' {
304 if dotAlreadySeen {
305 return 0, unstable.NewParserError(b[i:i+1], "float can have at most one decimal point")
306 }
307 if !isDigit(cleaned[i-1]) {
308 return 0, unstable.NewParserError(b[i-1:i+1], "float decimal point must be preceded by a digit")
309 }
310 if !isDigit(cleaned[i+1]) {
311 return 0, unstable.NewParserError(b[i:i+2], "float decimal point must be followed by a digit")
312 }
313 dotAlreadySeen = true
314 }
315 }
316
317 start := 0
318 if cleaned[0] == '+' || cleaned[0] == '-' {
319 start = 1
320 }
321 if cleaned[start] == '0' && len(cleaned) > start+1 && isDigit(cleaned[start+1]) {
322 return 0, unstable.NewParserError(b, "float integer part cannot have leading zeroes")
323 }
324
325 f, err := strconv.ParseFloat(string(cleaned), 64)
326 if err != nil {
327 return 0, unstable.NewParserError(b, "unable to parse float: %w", err)
328 }
329
330 return f, nil
331 }
332
333 func parseIntHex(b []byte) (int64, error) {
334 cleaned, err := checkAndRemoveUnderscoresIntegers(b[2:])
335 if err != nil {
336 return 0, err
337 }
338
339 i, err := strconv.ParseInt(string(cleaned), 16, 64)
340 if err != nil {
341 return 0, unstable.NewParserError(b, "couldn't parse hexadecimal number: %w", err)
342 }
343
344 return i, nil
345 }
346
347 func parseIntOct(b []byte) (int64, error) {
348 cleaned, err := checkAndRemoveUnderscoresIntegers(b[2:])
349 if err != nil {
350 return 0, err
351 }
352
353 i, err := strconv.ParseInt(string(cleaned), 8, 64)
354 if err != nil {
355 return 0, unstable.NewParserError(b, "couldn't parse octal number: %w", err)
356 }
357
358 return i, nil
359 }
360
361 func parseIntBin(b []byte) (int64, error) {
362 cleaned, err := checkAndRemoveUnderscoresIntegers(b[2:])
363 if err != nil {
364 return 0, err
365 }
366
367 i, err := strconv.ParseInt(string(cleaned), 2, 64)
368 if err != nil {
369 return 0, unstable.NewParserError(b, "couldn't parse binary number: %w", err)
370 }
371
372 return i, nil
373 }
374
375 func isSign(b byte) bool {
376 return b == '+' || b == '-'
377 }
378
379 func parseIntDec(b []byte) (int64, error) {
380 cleaned, err := checkAndRemoveUnderscoresIntegers(b)
381 if err != nil {
382 return 0, err
383 }
384
385 startIdx := 0
386
387 if isSign(cleaned[0]) {
388 startIdx++
389 }
390
391 if len(cleaned) > startIdx+1 && cleaned[startIdx] == '0' {
392 return 0, unstable.NewParserError(b, "leading zero not allowed on decimal number")
393 }
394
395 i, err := strconv.ParseInt(string(cleaned), 10, 64)
396 if err != nil {
397 return 0, unstable.NewParserError(b, "couldn't parse decimal number: %w", err)
398 }
399
400 return i, nil
401 }
402
403 func checkAndRemoveUnderscoresIntegers(b []byte) ([]byte, error) {
404 start := 0
405 if b[start] == '+' || b[start] == '-' {
406 start++
407 }
408
409 if len(b) == start {
410 return b, nil
411 }
412
413 if b[start] == '_' {
414 return nil, unstable.NewParserError(b[start:start+1], "number cannot start with underscore")
415 }
416
417 if b[len(b)-1] == '_' {
418 return nil, unstable.NewParserError(b[len(b)-1:], "number cannot end with underscore")
419 }
420
421 // fast path
422 i := 0
423 for ; i < len(b); i++ {
424 if b[i] == '_' {
425 break
426 }
427 }
428 if i == len(b) {
429 return b, nil
430 }
431
432 before := false
433 cleaned := make([]byte, i, len(b))
434 copy(cleaned, b)
435
436 for i++; i < len(b); i++ {
437 c := b[i]
438 if c == '_' {
439 if !before {
440 return nil, unstable.NewParserError(b[i-1:i+1], "number must have at least one digit between underscores")
441 }
442 before = false
443 } else {
444 before = true
445 cleaned = append(cleaned, c)
446 }
447 }
448
449 return cleaned, nil
450 }
451
452 func checkAndRemoveUnderscoresFloats(b []byte) ([]byte, error) {
453 if b[0] == '_' {
454 return nil, unstable.NewParserError(b[0:1], "number cannot start with underscore")
455 }
456
457 if b[len(b)-1] == '_' {
458 return nil, unstable.NewParserError(b[len(b)-1:], "number cannot end with underscore")
459 }
460
461 // fast path
462 i := 0
463 for ; i < len(b); i++ {
464 if b[i] == '_' {
465 break
466 }
467 }
468 if i == len(b) {
469 return b, nil
470 }
471
472 before := false
473 cleaned := make([]byte, 0, len(b))
474
475 for i := 0; i < len(b); i++ {
476 c := b[i]
477
478 switch c {
479 case '_':
480 if !before {
481 return nil, unstable.NewParserError(b[i-1:i+1], "number must have at least one digit between underscores")
482 }
483 if i < len(b)-1 && (b[i+1] == 'e' || b[i+1] == 'E') {
484 return nil, unstable.NewParserError(b[i+1:i+2], "cannot have underscore before exponent")
485 }
486 before = false
487 case '+', '-':
488 // signed exponents
489 cleaned = append(cleaned, c)
490 before = false
491 case 'e', 'E':
492 if i < len(b)-1 && b[i+1] == '_' {
493 return nil, unstable.NewParserError(b[i+1:i+2], "cannot have underscore after exponent")
494 }
495 cleaned = append(cleaned, c)
496 case '.':
497 if i < len(b)-1 && b[i+1] == '_' {
498 return nil, unstable.NewParserError(b[i+1:i+2], "cannot have underscore after decimal point")
499 }
500 if i > 0 && b[i-1] == '_' {
501 return nil, unstable.NewParserError(b[i-1:i], "cannot have underscore before decimal point")
502 }
503 cleaned = append(cleaned, c)
504 default:
505 before = true
506 cleaned = append(cleaned, c)
507 }
508 }
509
510 return cleaned, nil
511 }
512
513 // isValidDate checks if a provided date is a date that exists.
514 func isValidDate(year int, month int, day int) bool {
515 return month > 0 && month < 13 && day > 0 && day <= daysIn(month, year)
516 }
517
518 // daysBefore[m] counts the number of days in a non-leap year
519 // before month m begins. There is an entry for m=12, counting
520 // the number of days before January of next year (365).
521 var daysBefore = [...]int32{
522 0,
523 31,
524 31 + 28,
525 31 + 28 + 31,
526 31 + 28 + 31 + 30,
527 31 + 28 + 31 + 30 + 31,
528 31 + 28 + 31 + 30 + 31 + 30,
529 31 + 28 + 31 + 30 + 31 + 30 + 31,
530 31 + 28 + 31 + 30 + 31 + 30 + 31 + 31,
531 31 + 28 + 31 + 30 + 31 + 30 + 31 + 31 + 30,
532 31 + 28 + 31 + 30 + 31 + 30 + 31 + 31 + 30 + 31,
533 31 + 28 + 31 + 30 + 31 + 30 + 31 + 31 + 30 + 31 + 30,
534 31 + 28 + 31 + 30 + 31 + 30 + 31 + 31 + 30 + 31 + 30 + 31,
535 }
536
537 func daysIn(m int, year int) int {
538 if m == 2 && isLeap(year) {
539 return 29
540 }
541 return int(daysBefore[m] - daysBefore[m-1])
542 }
543
544 func isLeap(year int) bool {
545 return year%4 == 0 && (year%100 != 0 || year%400 == 0)
546 }
547
548 func isDigit(r byte) bool {
549 return r >= '0' && r <= '9'
550 }
551