diff options
Diffstat (limited to 'vendor/modernc.org/libc/printf.go')
| -rw-r--r-- | vendor/modernc.org/libc/printf.go | 684 |
1 files changed, 684 insertions, 0 deletions
diff --git a/vendor/modernc.org/libc/printf.go b/vendor/modernc.org/libc/printf.go new file mode 100644 index 0000000..2821f8e --- /dev/null +++ b/vendor/modernc.org/libc/printf.go @@ -0,0 +1,684 @@ +// Copyright 2020 The Libc 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:build !(linux && (amd64 || arm64 || loong64)) + +package libc // import "modernc.org/libc" + +import ( + "bytes" + "fmt" + "runtime" + "strconv" + "strings" + "unsafe" +) + +const ( + modNone = iota + modHH + modH + modL + modLL + modLD + modQ + modCapitalL + modJ + modZ + modCapitalZ + modT + mod32 + mod64 +) + +// Format of the format string +// +// The format string is a character string, beginning and ending in its initial +// shift state, if any. The format string is composed of zero or more +// directives: ordinary characters (not %), which are copied unchanged to +// the output stream; and conversion specifications, each of which results in +// fetching zero or more subsequent arguments. +func printf(format, args uintptr) []byte { + // format0 := format + // args0 := args + buf := bytes.NewBuffer(nil) + for { + switch c := *(*byte)(unsafe.Pointer(format)); c { + case '%': + format = printfConversion(buf, format, &args) + case 0: + // if dmesgs { + // dmesg("%v: %q, %#x -> %q", origin(1), GoString(format0), args0, buf.Bytes()) + // } + return buf.Bytes() + default: + format++ + buf.WriteByte(c) + } + } +} + +// Each conversion specification is introduced by the character %, and ends +// with a conversion specifier. In between there may be (in this order) zero +// or more flags, an optional minimum field width, an optional precision and +// an optional length modifier. +func printfConversion(buf *bytes.Buffer, format uintptr, args *uintptr) uintptr { + format++ // '%' + spec := "%" + + // Flags characters + // + // The character % is followed by zero or more of the following flags: +flags: + for { + switch c := *(*byte)(unsafe.Pointer(format)); c { + case '#': + // The value should be converted to an "alternate form". For o conversions, + // the first character of the output string is made zero (by prefixing a 0 if + // it was not zero already). For x and X conversions, a nonzero result has + // the string "0x" (or "0X" for X conversions) prepended to it. For a, A, e, + // E, f, F, g, and G conversions, the result will always contain a decimal + // point, even if no digits follow it (normally, a decimal point appears in the + // results of those conversions only if a digit follows). For g and G + // conversions, trailing zeros are not removed from the result as they would + // otherwise be. For other conversions, the result is undefined. + format++ + spec += "#" + case '0': + // The value should be zero padded. For d, i, o, u, x, X, a, A, e, E, f, F, + // g, and G conversions, the converted value is padded on the left with zeros + // rather than blanks. If the 0 and - flags both appear, the 0 flag is + // ignored. If a precision is given with a numeric conversion (d, i, o, u, x, + // and X), the 0 flag is ignored. For other conversions, the behav‐ ior is + // undefined. + format++ + spec += "0" + case '-': + // The converted value is to be left adjusted on the field boundary. (The + // default is right justification.) The converted value is padded on the right + // with blanks, rather than on the left with blanks or zeros. A - overrides a + // 0 if both are given. + format++ + spec += "-" + case ' ': + // A blank should be left before a positive number (or empty string) produced + // by a signed conversion. + format++ + spec += " " + case '+': + // A sign (+ or -) should always be placed before a number produced by a signed + // conversion. By default, a sign is used only for negative numbers. A + + // overrides a space if both are used. + format++ + spec += "+" + default: + break flags + } + } + format, width, hasWidth := parseFieldWidth(format, args) + if hasWidth { + spec += strconv.Itoa(width) + } + format, prec, hasPrecision := parsePrecision(format, args) + format, mod := parseLengthModifier(format) + + var str string + +more: + // Conversion specifiers + // + // A character that specifies the type of conversion to be applied. The + // conversion specifiers and their meanings are: + switch c := *(*byte)(unsafe.Pointer(format)); c { + case 'd', 'i': + // The int argument is converted to signed decimal notation. The precision, + // if any, gives the minimum number of digits that must appear; if the + // converted value requires fewer digits, it is padded on the left with zeros. + // The default precision is 1. When 0 is printed with an explicit precision 0, + // the output is empty. + format++ + var arg int64 + if isWindows && mod == modL { + mod = modNone + } + switch mod { + case modL, modLL, mod64, modJ: + arg = VaInt64(args) + case modH: + arg = int64(int16(VaInt32(args))) + case modHH: + arg = int64(int8(VaInt32(args))) + case mod32, modNone: + arg = int64(VaInt32(args)) + case modT: + arg = int64(VaInt64(args)) + default: + panic(todo("", mod)) + } + + if arg == 0 && hasPrecision && prec == 0 { + break + } + + if hasPrecision { + panic(todo("", prec)) + } + + f := spec + "d" + str = fmt.Sprintf(f, arg) + case 'u': + // The unsigned int argument is converted to unsigned decimal notation. The + // precision, if any, gives the minimum number of digits that must appear; if + // the converted value requires fewer digits, it is padded on the left with + // zeros. The default precision is 1. When 0 is printed with an explicit + // precision 0, the output is empty. + format++ + var arg uint64 + if isWindows && mod == modL { + mod = modNone + } + switch mod { + case modNone: + arg = uint64(VaUint32(args)) + case modL, modLL, mod64: + arg = VaUint64(args) + case modH: + arg = uint64(uint16(VaInt32(args))) + case modHH: + arg = uint64(uint8(VaInt32(args))) + case mod32: + arg = uint64(VaInt32(args)) + case modZ: + arg = uint64(VaInt64(args)) + default: + panic(todo("", mod)) + } + + if arg == 0 && hasPrecision && prec == 0 { + break + } + + if hasPrecision { + panic(todo("", prec)) + } + + f := spec + "d" + str = fmt.Sprintf(f, arg) + case 'o': + // The unsigned int argument is converted to unsigned octal notation. The + // precision, if any, gives the minimum number of digits that must appear; if + // the converted value requires fewer digits, it is padded on the left with + // zeros. The default precision is 1. When 0 is printed with an explicit + // precision 0, the output is empty. + format++ + var arg uint64 + if isWindows && mod == modL { + mod = modNone + } + switch mod { + case modNone: + arg = uint64(VaUint32(args)) + case modL, modLL, mod64: + arg = VaUint64(args) + case modH: + arg = uint64(uint16(VaInt32(args))) + case modHH: + arg = uint64(uint8(VaInt32(args))) + case mod32: + arg = uint64(VaInt32(args)) + default: + panic(todo("", mod)) + } + + if arg == 0 && hasPrecision && prec == 0 { + break + } + + if hasPrecision { + panic(todo("", prec)) + } + + f := spec + "o" + str = fmt.Sprintf(f, arg) + case 'b': + // Base 2. + format++ + var arg uint64 + if isWindows && mod == modL { + mod = modNone + } + switch mod { + case modNone: + arg = uint64(VaUint32(args)) + case modL, modLL, mod64: + arg = VaUint64(args) + case modH: + arg = uint64(uint16(VaInt32(args))) + case modHH: + arg = uint64(uint8(VaInt32(args))) + case mod32: + arg = uint64(VaInt32(args)) + default: + panic(todo("", mod)) + } + + if arg == 0 && hasPrecision && prec == 0 { + break + } + + if hasPrecision { + panic(todo("", prec)) + } + + f := spec + "b" + str = fmt.Sprintf(f, arg) + case 'I': + if !isWindows { + panic(todo("%#U", c)) + } + + format++ + switch c = *(*byte)(unsafe.Pointer(format)); c { + case 'x', 'X': + // https://docs.microsoft.com/en-us/windows/win32/api/winuser/nf-winuser-wsprintfa + // + // Ix, IX + // + // 64-bit unsigned hexadecimal integer in lowercase or uppercase on 64-bit + // platforms, 32-bit unsigned hexadecimal integer in lowercase or uppercase on + // 32-bit platforms. + if unsafe.Sizeof(int(0)) == 4 { + mod = mod32 + } + case '3': + // https://en.wikipedia.org/wiki/Printf_format_string#Length_field + // + // I32 For integer types, causes printf to expect a 32-bit (double word) integer argument. + format++ + switch c = *(*byte)(unsafe.Pointer(format)); c { + case '2': + format++ + mod = mod32 + goto more + default: + panic(todo("%#U", c)) + } + case '6': + // https://en.wikipedia.org/wiki/Printf_format_string#Length_field + // + // I64 For integer types, causes printf to expect a 64-bit (quad word) integer argument. + format++ + switch c = *(*byte)(unsafe.Pointer(format)); c { + case '4': + format++ + mod = mod64 + goto more + default: + panic(todo("%#U", c)) + } + default: + panic(todo("%#U", c)) + } + fallthrough + case 'X': + fallthrough + case 'x': + // The unsigned int argument is converted to unsigned hexadecimal notation. + // The letters abcdef are used for x conversions; the letters ABCDEF are used + // for X conversions. The precision, if any, gives the minimum number of + // digits that must appear; if the converted value requires fewer digits, it is + // padded on the left with zeros. The default precision is 1. When 0 is + // printed with an explicit precision 0, the output is empty. + format++ + var arg uint64 + if isWindows && mod == modL { + mod = modNone + } + switch mod { + case modNone: + arg = uint64(VaUint32(args)) + case modL, modLL, mod64: + arg = VaUint64(args) + case modH: + arg = uint64(uint16(VaInt32(args))) + case modHH: + arg = uint64(uint8(VaInt32(args))) + case mod32: + arg = uint64(VaInt32(args)) + case modZ: + arg = uint64(VaInt64(args)) + default: + panic(todo("", mod)) + } + + if arg == 0 && hasPrecision && prec == 0 { + break + } + + if strings.Contains(spec, "#") && arg == 0 { + spec = strings.ReplaceAll(spec, "#", "") + } + var f string + switch { + case hasPrecision: + f = fmt.Sprintf("%s.%d%c", spec, prec, c) + default: + f = spec + string(c) + } + str = fmt.Sprintf(f, arg) + case 'e', 'E': + // The double argument is rounded and converted in the style [-]d.ddde±dd where + // there is one digit before the decimal-point character and the number of + // digits after it is equal to the precision; if the precision is missing, it + // is taken as 6; if the precision is zero, no decimal-point character appears. + // An E conversion uses the letter E (rather than e) to intro‐ duce the + // exponent. The exponent always contains at least two digits; if the value is + // zero, the exponent is 00. + format++ + arg := VaFloat64(args) + if !hasPrecision { + prec = 6 + } + f := fmt.Sprintf("%s.%d%c", spec, prec, c) + str = fmt.Sprintf(f, arg) + case 'f', 'F': + // The double argument is rounded and converted to decimal notation in the + // style [-]ddd.ddd, where the number of digits after the decimal-point + // character is equal to the precision specification. If the precision + // is missing, it is taken as 6; if the precision is explicitly zero, no + // decimal-point character appears. If a decimal point appears, at least one + // digit appears before it. + format++ + arg := VaFloat64(args) + if !hasPrecision { + prec = 6 + } + f := fmt.Sprintf("%s.%d%c", spec, prec, c) + str = fixNanInf(fmt.Sprintf(f, arg)) + case 'G': + fallthrough + case 'g': + // The double argument is converted in style f or e (or F or E for G + // conversions). The precision specifies the number of significant digits. If + // the precision is missing, 6 digits are given; if the precision is zero, it + // is treated as 1. Style e is used if the exponent from its conversion is + // less than -4 or greater than or equal to the precision. Trailing zeros are + // removed from the fractional part of the result; a decimal point appears only + // if it is followed by at least one digit. + format++ + arg := VaFloat64(args) + if !hasPrecision { + prec = 6 + } + if prec == 0 { + prec = 1 + } + + f := fmt.Sprintf("%s.%d%c", spec, prec, c) + str = fixNanInf(fmt.Sprintf(f, arg)) + case 's': + // If no l modifier is present: the const char * argument is expected to be a + // pointer to an array of character type (pointer to a string). Characters + // from the array are written up to (but not including) a terminating null byte + // ('\0'); if a precision is specified, no more than the number specified are + // written. If a precision is given, no null byte need be present; if + // the precision is not specified, or is greater than the size of the array, + // the array must contain a terminating null byte. + // + // If an l modifier is present: the const wchar_t * argument is expected + // to be a pointer to an array of wide characters. Wide characters from the + // array are converted to multibyte characters (each by a call to the + // wcrtomb(3) function, with a conversion state starting in the initial state + // before the first wide character), up to and including a terminating null + // wide character. The resulting multibyte characters are written up to + // (but not including) the terminating null byte. If a precision is specified, + // no more bytes than the number specified are written, but no partial + // multibyte characters are written. Note that the precision determines the + // number of bytes written, not the number of wide characters or screen + // positions. The array must contain a terminating null wide character, + // unless a precision is given and it is so small that the number of bytes + // written exceeds it before the end of the array is reached. + format++ + arg := VaUintptr(args) + switch mod { + case modNone: + var f string + switch { + case hasPrecision: + f = fmt.Sprintf("%s.%ds", spec, prec) + str = fmt.Sprintf(f, GoString(arg)) + default: + f = spec + "s" + str = fmt.Sprintf(f, GoString(arg)) + } + default: + panic(todo("")) + } + case 'p': + // The void * pointer argument is printed in hexadecimal (as if by %#x or + // %#lx). + format++ + switch runtime.GOOS { + case "windows": + switch runtime.GOARCH { + case "386", "arm": + fmt.Fprintf(buf, "%08X", VaUintptr(args)) + default: + fmt.Fprintf(buf, "%016X", VaUintptr(args)) + } + default: + fmt.Fprintf(buf, "%#0x", VaUintptr(args)) + } + case 'c': + // If no l modifier is present, the int argument is converted to an unsigned + // char, and the resulting character is written. If an l modifier is present, + // the wint_t (wide character) ar‐ gument is converted to a multibyte sequence + // by a call to the wcrtomb(3) function, with a conversion state starting in + // the initial state, and the resulting multibyte string is writ‐ ten. + format++ + switch mod { + case modNone: + arg := VaInt32(args) + buf.WriteByte(byte(arg)) + default: + panic(todo("")) + } + case '%': + // A '%' is written. No argument is converted. The complete conversion + // specification is '%%'. + format++ + buf.WriteByte('%') + default: + panic(todo("%#U", c)) + } + + buf.WriteString(str) + return format +} + +// Field width +// +// An optional decimal digit string (with nonzero first digit) specifying a +// minimum field width. If the converted value has fewer characters than the +// field width, it will be padded with spa‐ ces on the left (or right, if the +// left-adjustment flag has been given). Instead of a decimal digit string one +// may write "*" or "*m$" (for some decimal integer m) to specify that the +// field width is given in the next argument, or in the m-th argument, +// respectively, which must be of type int. A negative field width is taken as +// a '-' flag followed by a positive field width. In no case does a +// nonexistent or small field width cause truncation of a field; if the result +// of a conversion is wider than the field width, the field is expanded to +// contain the conversion result. +func parseFieldWidth(format uintptr, args *uintptr) (_ uintptr, n int, ok bool) { + first := true + for { + var digit int + switch c := *(*byte)(unsafe.Pointer(format)); { + case first && c == '0': + return format, n, ok + case first && c == '*': + format++ + switch c := *(*byte)(unsafe.Pointer(format)); { + case c >= '0' && c <= '9': + panic(todo("")) + default: + return format, int(VaInt32(args)), true + } + case c >= '0' && c <= '9': + format++ + ok = true + first = false + digit = int(c) - '0' + default: + return format, n, ok + } + + n0 := n + n = 10*n + digit + if n < n0 { + panic(todo("")) + } + } +} + +// Precision +// +// An optional precision, in the form of a period ('.') followed by an +// optional decimal digit string. Instead of a decimal digit string one may +// write "*" or "*m$" (for some decimal integer m) to specify that the +// precision is given in the next argument, or in the m-th argument, +// respectively, which must be of type int. If the precision is given as just +// '.', the precision is taken to be zero. A negative precision is taken +// as if the precision were omitted. This gives the minimum number of digits +// to appear for d, i, o, u, x, and X conversions, the number of digits to +// appear after the radix character for a, A, e, E, f, and F conversions, the +// maximum number of significant digits for g and G conversions, or the maximum +// number of characters to be printed from a string for s and S conversions. +func parsePrecision(format uintptr, args *uintptr) (_ uintptr, n int, ok bool) { + for { + switch c := *(*byte)(unsafe.Pointer(format)); c { + case '.': + format++ + first := true + for { + switch c := *(*byte)(unsafe.Pointer(format)); { + case first && c == '*': + format++ + n = int(VaInt32(args)) + return format, n, true + case c >= '0' && c <= '9': + format++ + first = false + n0 := n + n = 10*n + (int(c) - '0') + if n < n0 { + panic(todo("")) + } + default: + return format, n, true + } + } + default: + return format, 0, false + } + } +} + +// Length modifier +// +// Here, "integer conversion" stands for d, i, o, u, x, or X conversion. +// +// hh A following integer conversion corresponds to a signed char or +// unsigned char argument, or a following n conversion corresponds to a pointer +// to a signed char argument. +// +// h A following integer conversion corresponds to a short int or unsigned +// short int argument, or a following n conversion corresponds to a pointer to +// a short int argument. +// +// l (ell) A following integer conversion corresponds to a long int or +// unsigned long int argument, or a following n conversion corresponds to a +// pointer to a long int argument, or a fol‐ lowing c conversion corresponds to +// a wint_t argument, or a following s conversion corresponds to a pointer to +// wchar_t argument. +// +// ll (ell-ell). A following integer conversion corresponds to a long long +// int or unsigned long long int argument, or a following n conversion +// corresponds to a pointer to a long long int argument. +// +// q A synonym for ll. This is a nonstandard extension, derived from BSD; +// avoid its use in new code. +// +// L A following a, A, e, E, f, F, g, or G conversion corresponds to a +// long double argument. (C99 allows %LF, but SUSv2 does not.) +// +// j A following integer conversion corresponds to an intmax_t or +// uintmax_t argument, or a following n conversion corresponds to a pointer to +// an intmax_t argument. +// +// z A following integer conversion corresponds to a size_t or ssize_t +// argument, or a following n conversion corresponds to a pointer to a size_t +// argument. +// +// Z A nonstandard synonym for z that predates the appearance of z. Do +// not use in new code. +// +// t A following integer conversion corresponds to a ptrdiff_t argument, +// or a following n conversion corresponds to a pointer to a ptrdiff_t +// argument. + +func parseLengthModifier(format uintptr) (_ uintptr, n int) { + switch c := *(*byte)(unsafe.Pointer(format)); c { + case 'h': + format++ + n = modH + switch c := *(*byte)(unsafe.Pointer(format)); c { + case 'h': + format++ + n = modHH + } + return format, n + case 'l': + format++ + n = modL + switch c := *(*byte)(unsafe.Pointer(format)); c { + case 'l': + format++ + n = modLL + } + return format, n + case 'q': + panic(todo("")) + case 'L': + format++ + n = modLD + return format, n + case 'j': + format++ + n = modJ + return format, n + case 'z': + format++ + return format, modZ + case 'Z': + format++ + return format, modCapitalZ + case 't': + format++ + return format, modT + default: + return format, 0 + } +} + +func fixNanInf(s string) string { + switch s { + case "NaN": + return "nan" + case "+Inf", "-Inf": + return "inf" + default: + return s + } +} |
