golang/mikael/madonctl: comparison vendor/github.com/pelletier/go-toml/parser.go

equal deleted inserted replaced

-:4f153a23adab
+:6d9efbef00a9
 import (
 	"errors"
 	"fmt"
 	"math"
 	"reflect"
-	"regexp"
 	"strconv"
 	"strings"
 	"time"
 )
 		p.raiseError(key, "invalid table array key: %s", err)
 	}
 	if err := p.tree.createSubTree(keys, startToken.Position); err != nil {
 		p.raiseError(key, "%s", err)
 	}
+	destTree := p.tree.GetPath(keys)
+	if target, ok := destTree.(*Tree); ok && target != nil && target.inline {
+		p.raiseError(key, "could not re-define exist inline table or its sub-table : %s",
+			strings.Join(keys, "."))
+	}
 	p.assume(tokenRightBracket)
 	p.currentTable = keys
 	return p.parseStart
 }
 	default:
 		p.raiseError(key, "Unknown table type for path: %s",
 			strings.Join(tableKey, "."))
 	}
+	if targetNode.inline {
+		p.raiseError(key, "could not add key or sub-table to exist inline table or its sub-table : %s",
+			strings.Join(tableKey, "."))
+	}
 	// assign value to the found table
 	keyVal := parsedKey[len(parsedKey)-1]
 	localKey := []string{keyVal}
 	finalKey := append(tableKey, keyVal)
 	if targetNode.GetPath(localKey) != nil {
 	}
 	targetNode.values[keyVal] = toInsert
 	return p.parseStart
 }
-var numberUnderscoreInvalidRegexp *regexp.Regexp
+var errInvalidUnderscore = errors.New("invalid use of _ in number")
-var hexNumberUnderscoreInvalidRegexp *regexp.Regexp
 func numberContainsInvalidUnderscore(value string) error {
-	if numberUnderscoreInvalidRegexp.MatchString(value) {
+	// For large numbers, you may use underscores between digits to enhance
-		return errors.New("invalid use of _ in number")
+	// readability. Each underscore must be surrounded by at least one digit on
+	// each side.
+	hasBefore := false
+	for idx, r := range value {
+		if r == '_' {
+			if !hasBefore || idx+1 >= len(value) {
+				// can't end with an underscore
+				return errInvalidUnderscore
+			}
+		}
+		hasBefore = isDigit(r)
 	}
 	return nil
 }
+var errInvalidUnderscoreHex = errors.New("invalid use of _ in hex number")
 func hexNumberContainsInvalidUnderscore(value string) error {
-	if hexNumberUnderscoreInvalidRegexp.MatchString(value) {
+	hasBefore := false
-		return errors.New("invalid use of _ in hex number")
+	for idx, r := range value {
+		if r == '_' {
+			if !hasBefore || idx+1 >= len(value) {
+				// can't end with an underscore
+				return errInvalidUnderscoreHex
+			}
+		}
+		hasBefore = isHexDigit(r)
 	}
 	return nil
 }
 func cleanupNumberToken(value string) string {
 		val, err := strconv.ParseFloat(cleanedVal, 64)
 		if err != nil {
 			p.raiseError(tok, "%s", err)
 		}
 		return val
-	case tokenDate:
+	case tokenLocalTime:
-		layout := time.RFC3339Nano
+		val, err := ParseLocalTime(tok.val)
-		if !strings.Contains(tok.val, "T") {
-			layout = strings.Replace(layout, "T", " ", 1)
-		}
-		val, err := time.ParseInLocation(layout, tok.val, time.UTC)
 		if err != nil {
 			p.raiseError(tok, "%s", err)
 		}
 		return val
 	case tokenLocalDate:
-		v := strings.Replace(tok.val, " ", "T", -1)
+		// a local date may be followed by:
-		isDateTime := false
+		// * nothing: this is a local date
-		isTime := false
+		// * a local time: this is a local date-time
-		for _, c := range v {
-			if c == 'T' || c == 't' {
+		next := p.peek()
-				isDateTime = true
+		if next == nil || next.typ != tokenLocalTime {
-				break
+			val, err := ParseLocalDate(tok.val)
-			}
+			if err != nil {
-			if c == ':' {
+				p.raiseError(tok, "%s", err)
-				isTime = true
+			}
-				break
+			return val
-			}
+		}
-		}
+		localDate := tok
-		var val interface{}
+		localTime := p.getToken()
-		var err error
+		next = p.peek()
-		if isDateTime {
+		if next == nil || next.typ != tokenTimeOffset {
-			val, err = ParseLocalDateTime(v)
+			v := localDate.val + "T" + localTime.val
-		} else if isTime {
+			val, err := ParseLocalDateTime(v)
-			val, err = ParseLocalTime(v)
+			if err != nil {
-		} else {
+				p.raiseError(tok, "%s", err)
-			val, err = ParseLocalDate(v)
+			}
-		}
+			return val
+		}
+		offset := p.getToken()
+		layout := time.RFC3339Nano
+		v := localDate.val + "T" + localTime.val + offset.val
+		val, err := time.ParseInLocation(layout, v, time.UTC)
 		if err != nil {
 			p.raiseError(tok, "%s", err)
 		}
 		return val
 	case tokenLeftBracket:
 		return p.parseInlineTable()
 	case tokenEqual:
 		p.raiseError(tok, "cannot have multiple equals for the same key")
 	case tokenError:
 		p.raiseError(tok, "%s", tok)
-	}
+	default:
+		panic(fmt.Errorf("unhandled token: %v", tok))
-	p.raiseError(tok, "never reached")
+	}
 	return nil
 }
 func tokenIsComma(t *token) bool {
 		previous = follow
 	}
 	if tokenIsComma(previous) {
 		p.raiseError(previous, "trailing comma at the end of inline table")
 	}
+	tree.inline = true
 	return tree
 }
 func (p *tomlParser) parseArray() interface{} {
 	var array []interface{}
-	arrayType := reflect.TypeOf(nil)
+	arrayType := reflect.TypeOf(newTree())
 	for {
 		follow := p.peek()
 		if follow == nil || follow.typ == tokenEOF {
 			p.raiseError(follow, "unterminated array")
 		}
 		if follow.typ == tokenRightBracket {
 			p.getToken()
 			break
 		}
 		val := p.parseRvalue()
-		if arrayType == nil {
-			arrayType = reflect.TypeOf(val)
-		}
 		if reflect.TypeOf(val) != arrayType {
-			p.raiseError(follow, "mixed types in array")
+			arrayType = nil
 		}
 		array = append(array, val)
 		follow = p.peek()
 		if follow == nil || follow.typ == tokenEOF {
 			p.raiseError(follow, "unterminated array")
 			p.raiseError(follow, "missing comma")
 		}
 		if follow.typ == tokenComma {
 			p.getToken()
 		}
+	}
+	// if the array is a mixed-type array or its length is 0,
+	// don't convert it to a table array
+	if len(array) <= 0 {
+		arrayType = nil
 	}
 	// An array of Trees is actually an array of inline
 	// tables, which is a shorthand for a table array. If the
 	// array was not converted from []interface{} to []*Tree,
 	// the two notations would not be equivalent.
 		seenTableKeys: make([]string, 0),
 	}
 	parser.run()
 	return result
 }
-func init() {
-	numberUnderscoreInvalidRegexp = regexp.MustCompile(`([^\d]_|_[^\d])|_$|^_`)
-	hexNumberUnderscoreInvalidRegexp = regexp.MustCompile(`(^0x_)|([^\da-f]_|_[^\da-f])|_$|^_`)
-}

changeset 256	6d9efbef00a9
parent 251	1c52a0eeb952
child 260	445e01aede7e