| // 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) |
| } |