taldir

parser.go (8701B)

---

 // Copyright 2017 The Go Authors. All rights reserved.
 // Use of this source code is governed by a BSD-style
 // license that can be found in the LICENSE file.
 
 package format
 
 import (
 	"reflect"
 	"unicode/utf8"
 )
 
 // A Parser parses a format string. The result from the parse are set in the
 // struct fields.
 type Parser struct {
 	Verb rune
 
 	WidthPresent bool
 	PrecPresent  bool
 	Minus        bool
 	Plus         bool
 	Sharp        bool
 	Space        bool
 	Zero         bool
 
 	// For the formats %+v %#v, we set the plusV/sharpV flags
 	// and clear the plus/sharp flags since %+v and %#v are in effect
 	// different, flagless formats set at the top level.
 	PlusV  bool
 	SharpV bool
 
 	HasIndex bool
 
 	Width int
 	Prec  int // precision
 
 	// retain arguments across calls.
 	Args []interface{}
 	// retain current argument number across calls
 	ArgNum int
 
 	// reordered records whether the format string used argument reordering.
 	Reordered bool
 	// goodArgNum records whether the most recent reordering directive was valid.
 	goodArgNum bool
 
 	// position info
 	format   string
 	startPos int
 	endPos   int
 	Status   Status
 }
 
 // Reset initializes a parser to scan format strings for the given args.
 func (p *Parser) Reset(args []interface{}) {
 	p.Args = args
 	p.ArgNum = 0
 	p.startPos = 0
 	p.Reordered = false
 }
 
 // Text returns the part of the format string that was parsed by the last call
 // to Scan. It returns the original substitution clause if the current scan
 // parsed a substitution.
 func (p *Parser) Text() string { return p.format[p.startPos:p.endPos] }
 
 // SetFormat sets a new format string to parse. It does not reset the argument
 // count.
 func (p *Parser) SetFormat(format string) {
 	p.format = format
 	p.startPos = 0
 	p.endPos = 0
 }
 
 // Status indicates the result type of a call to Scan.
 type Status int
 
 const (
 	StatusText Status = iota
 	StatusSubstitution
 	StatusBadWidthSubstitution
 	StatusBadPrecSubstitution
 	StatusNoVerb
 	StatusBadArgNum
 	StatusMissingArg
 )
 
 // ClearFlags reset the parser to default behavior.
 func (p *Parser) ClearFlags() {
 	p.WidthPresent = false
 	p.PrecPresent = false
 	p.Minus = false
 	p.Plus = false
 	p.Sharp = false
 	p.Space = false
 	p.Zero = false
 
 	p.PlusV = false
 	p.SharpV = false
 
 	p.HasIndex = false
 }
 
 // Scan scans the next part of the format string and sets the status to
 // indicate whether it scanned a string literal, substitution or error.
 func (p *Parser) Scan() bool {
 	p.Status = StatusText
 	format := p.format
 	end := len(format)
 	if p.endPos >= end {
 		return false
 	}
 	afterIndex := false // previous item in format was an index like [3].
 
 	p.startPos = p.endPos
 	p.goodArgNum = true
 	i := p.startPos
 	for i < end && format[i] != '%' {
 		i++
 	}
 	if i > p.startPos {
 		p.endPos = i
 		return true
 	}
 	// Process one verb
 	i++
 
 	p.Status = StatusSubstitution
 
 	// Do we have flags?
 	p.ClearFlags()
 
 simpleFormat:
 	for ; i < end; i++ {
 		c := p.format[i]
 		switch c {
 		case '#':
 			p.Sharp = true
 		case '0':
 			p.Zero = !p.Minus // Only allow zero padding to the left.
 		case '+':
 			p.Plus = true
 		case '-':
 			p.Minus = true
 			p.Zero = false // Do not pad with zeros to the right.
 		case ' ':
 			p.Space = true
 		default:
 			// Fast path for common case of ascii lower case simple verbs
 			// without precision or width or argument indices.
 			if 'a' <= c && c <= 'z' && p.ArgNum < len(p.Args) {
 				if c == 'v' {
 					// Go syntax
 					p.SharpV = p.Sharp
 					p.Sharp = false
 					// Struct-field syntax
 					p.PlusV = p.Plus
 					p.Plus = false
 				}
 				p.Verb = rune(c)
 				p.ArgNum++
 				p.endPos = i + 1
 				return true
 			}
 			// Format is more complex than simple flags and a verb or is malformed.
 			break simpleFormat
 		}
 	}
 
 	// Do we have an explicit argument index?
 	i, afterIndex = p.updateArgNumber(format, i)
 
 	// Do we have width?
 	if i < end && format[i] == '*' {
 		i++
 		p.Width, p.WidthPresent = p.intFromArg()
 
 		if !p.WidthPresent {
 			p.Status = StatusBadWidthSubstitution
 		}
 
 		// We have a negative width, so take its value and ensure
 		// that the minus flag is set
 		if p.Width < 0 {
 			p.Width = -p.Width
 			p.Minus = true
 			p.Zero = false // Do not pad with zeros to the right.
 		}
 		afterIndex = false
 	} else {
 		p.Width, p.WidthPresent, i = parsenum(format, i, end)
 		if afterIndex && p.WidthPresent { // "%[3]2d"
 			p.goodArgNum = false
 		}
 	}
 
 	// Do we have precision?
 	if i+1 < end && format[i] == '.' {
 		i++
 		if afterIndex { // "%[3].2d"
 			p.goodArgNum = false
 		}
 		i, afterIndex = p.updateArgNumber(format, i)
 		if i < end && format[i] == '*' {
 			i++
 			p.Prec, p.PrecPresent = p.intFromArg()
 			// Negative precision arguments don't make sense
 			if p.Prec < 0 {
 				p.Prec = 0
 				p.PrecPresent = false
 			}
 			if !p.PrecPresent {
 				p.Status = StatusBadPrecSubstitution
 			}
 			afterIndex = false
 		} else {
 			p.Prec, p.PrecPresent, i = parsenum(format, i, end)
 			if !p.PrecPresent {
 				p.Prec = 0
 				p.PrecPresent = true
 			}
 		}
 	}
 
 	if !afterIndex {
 		i, afterIndex = p.updateArgNumber(format, i)
 	}
 	p.HasIndex = afterIndex
 
 	if i >= end {
 		p.endPos = i
 		p.Status = StatusNoVerb
 		return true
 	}
 
 	verb, w := utf8.DecodeRuneInString(format[i:])
 	p.endPos = i + w
 	p.Verb = verb
 
 	switch {
 	case verb == '%': // Percent does not absorb operands and ignores f.wid and f.prec.
 		p.startPos = p.endPos - 1
 		p.Status = StatusText
 	case !p.goodArgNum:
 		p.Status = StatusBadArgNum
 	case p.ArgNum >= len(p.Args): // No argument left over to print for the current verb.
 		p.Status = StatusMissingArg
 		p.ArgNum++
 	case verb == 'v':
 		// Go syntax
 		p.SharpV = p.Sharp
 		p.Sharp = false
 		// Struct-field syntax
 		p.PlusV = p.Plus
 		p.Plus = false
 		fallthrough
 	default:
 		p.ArgNum++
 	}
 	return true
 }
 
 // intFromArg gets the ArgNumth element of Args. On return, isInt reports
 // whether the argument has integer type.
 func (p *Parser) intFromArg() (num int, isInt bool) {
 	if p.ArgNum < len(p.Args) {
 		arg := p.Args[p.ArgNum]
 		num, isInt = arg.(int) // Almost always OK.
 		if !isInt {
 			// Work harder.
 			switch v := reflect.ValueOf(arg); v.Kind() {
 			case reflect.Int, reflect.Int8, reflect.Int16, reflect.Int32, reflect.Int64:
 				n := v.Int()
 				if int64(int(n)) == n {
 					num = int(n)
 					isInt = true
 				}
 			case reflect.Uint, reflect.Uint8, reflect.Uint16, reflect.Uint32, reflect.Uint64, reflect.Uintptr:
 				n := v.Uint()
 				if int64(n) >= 0 && uint64(int(n)) == n {
 					num = int(n)
 					isInt = true
 				}
 			default:
 				// Already 0, false.
 			}
 		}
 		p.ArgNum++
 		if tooLarge(num) {
 			num = 0
 			isInt = false
 		}
 	}
 	return
 }
 
 // parseArgNumber returns the value of the bracketed number, minus 1
 // (explicit argument numbers are one-indexed but we want zero-indexed).
 // The opening bracket is known to be present at format[0].
 // The returned values are the index, the number of bytes to consume
 // up to the closing paren, if present, and whether the number parsed
 // ok. The bytes to consume will be 1 if no closing paren is present.
 func parseArgNumber(format string) (index int, wid int, ok bool) {
 	// There must be at least 3 bytes: [n].
 	if len(format) < 3 {
 		return 0, 1, false
 	}
 
 	// Find closing bracket.
 	for i := 1; i < len(format); i++ {
 		if format[i] == ']' {
 			width, ok, newi := parsenum(format, 1, i)
 			if !ok || newi != i {
 				return 0, i + 1, false
 			}
 			return width - 1, i + 1, true // arg numbers are one-indexed and skip paren.
 		}
 	}
 	return 0, 1, false
 }
 
 // updateArgNumber returns the next argument to evaluate, which is either the value of the passed-in
 // argNum or the value of the bracketed integer that begins format[i:]. It also returns
 // the new value of i, that is, the index of the next byte of the format to process.
 func (p *Parser) updateArgNumber(format string, i int) (newi int, found bool) {
 	if len(format) <= i || format[i] != '[' {
 		return i, false
 	}
 	p.Reordered = true
 	index, wid, ok := parseArgNumber(format[i:])
 	if ok && 0 <= index && index < len(p.Args) {
 		p.ArgNum = index
 		return i + wid, true
 	}
 	p.goodArgNum = false
 	return i + wid, ok
 }
 
 // tooLarge reports whether the magnitude of the integer is
 // too large to be used as a formatting width or precision.
 func tooLarge(x int) bool {
 	const max int = 1e6
 	return x > max || x < -max
 }
 
 // parsenum converts ASCII to integer.  num is 0 (and isnum is false) if no number present.
 func parsenum(s string, start, end int) (num int, isnum bool, newi int) {
 	if start >= end {
 		return 0, false, end
 	}
 	for newi = start; newi < end && '0' <= s[newi] && s[newi] <= '9'; newi++ {
 		if tooLarge(num) {
 			return 0, false, end // Overflow; crazy long number most likely.
 		}
 		num = num*10 + int(s[newi]-'0')
 		isnum = true
 	}
 	return
 }