gtsocial-umbx

printf.go (19580B)

---

 // 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.
 
 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)
 	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:
 			arg = VaInt64(args)
 		case modH:
 			arg = int64(int16(VaInt32(args)))
 		case modHH:
 			arg = int64(int8(VaInt32(args)))
 		case mod32, modNone:
 			arg = int64(VaInt32(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))
 		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 '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))
 		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) (_ 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 == '*':
 			panic(todo(""))
 		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':
 		panic(todo(""))
 	case 'z':
 		panic(todo(""))
 	case 'Z':
 		panic(todo(""))
 	case 't':
 		panic(todo(""))
 	default:
 		return format, 0
 	}
 }
 
 func fixNanInf(s string) string {
 	switch s {
 	case "NaN":
 		return "nan"
 	case "+Inf", "-Inf":
 		return "inf"
 	default:
 		return s
 	}
 }