pkg/strconv/strconv.go - cue - Git at Google

 // Copyright 2020 The CUE Authors
 //
 // Licensed under the Apache License, Version 2.0 (the "License");
 // you may not use this file except in compliance with the License.
 // You may obtain a copy of the License at
 //
 //     http://www.apache.org/licenses/LICENSE-2.0
 //
 // Unless required by applicable law or agreed to in writing, software
 // distributed under the License is distributed on an "AS IS" BASIS,
 // WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
 // See the License for the specific language governing permissions and
 // limitations under the License.

 // Copyright 2018 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.

 //go:generate go run cuelang.org/go/internal/cmd/qgo -exclude=Append,Unquote,Itoa,CanBackquote extract strconv

 package strconv

 import "strconv"

 // ParseBool returns the boolean value represented by the string.
 // It accepts 1, t, T, TRUE, true, True, 0, f, F, FALSE, false, False.
 // Any other value returns an error.
 func ParseBool(str string) (bool, error) {
 	return strconv.ParseBool(str)
 }

 // FormatBool returns "true" or "false" according to the value of b.
 func FormatBool(b bool) string {
 	return strconv.FormatBool(b)
 }

 // ParseFloat converts the string s to a floating-point number
 // with the precision specified by bitSize: 32 for float32, or 64 for float64.
 // When bitSize=32, the result still has type float64, but it will be
 // convertible to float32 without changing its value.
 //
 // ParseFloat accepts decimal and hexadecimal floating-point number syntax.
 // If s is well-formed and near a valid floating-point number,
 // ParseFloat returns the nearest floating-point number rounded
 // using IEEE754 unbiased rounding.
 // (Parsing a hexadecimal floating-point value only rounds when
 // there are more bits in the hexadecimal representation than
 // will fit in the mantissa.)
 //
 // The errors that ParseFloat returns have concrete type *NumError
 // and include err.Num = s.
 //
 // If s is not syntactically well-formed, ParseFloat returns err.Err = ErrSyntax.
 //
 // If s is syntactically well-formed but is more than 1/2 ULP
 // away from the largest floating point number of the given size,
 // ParseFloat returns f = ±Inf, err.Err = ErrRange.
 //
 // ParseFloat recognizes the strings "NaN", "+Inf", and "-Inf" as their
 // respective special floating point values. It ignores case when matching.
 func ParseFloat(s string, bitSize int) (float64, error) {
 	return strconv.ParseFloat(s, bitSize)
 }

 // IntSize is the size in bits of an int or uint value.
 const IntSize = 64

 // ParseUint is like ParseInt but for unsigned numbers.
 func ParseUint(s string, base int, bitSize int) (uint64, error) {
 	return strconv.ParseUint(s, base, bitSize)
 }

 // ParseInt interprets a string s in the given base (0, 2 to 36) and
 // bit size (0 to 64) and returns the corresponding value i.
 //
 // If the base argument is 0, the true base is implied by the string's
 // prefix: 2 for "0b", 8 for "0" or "0o", 16 for "0x", and 10 otherwise.
 // Also, for argument base 0 only, underscore characters are permitted
 // as defined by the Go syntax for integer literals.
 //
 // The bitSize argument specifies the integer type
 // that the result must fit into. Bit sizes 0, 8, 16, 32, and 64
 // correspond to int, int8, int16, int32, and int64.
 // If bitSize is below 0 or above 64, an error is returned.
 //
 // The errors that ParseInt returns have concrete type *NumError
 // and include err.Num = s. If s is empty or contains invalid
 // digits, err.Err = ErrSyntax and the returned value is 0;
 // if the value corresponding to s cannot be represented by a
 // signed integer of the given size, err.Err = ErrRange and the
 // returned value is the maximum magnitude integer of the
 // appropriate bitSize and sign.
 func ParseInt(s string, base int, bitSize int) (i int64, err error) {
 	return strconv.ParseInt(s, base, bitSize)
 }

 // Atoi is equivalent to ParseInt(s, 10, 0), converted to type int.
 func Atoi(s string) (int, error) {
 	return strconv.Atoi(s)
 }

 // FormatFloat converts the floating-point number f to a string,
 // according to the format fmt and precision prec. It rounds the
 // result assuming that the original was obtained from a floating-point
 // value of bitSize bits (32 for float32, 64 for float64).
 //
 // The format fmt is one of
 // 'b' (-ddddp±ddd, a binary exponent),
 // 'e' (-d.dddde±dd, a decimal exponent),
 // 'E' (-d.ddddE±dd, a decimal exponent),
 // 'f' (-ddd.dddd, no exponent),
 // 'g' ('e' for large exponents, 'f' otherwise),
 // 'G' ('E' for large exponents, 'f' otherwise),
 // 'x' (-0xd.ddddp±ddd, a hexadecimal fraction and binary exponent), or
 // 'X' (-0Xd.ddddP±ddd, a hexadecimal fraction and binary exponent).
 //
 // The precision prec controls the number of digits (excluding the exponent)
 // printed by the 'e', 'E', 'f', 'g', 'G', 'x', and 'X' formats.
 // For 'e', 'E', 'f', 'x', and 'X', it is the number of digits after the decimal point.
 // For 'g' and 'G' it is the maximum number of significant digits (trailing
 // zeros are removed).
 // The special precision -1 uses the smallest number of digits
 // necessary such that ParseFloat will return f exactly.
 func FormatFloat(f float64, fmt byte, prec, bitSize int) string {
 	return strconv.FormatFloat(f, fmt, prec, bitSize)
 }

 // FormatUint returns the string representation of i in the given base,
 // for 2 <= base <= 36. The result uses the lower-case letters 'a' to 'z'
 // for digit values >= 10.
 func FormatUint(i uint64, base int) string {
 	return strconv.FormatUint(i, base)
 }

 // FormatInt returns the string representation of i in the given base,
 // for 2 <= base <= 36. The result uses the lower-case letters 'a' to 'z'
 // for digit values >= 10.
 func FormatInt(i int64, base int) string {
 	return strconv.FormatInt(i, base)
 }

 // Quote returns a double-quoted Go string literal representing s. The
 // returned string uses Go escape sequences (\t, \n, \xFF, \u0100) for
 // control characters and non-printable characters as defined by
 // IsPrint.
 func Quote(s string) string {
 	return strconv.Quote(s)
 }

 // QuoteToASCII returns a double-quoted Go string literal representing s.
 // The returned string uses Go escape sequences (\t, \n, \xFF, \u0100) for
 // non-ASCII characters and non-printable characters as defined by IsPrint.
 func QuoteToASCII(s string) string {
 	return strconv.QuoteToASCII(s)
 }

 // QuoteToGraphic returns a double-quoted Go string literal representing s.
 // The returned string leaves Unicode graphic characters, as defined by
 // IsGraphic, unchanged and uses Go escape sequences (\t, \n, \xFF, \u0100)
 // for non-graphic characters.
 func QuoteToGraphic(s string) string {
 	return strconv.QuoteToGraphic(s)
 }

 // QuoteRune returns a single-quoted Go character literal representing the
 // rune. The returned string uses Go escape sequences (\t, \n, \xFF, \u0100)
 // for control characters and non-printable characters as defined by IsPrint.
 func QuoteRune(r rune) string {
 	return strconv.QuoteRune(r)
 }

 // QuoteRuneToASCII returns a single-quoted Go character literal representing
 // the rune. The returned string uses Go escape sequences (\t, \n, \xFF,
 // \u0100) for non-ASCII characters and non-printable characters as defined
 // by IsPrint.
 func QuoteRuneToASCII(r rune) string {
 	return strconv.QuoteRuneToASCII(r)
 }

 // QuoteRuneToGraphic returns a single-quoted Go character literal representing
 // the rune. If the rune is not a Unicode graphic character,
 // as defined by IsGraphic, the returned string will use a Go escape sequence
 // (\t, \n, \xFF, \u0100).
 func QuoteRuneToGraphic(r rune) string {
 	return strconv.QuoteRuneToGraphic(r)
 }

 // IsPrint reports whether the rune is defined as printable by Go, with
 // the same definition as unicode.IsPrint: letters, numbers, punctuation,
 // symbols and ASCII space.
 func IsPrint(r rune) bool {
 	return strconv.IsPrint(r)
 }

 // IsGraphic reports whether the rune is defined as a Graphic by Unicode. Such
 // characters include letters, marks, numbers, punctuation, symbols, and
 // spaces, from categories L, M, N, P, S, and Zs.
 func IsGraphic(r rune) bool {
 	return strconv.IsGraphic(r)
 }
	// Copyright 2020 The CUE Authors
	//
	// Licensed under the Apache License, Version 2.0 (the "License");
	// you may not use this file except in compliance with the License.
	// You may obtain a copy of the License at
	//
	// http://www.apache.org/licenses/LICENSE-2.0
	//
	// Unless required by applicable law or agreed to in writing, software
	// distributed under the License is distributed on an "AS IS" BASIS,
	// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
	// See the License for the specific language governing permissions and
	// limitations under the License.

	// Copyright 2018 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.

	//go:generate go run cuelang.org/go/internal/cmd/qgo -exclude=Append,Unquote,Itoa,CanBackquote extract strconv

	package strconv

	import "strconv"

	// ParseBool returns the boolean value represented by the string.
	// It accepts 1, t, T, TRUE, true, True, 0, f, F, FALSE, false, False.
	// Any other value returns an error.
	func ParseBool(str string) (bool, error) {
	return strconv.ParseBool(str)
	}

	// FormatBool returns "true" or "false" according to the value of b.
	func FormatBool(b bool) string {
	return strconv.FormatBool(b)
	}

	// ParseFloat converts the string s to a floating-point number
	// with the precision specified by bitSize: 32 for float32, or 64 for float64.
	// When bitSize=32, the result still has type float64, but it will be
	// convertible to float32 without changing its value.
	//
	// ParseFloat accepts decimal and hexadecimal floating-point number syntax.
	// If s is well-formed and near a valid floating-point number,
	// ParseFloat returns the nearest floating-point number rounded
	// using IEEE754 unbiased rounding.
	// (Parsing a hexadecimal floating-point value only rounds when
	// there are more bits in the hexadecimal representation than
	// will fit in the mantissa.)
	//
	// The errors that ParseFloat returns have concrete type *NumError
	// and include err.Num = s.
	//
	// If s is not syntactically well-formed, ParseFloat returns err.Err = ErrSyntax.
	//
	// If s is syntactically well-formed but is more than 1/2 ULP
	// away from the largest floating point number of the given size,
	// ParseFloat returns f = ±Inf, err.Err = ErrRange.
	//
	// ParseFloat recognizes the strings "NaN", "+Inf", and "-Inf" as their
	// respective special floating point values. It ignores case when matching.
	func ParseFloat(s string, bitSize int) (float64, error) {
	return strconv.ParseFloat(s, bitSize)
	}

	// IntSize is the size in bits of an int or uint value.
	const IntSize = 64

	// ParseUint is like ParseInt but for unsigned numbers.
	func ParseUint(s string, base int, bitSize int) (uint64, error) {
	return strconv.ParseUint(s, base, bitSize)
	}

	// ParseInt interprets a string s in the given base (0, 2 to 36) and
	// bit size (0 to 64) and returns the corresponding value i.
	//
	// If the base argument is 0, the true base is implied by the string's
	// prefix: 2 for "0b", 8 for "0" or "0o", 16 for "0x", and 10 otherwise.
	// Also, for argument base 0 only, underscore characters are permitted
	// as defined by the Go syntax for integer literals.
	//
	// The bitSize argument specifies the integer type
	// that the result must fit into. Bit sizes 0, 8, 16, 32, and 64
	// correspond to int, int8, int16, int32, and int64.
	// If bitSize is below 0 or above 64, an error is returned.
	//
	// The errors that ParseInt returns have concrete type *NumError
	// and include err.Num = s. If s is empty or contains invalid
	// digits, err.Err = ErrSyntax and the returned value is 0;
	// if the value corresponding to s cannot be represented by a
	// signed integer of the given size, err.Err = ErrRange and the
	// returned value is the maximum magnitude integer of the
	// appropriate bitSize and sign.
	func ParseInt(s string, base int, bitSize int) (i int64, err error) {
	return strconv.ParseInt(s, base, bitSize)
	}

	// Atoi is equivalent to ParseInt(s, 10, 0), converted to type int.
	func Atoi(s string) (int, error) {
	return strconv.Atoi(s)
	}

	// FormatFloat converts the floating-point number f to a string,
	// according to the format fmt and precision prec. It rounds the
	// result assuming that the original was obtained from a floating-point
	// value of bitSize bits (32 for float32, 64 for float64).
	//
	// The format fmt is one of
	// 'b' (-ddddp±ddd, a binary exponent),
	// 'e' (-d.dddde±dd, a decimal exponent),
	// 'E' (-d.ddddE±dd, a decimal exponent),
	// 'f' (-ddd.dddd, no exponent),
	// 'g' ('e' for large exponents, 'f' otherwise),
	// 'G' ('E' for large exponents, 'f' otherwise),
	// 'x' (-0xd.ddddp±ddd, a hexadecimal fraction and binary exponent), or
	// 'X' (-0Xd.ddddP±ddd, a hexadecimal fraction and binary exponent).
	//
	// The precision prec controls the number of digits (excluding the exponent)
	// printed by the 'e', 'E', 'f', 'g', 'G', 'x', and 'X' formats.
	// For 'e', 'E', 'f', 'x', and 'X', it is the number of digits after the decimal point.
	// For 'g' and 'G' it is the maximum number of significant digits (trailing
	// zeros are removed).
	// The special precision -1 uses the smallest number of digits
	// necessary such that ParseFloat will return f exactly.
	func FormatFloat(f float64, fmt byte, prec, bitSize int) string {
	return strconv.FormatFloat(f, fmt, prec, bitSize)
	}

	// FormatUint returns the string representation of i in the given base,
	// for 2 <= base <= 36. The result uses the lower-case letters 'a' to 'z'
	// for digit values >= 10.
	func FormatUint(i uint64, base int) string {
	return strconv.FormatUint(i, base)
	}

	// FormatInt returns the string representation of i in the given base,
	// for 2 <= base <= 36. The result uses the lower-case letters 'a' to 'z'
	// for digit values >= 10.
	func FormatInt(i int64, base int) string {
	return strconv.FormatInt(i, base)
	}

	// Quote returns a double-quoted Go string literal representing s. The
	// returned string uses Go escape sequences (\t, \n, \xFF, \u0100) for
	// control characters and non-printable characters as defined by
	// IsPrint.
	func Quote(s string) string {
	return strconv.Quote(s)
	}

	// QuoteToASCII returns a double-quoted Go string literal representing s.
	// The returned string uses Go escape sequences (\t, \n, \xFF, \u0100) for
	// non-ASCII characters and non-printable characters as defined by IsPrint.
	func QuoteToASCII(s string) string {
	return strconv.QuoteToASCII(s)
	}

	// QuoteToGraphic returns a double-quoted Go string literal representing s.
	// The returned string leaves Unicode graphic characters, as defined by
	// IsGraphic, unchanged and uses Go escape sequences (\t, \n, \xFF, \u0100)
	// for non-graphic characters.
	func QuoteToGraphic(s string) string {
	return strconv.QuoteToGraphic(s)
	}

	// QuoteRune returns a single-quoted Go character literal representing the
	// rune. The returned string uses Go escape sequences (\t, \n, \xFF, \u0100)
	// for control characters and non-printable characters as defined by IsPrint.
	func QuoteRune(r rune) string {
	return strconv.QuoteRune(r)
	}

	// QuoteRuneToASCII returns a single-quoted Go character literal representing
	// the rune. The returned string uses Go escape sequences (\t, \n, \xFF,
	// \u0100) for non-ASCII characters and non-printable characters as defined
	// by IsPrint.
	func QuoteRuneToASCII(r rune) string {
	return strconv.QuoteRuneToASCII(r)
	}

	// QuoteRuneToGraphic returns a single-quoted Go character literal representing
	// the rune. If the rune is not a Unicode graphic character,
	// as defined by IsGraphic, the returned string will use a Go escape sequence
	// (\t, \n, \xFF, \u0100).
	func QuoteRuneToGraphic(r rune) string {
	return strconv.QuoteRuneToGraphic(r)
	}

	// IsPrint reports whether the rune is defined as printable by Go, with
	// the same definition as unicode.IsPrint: letters, numbers, punctuation,
	// symbols and ASCII space.
	func IsPrint(r rune) bool {
	return strconv.IsPrint(r)
	}

	// IsGraphic reports whether the rune is defined as a Graphic by Unicode. Such
	// characters include letters, marks, numbers, punctuation, symbols, and
	// spaces, from categories L, M, N, P, S, and Zs.
	func IsGraphic(r rune) bool {
	return strconv.IsGraphic(r)
	}