// be done precisely in binary representation.
//
// In contrast to strconv/decimal.go, only right shift is implemented in
// decimal format - left shift can be done precisely in binary format.

package big

// A decimal represents an unsigned floating-point number in decimal representation.
// The value of a non-zero decimal d is d.mant * 10**d.exp with 0.1 <= d.mant < 1,

// Multiprecision decimal numbers.
// For floating-point formatting only; not general purpose.
// Only operations are assign and (binary) left/right shift.
// Can do binary floating point in multiprecision decimal precisely
// because 2 divides 10; cannot do decimal floating point
// in multiprecision binary precisely.

package strconv

type decimal struct {
	d     [800]byte // digits, big-endian representation

		case 'a':
			ret = &Name{Name: "auto"}
		case 'c':
			ret = &Name{Name: "decltype(auto)"}

		case 'f':
			ret = &BuiltinType{Name: "decimal32"}
		case 'd':
			ret = &BuiltinType{Name: "decimal64"}
		case 'e':
			ret = &BuiltinType{Name: "decimal128"}
		case 'h':
			ret = &BuiltinType{Name: "half"}
		case 'u':
			ret = &BuiltinType{Name: "char8_t"}
		case 's':

}

func main() {
	// 0-octals
	assert(0_1 == 01)
	assert(012 == 012)
	assert(0_1_2 == 012)
	assert(0_1_2i == complex(0, 12)) // decimal digits despite leading 0 for backward-compatibility
	assert(00089i == complex(0, 89)) // decimal digits despite leading 0 for backward-compatibility

	// decimals
	assert(1_000_000 == 1000000)
	assert(1_000i == complex(0, 1000))

	// hexadecimals
	assert(0x_1 == 0x1)
	assert(0x1_2 == 0x12)

package p

const (
	// 0-octals
	_	= 0
	_	= 0123
	_	= 0123456

	_	= 0_123
	_	= 0123_456

	// decimals
	_	= 1
	_	= 1234
	_	= 1234567

	_	= 1_234
	_	= 1_234_567

	// hexadecimals
	_	= 0x0
	_	= 0x1234
	_	= 0xcafef00d

	_	= 0x0
	_	= 0x1234
	_	= 0xCAFEf00d

	_	= 0x_0
	_	= 0x_1234
	_	= 0x_CAFE_f00d

	// octals
	_	= 0o0
	_	= 0o1234
	_	= 0o01234567

	_	= 0o0

package p

const (
	// 0-octals
	_ = 0
	_ = 0123
	_ = 0123456

	_ = 0_123
	_ = 0123_456

	// decimals
	_ = 1
	_ = 1234
	_ = 1234567

	_ = 1_234
	_ = 1_234_567

	// hexadecimals
	_ = 0x0
	_ = 0x1234
	_ = 0xcafef00d

	_ = 0x0
	_ = 0x1234
	_ = 0xCAFEf00d

	_ = 0x_0
	_ = 0x_1234
	_ = 0x_CAFE_f00d

	// octals
	_ = 0o0
	_ = 0o1234
	_ = 0o01234567

	_ = 0o0

	format := q.Format
	switch format {
	case DecimalExponent, DecimalSI:
	case BinarySI:
		if q.CmpInt64(-1024) > 0 && q.CmpInt64(1024) < 0 {
			// This avoids rounding and hopefully confusion, too.
			format = DecimalSI
		} else {
			var exact bool
			if rounded, exact = q.AsScale(0); !exact {
				// Don't lose precision-- show as DecimalSI
				format = DecimalSI
			}
		}
	default:
		format = DecimalExponent
	}

package p

const (
	// 0-octals
	_ = 0
	_ = 0123
	_ = 0123456

	_ = 0_123
	_ = 0123_456

	// decimals
	_ = 1
	_ = 1234
	_ = 1234567

	_ = 1_234
	_ = 1_234_567

	// hexadecimals
	_ = 0x0
	_ = 0x1234
	_ = 0xcafef00d

	_ = 0X0
	_ = 0X1234
	_ = 0XCAFEf00d

	_ = 0X_0
	_ = 0X_1234
	_ = 0X_CAFE_f00d

	// octals
	_ = 0o0
	_ = 0o1234
	_ = 0o01234567

	_ = 0O0

		{intQuantity(800, -3, DecimalSI), intQuantity(79, -2, DecimalSI), 1},

		{intQuantity(mostPositive, 0, DecimalSI), intQuantity(1, -1, DecimalSI), 1},
		{intQuantity(mostPositive, 1, DecimalSI), intQuantity(1, 0, DecimalSI), 1},
		{intQuantity(mostPositive, 1, DecimalSI), intQuantity(1, 1, DecimalSI), 1},
		{intQuantity(mostPositive, 1, DecimalSI), intQuantity(0, 1, DecimalSI), 1},

//
// 	(Note that <suffix> may be empty, from the "" case in <decimalSI>.)
//
// <digit>           ::= 0 | 1 | ... | 9
// <digits>          ::= <digit> | <digit><digits>
// <number>          ::= <digits> | <digits>.<digits> | <digits>. | .<digits>
// <sign>            ::= "+" | "-"
// <signedNumber>    ::= <number> | <sign><number>
// <suffix>          ::= <binarySI> | <decimalExponent> | <decimalSI>
// <binarySI>        ::= Ki | Mi | Gi | Ti | Pi | Ei
//