Hojun-Cho
10672f3816
Dead, vestigial, and over-built code with no behavior change (except the
bool-vocabulary trim, a deliberate behavior tightening):
- httpdl: drop the vestigial sort+copy in validSegs (work-stealing was
removed in 270812d, so segments always tile [0,total) ascending now);
validate order in place, which also rejects a scrambled sidecar. Inline
the endOff() accessor to s.end.
- cli: shrink the boolean vocabulary to true/false, which is all that's
accepted. The invented yes/no/1/0/on/off spellings are gone, so e.g.
--enable-dht=yes (or yes in got.conf) is now a usage error.
- download: remove the dead, never-called Stat.Done() method.
- progress: drop speed(), a pure alias of humanSize; call humanSize directly.
- main: replace the jobsHolder mutex box with atomic.Pointer[[]job] for the
forced-exit session save; the capability stays, the lock and type go.
- bt: collapse isAddrInUse's X||X (missinggo.IsAddrInUse is that exact
string match); drop the now-unused missinggo import (tidy -> indirect).
- option: note that prealloc and falloc are identical here.
115 lines
3.5 KiB
Go
115 lines
3.5 KiB
Go
package cli
|
|
|
|
import (
|
|
"fmt"
|
|
"math"
|
|
"strconv"
|
|
"strings"
|
|
)
|
|
|
|
// Options is the resolved configuration: a flat name->value map plus a record
|
|
// of which names were explicitly set (so callers can tell a default from a
|
|
// chosen value). Values are kept as strings end-to-end and converted only at
|
|
// the point of use by the typed getters below.
|
|
type Options struct {
|
|
vals map[string]string
|
|
set map[string]bool
|
|
}
|
|
|
|
func newOptions() *Options {
|
|
return &Options{vals: map[string]string{}, set: map[string]bool{}}
|
|
}
|
|
|
|
// IsSet reports whether name was given on the command line or in the config
|
|
// (as opposed to coming from the built-in default).
|
|
func (o *Options) IsSet(name string) bool { return o.set[name] }
|
|
|
|
// Str returns the raw string value (empty if unset and no default).
|
|
func (o *Options) Str(name string) string { return o.vals[name] }
|
|
|
|
// boolWords is the accepted vocabulary for boolean options. aria2 takes only
|
|
// true/false (and rejects everything else), so we match it rather than inventing
|
|
// extra spellings. boolWord is the single consult point — the Bool reader,
|
|
// validate(), and the no-conf bootstrap all go through it — so exactly the words
|
|
// that validate are honoured.
|
|
var boolWords = map[string]bool{
|
|
"true": true,
|
|
"false": false,
|
|
}
|
|
|
|
// boolWord reports a value's truth and whether it is a recognised boolean word.
|
|
func boolWord(s string) (val, ok bool) {
|
|
val, ok = boolWords[strings.ToLower(strings.TrimSpace(s))]
|
|
return val, ok
|
|
}
|
|
|
|
// Bool reports whether the value is a truthy boolean word.
|
|
func (o *Options) Bool(name string) bool {
|
|
val, _ := boolWord(o.vals[name])
|
|
return val
|
|
}
|
|
|
|
// Int returns the value as an int, or 0 if empty/invalid. The value has already
|
|
// passed validate(), so a parse failure here is unreachable in normal flow.
|
|
func (o *Options) Int(name string) int {
|
|
n, _ := strconv.ParseInt(strings.TrimSpace(o.vals[name]), 10, 64)
|
|
return int(n)
|
|
}
|
|
|
|
// Float returns the value as a float64, or 0 if empty/invalid.
|
|
func (o *Options) Float(name string) float64 {
|
|
f, _ := strconv.ParseFloat(strings.TrimSpace(o.vals[name]), 64)
|
|
return f
|
|
}
|
|
|
|
// Size returns a byte count parsed from a value like "20M" or "512K".
|
|
func (o *Options) Size(name string) int64 {
|
|
n, _ := parseSize(o.vals[name])
|
|
return n
|
|
}
|
|
|
|
// List returns a repeatable option's accumulated values.
|
|
func (o *Options) List(name string) []string {
|
|
v := o.vals[name]
|
|
if v == "" {
|
|
return nil
|
|
}
|
|
return strings.Split(v, "\n")
|
|
}
|
|
|
|
// parseSize converts a size string into a byte count: the first 'K'/'k' or
|
|
// 'M'/'m' in the string selects the multiplier (1024 or 1024*1024) and
|
|
// everything from that byte on is discarded; with no such unit the whole string
|
|
// is the byte count. There is no gigabyte unit, so "1G" is rejected; "1Mi" and
|
|
// "10MB" are 1M and 10M (the trailing bytes are dropped). An empty string is 0
|
|
// bytes; a negative value is rejected.
|
|
func parseSize(s string) (int64, error) {
|
|
s = strings.TrimSpace(s)
|
|
if s == "" {
|
|
return 0, nil
|
|
}
|
|
mult := int64(1)
|
|
if i := strings.IndexAny(s, "KkMm"); i >= 0 {
|
|
if c := s[i]; c == 'M' || c == 'm' {
|
|
mult = 1 << 20
|
|
} else {
|
|
mult = 1 << 10
|
|
}
|
|
s = s[:i]
|
|
}
|
|
n, err := strconv.ParseInt(strings.TrimSpace(s), 10, 64)
|
|
if err != nil {
|
|
return 0, fmt.Errorf("bad size %q", s)
|
|
}
|
|
// Size parsing rejects negative sizes outright.
|
|
if n < 0 {
|
|
return 0, fmt.Errorf("negative size %q", s)
|
|
}
|
|
// Reject a value whose unit multiply would overflow int64 and silently wrap to
|
|
// a bogus (positive or negative) byte count.
|
|
if mult > 1 && n > math.MaxInt64/mult {
|
|
return 0, fmt.Errorf("size %q too large", s)
|
|
}
|
|
return n * mult, nil
|
|
}
|