go/test/convinline.go

// runoutput
//go:build !wasm

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

package main

import (
	"bytes"
	"fmt"
	"math"
	"math/bits"
	"os"
	"strconv"
	"strings"
)

var types = []string{
	"int",
	"int8",
	"int16",
	"int32",
	"int64",
	"uint",
	"uint8",
	"uint16",
	"uint32",
	"uint64",
	"uintptr",
	"float32",
	"float64",
}

func main() {
	var prog bytes.Buffer
	fmt.Fprintf(&prog, "package main\n\n")
	fmt.Fprintf(&prog, "import ( \"fmt\"; \"math\" )\n")
	for _, t1 := range types {
		for _, t2 := range types {
			fmt.Fprintf(&prog, "func %[1]s_to_%[2]s(x %[1]s) %[2]s { return %[2]s(x) }\n", t1, t2)
		}
	}

	var outputs []string
	var exprs []string

	fmt.Fprintf(&prog, "var (\n")
	for _, t1 := range types {
		var inputs []string
		switch t1 {
		case "int64", "int":
			if t1 == "int64" || bits.UintSize == 64 {
				inputs = append(inputs, "-0x8000_0000_0000_0000", "-0x7fff_ffff_ffff_ffff", "-0x12_3456_7890", "0x12_3456_7890", "0x7fff_ffff_ffff_ffff")
			}
			fallthrough
		case "int32":
			inputs = append(inputs, "-0x8000_0000", "-0x7fff_ffff", "-0x12_3456", "0x12_3456", "0x7fff_ffff")
			fallthrough
		case "int16":
			inputs = append(inputs, "-0x8000", "-0x7fff", "-0x1234", "0x1234", "0x7fff")
			fallthrough
		case "int8":
			inputs = append(inputs, "-0x80", "-0x7f", "-0x12", "-1", "0", "1", "0x12", "0x7f")

		case "uint64", "uint", "uintptr":
			if t1 == "uint64" || bits.UintSize == 64 {
				inputs = append(inputs, "0x12_3456_7890", "0x7fff_ffff_ffff_ffff", "0x8000_0000_0000_0000", "0xffff_ffff_ffff_ffff")
			}
			fallthrough
		case "uint32":
			inputs = append(inputs, "0x12_3456", "0x7fff_ffff", "0x8000_0000", "0xffff_ffff")
			fallthrough
		case "uint16":
			inputs = append(inputs, "0x1234", "0x7fff", "0x8000", "0xffff")
			fallthrough
		case "uint8":
			inputs = append(inputs, "0", "1", "0x12", "0x7f", "0x80", "0xff")

		case "float64":
			inputs = append(inputs,
				"-1.79769313486231570814527423731704356798070e+308",
				"-1e300",
				"-1e100",
				"-1e40",
				"-3.5e38",
				"3.5e38",
				"1e40",
				"1e100",
				"1e300",
				"1.79769313486231570814527423731704356798070e+308")
			fallthrough
		case "float32":
			inputs = append(inputs,
				"-3.40282346638528859811704183484516925440e+38",
				"-1e38",
				"-1.5",
				"-1.401298464324817070923729583289916131280e-45",
				"0",
				"1.401298464324817070923729583289916131280e-45",
				"1.5",
				"1e38",
				"3.40282346638528859811704183484516925440e+38")
		}
		for _, t2 := range types {
			for _, x := range inputs {
				code := fmt.Sprintf("%s_to_%s(%s)", t1, t2, x)
				fmt.Fprintf(&prog, "\tv%d = %s\n", len(outputs), code)
				exprs = append(exprs, code)
				outputs = append(outputs, convert(x, t1, t2))
			}
		}
	}
	fmt.Fprintf(&prog, ")\n\n")
	fmt.Fprintf(&prog, "func main() {\n\tok := true\n")
	for i, out := range outputs {
		fmt.Fprintf(&prog, "\tif v%d != %s { fmt.Println(%q, \"=\", v%d, \"want\", %s); ok = false }\n", i, out, exprs[i], i, out)
	}
	fmt.Fprintf(&prog, "\tif !ok { println(\"FAIL\") }\n")
	fmt.Fprintf(&prog, "}\n")

	os.Stdout.Write(prog.Bytes())
}

func convert(x, t1, t2 string) string {
	if strings.HasPrefix(t1, "int") {
		v, err := strconv.ParseInt(x, 0, 64)
		if err != nil {
			println(x, t1, t2)
			panic(err)
		}
		return convert1(v, t2)
	}
	if strings.HasPrefix(t1, "uint") {
		v, err := strconv.ParseUint(x, 0, 64)
		if err != nil {
			println(x, t1, t2)
			panic(err)
		}
		return convert1(v, t2)
	}
	if strings.HasPrefix(t1, "float") {
		v, err := strconv.ParseFloat(x, 64)
		if err != nil {
			println(x, t1, t2)
			panic(err)
		}
		if t1 == "float32" {
			v = float64(float32(v))
		}
		return convert1(v, t2)
	}
	panic(t1)
}

func convert1[T int64 | uint64 | float64](v T, t2 string) string {
	switch t2 {
	case "int":
		return fmt.Sprintf("%s(%#x)", t2, int(v))
	case "int8":
		return fmt.Sprintf("%s(%#x)", t2, int8(v))
	case "int16":
		return fmt.Sprintf("%s(%#x)", t2, int16(v))
	case "int32":
		return fmt.Sprintf("%s(%#x)", t2, int32(v))
	case "int64":
		return fmt.Sprintf("%s(%#x)", t2, int64(v))
	case "uint":
		return fmt.Sprintf("%s(%#x)", t2, uint(v))
	case "uint8":
		return fmt.Sprintf("%s(%#x)", t2, uint8(v))
	case "uint16":
		return fmt.Sprintf("%s(%#x)", t2, uint16(v))
	case "uint32":
		return fmt.Sprintf("%s(%#x)", t2, uint32(v))
	case "uint64":
		return fmt.Sprintf("%s(%#x)", t2, uint64(v))
	case "uintptr":
		return fmt.Sprintf("%s(%#x)", t2, uintptr(v))
	case "float32":
		v := float32(v)
		if math.IsInf(float64(v), -1) {
			return "float32(math.Inf(-1))"
		}
		if math.IsInf(float64(v), +1) {
			return "float32(math.Inf(+1))"
		}
		return fmt.Sprintf("%s(%v)", t2, float64(v))
	case "float64":
		return fmt.Sprintf("%s(%v)", t2, float64(v))
	}
	panic(t2)
}