src/cmd/internal/gc/mparith1.go - go - Git at Google

 // Copyright 2009 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 gc

 import (
 	"cmd/internal/obj"
 	"fmt"
 	"math"
 	"math/big"
 )

 /// uses arithmetic

 func mpcmpfixflt(a *Mpfix, b *Mpflt) int {
 	var c Mpflt

 	buf := _Bconv(a, 0)
 	mpatoflt(&c, buf)
 	return mpcmpfltflt(&c, b)
 }

 func mpcmpfltfix(a *Mpflt, b *Mpfix) int {
 	var c Mpflt

 	buf := _Bconv(b, 0)
 	mpatoflt(&c, buf)
 	return mpcmpfltflt(a, &c)
 }

 func Mpcmpfixfix(a, b *Mpint) int {
 	return a.Val.Cmp(&b.Val)
 }

 func mpcmpfixc(b *Mpint, c int64) int {
 	return b.Val.Cmp(big.NewInt(c))
 }

 func mpcmpfltflt(a *Mpflt, b *Mpflt) int {
 	var c Mpflt

 	mpmovefltflt(&c, a)
 	mpsubfltflt(&c, b)
 	return mptestflt(&c)
 }

 func mpcmpfltc(b *Mpflt, c float64) int {
 	var a Mpflt

 	Mpmovecflt(&a, c)
 	return mpcmpfltflt(b, &a)
 }

 func mpsubfixfix(a, b *Mpint) {
 	a.Val.Sub(&a.Val, &b.Val)
 }

 func _mpsubfixfix(a *Mpfix, b *Mpfix) {
 	_mpnegfix(a)
 	_mpaddfixfix(a, b, 0)
 	_mpnegfix(a)
 }

 func mpsubfltflt(a *Mpflt, b *Mpflt) {
 	mpnegflt(a)
 	mpaddfltflt(a, b)
 	mpnegflt(a)
 }

 func mpaddcfix(a *Mpfix, c int64) {
 	var b Mpfix

 	_Mpmovecfix(&b, c)
 	_mpaddfixfix(a, &b, 0)
 }

 func mpaddcflt(a *Mpflt, c float64) {
 	var b Mpflt

 	Mpmovecflt(&b, c)
 	mpaddfltflt(a, &b)
 }

 func mpmulcfix(a *Mpfix, c int64) {
 	var b Mpfix

 	_Mpmovecfix(&b, c)
 	_mpmulfixfix(a, &b)
 }

 func mpmulcflt(a *Mpflt, c float64) {
 	var b Mpflt

 	Mpmovecflt(&b, c)
 	mpmulfltflt(a, &b)
 }

 func mpdivfixfix(a, b *Mpint) {
 	a.Val.Quo(&a.Val, &b.Val)
 }

 func _mpdivfixfix(a *Mpfix, b *Mpfix) {
 	var q Mpfix
 	var r Mpfix

 	mpdivmodfixfix(&q, &r, a, b)
 	_mpmovefixfix(a, &q)
 }

 func mpmodfixfix(a, b *Mpint) {
 	a.Val.Rem(&a.Val, &b.Val)
 }

 func _mpmodfixfix(a *Mpfix, b *Mpfix) {
 	var q Mpfix
 	var r Mpfix

 	mpdivmodfixfix(&q, &r, a, b)
 	_mpmovefixfix(a, &r)
 }

 func mpcomfix(a *Mpfix) {
 	var b Mpfix

 	_Mpmovecfix(&b, 1)
 	_mpnegfix(a)
 	_mpsubfixfix(a, &b)
 }

 // *a = Mpfix(*b)
 func mpmoveintfix(a *Mpfix, b *Mpint) {
 	if b.Ovf {
 		_Mpmovecfix(a, 0)
 		a.Ovf = 1
 		return
 	}

 	var bb big.Int
 	bb.Abs(&b.Val)
 	i := 0
 	for ; i < Mpprec && bb.Sign() != 0; i++ {
 		// depends on (unspecified) behavior of Int.Uint64
 		a.A[i] = int(bb.Uint64() & Mpmask)
 		bb.Rsh(&bb, Mpscale)
 	}

 	if bb.Sign() != 0 {
 		// MPint overflows
 		_Mpmovecfix(a, 0)
 		a.Ovf = 1
 		return
 	}

 	for ; i < Mpprec; i++ {
 		a.A[i] = 0
 	}

 	a.Neg = 0
 	if b.Val.Sign() < 0 {
 		a.Neg = 1
 	}
 	a.Ovf = 0

 	// leave for debugging
 	// println("mpmoveintfix:", b.Val.String(), "->", _Bconv(a, 0))
 }

 // *a = big.Int(*b)
 func mpmovefixint(a *Mpint, b *Mpfix) {
 	if b.Ovf != 0 {
 		mpsetovf(a)
 		return
 	}

 	i := Mpprec - 1
 	for ; i >= 0 && b.A[i] == 0; i-- {
 	}

 	a.Val.SetUint64(0)
 	var x big.Int
 	for ; i >= 0; i-- {
 		a.Val.Lsh(&a.Val, Mpscale)
 		a.Val.Or(&a.Val, x.SetUint64(uint64(b.A[i]&Mpmask)))
 	}

 	if b.Neg != 0 {
 		a.Val.Neg(&a.Val)
 	}
 	a.Ovf = false

 	// leave for debugging
 	// println("mpmovefixint:", _Bconv(b, 0), "->", a.Val.String())
 }

 func Mpmovefixflt(a *Mpflt, b *Mpint) {
 	mpmoveintfix(&a.Val, b) // a.Val = *b
 	a.Exp = 0
 	mpnorm(a)
 }

 func _Mpmovefixflt(a *Mpflt, b *Mpfix) {
 	a.Val = *b
 	a.Exp = 0
 	mpnorm(a)
 }

 // convert (truncate) b to a.
 // return -1 (but still convert) if b was non-integer.
 func mpexactfltfix(a *Mpint, b *Mpflt) int {
 	mpmovefixint(a, &b.Val) // *a = b.Val
 	Mpshiftfix(a, int(b.Exp))
 	if b.Exp < 0 {
 		var f Mpflt
 		mpmoveintfix(&f.Val, a) // f.Val = *a
 		f.Exp = 0
 		mpnorm(&f)
 		if mpcmpfltflt(b, &f) != 0 {
 			return -1
 		}
 	}

 	return 0
 }

 func mpmovefltfix(a *Mpint, b *Mpflt) int {
 	if mpexactfltfix(a, b) == 0 {
 		return 0
 	}

 	// try rounding down a little
 	f := *b

 	f.Val.A[0] = 0
 	if mpexactfltfix(a, &f) == 0 {
 		return 0
 	}

 	// try rounding up a little
 	for i := 1; i < Mpprec; i++ {
 		f.Val.A[i]++
 		if f.Val.A[i] != Mpbase {
 			break
 		}
 		f.Val.A[i] = 0
 	}

 	mpnorm(&f)
 	if mpexactfltfix(a, &f) == 0 {
 		return 0
 	}

 	return -1
 }

 func mpmovefixfix(a, b *Mpint) {
 	a.Val.Set(&b.Val)
 }

 func _mpmovefixfix(a *Mpfix, b *Mpfix) {
 	*a = *b
 }

 func mpmovefltflt(a *Mpflt, b *Mpflt) {
 	*a = *b
 }

 var tab = []float64{1e0, 1e1, 1e2, 1e3, 1e4, 1e5, 1e6, 1e7}

 func mppow10flt(a *Mpflt, p int) {
 	if p < 0 {
 		panic("abort")
 	}
 	if p < len(tab) {
 		Mpmovecflt(a, tab[p])
 		return
 	}

 	mppow10flt(a, p>>1)
 	mpmulfltflt(a, a)
 	if p&1 != 0 {
 		mpmulcflt(a, 10)
 	}
 }

 func mphextofix(a *Mpfix, s string) {
 	for s != "" && s[0] == '0' {
 		s = s[1:]
 	}

 	// overflow
 	if 4*len(s) > Mpscale*Mpprec {
 		a.Ovf = 1
 		return
 	}

 	end := len(s) - 1
 	var c int8
 	var d int
 	var bit int
 	for hexdigitp := end; hexdigitp >= 0; hexdigitp-- {
 		c = int8(s[hexdigitp])
 		if c >= '0' && c <= '9' {
 			d = int(c) - '0'
 		} else if c >= 'A' && c <= 'F' {
 			d = int(c) - 'A' + 10
 		} else {
 			d = int(c) - 'a' + 10
 		}

 		bit = 4 * (end - hexdigitp)
 		for d > 0 {
 			if d&1 != 0 {
 				a.A[bit/Mpscale] |= int(1) << uint(bit%Mpscale)
 			}
 			bit++
 			d = d >> 1
 		}
 	}
 }

 //
 // floating point input
 // required syntax is [+-]d*[.]d*[e[+-]d*] or [+-]0xH*[e[+-]d*]
 //
 func mpatoflt(a *Mpflt, as string) {
 	for as[0] == ' ' || as[0] == '\t' {
 		as = as[1:]
 	}

 	/* determine base */
 	s := as

 	base := -1
 	for base == -1 {
 		if s == "" {
 			base = 10
 			break
 		}
 		c := s[0]
 		s = s[1:]
 		switch c {
 		case '-', '+':
 			break

 		case '0':
 			if s != "" && s[0] == 'x' {
 				base = 16
 			} else {
 				base = 10
 			}

 		default:
 			base = 10
 		}
 	}

 	s = as
 	dp := 0 /* digits after decimal point */
 	f := 0  /* sign */
 	ex := 0 /* exponent */
 	eb := 0 /* binary point */

 	Mpmovecflt(a, 0.0)
 	var ef int
 	var c int
 	if base == 16 {
 		start := ""
 		var c int
 		for {
 			c, _ = intstarstringplusplus(s)
 			if c == '-' {
 				f = 1
 				s = s[1:]
 			} else if c == '+' {
 				s = s[1:]
 			} else if c == '0' && s[1] == 'x' {
 				s = s[2:]
 				start = s
 			} else if (c >= '0' && c <= '9') || (c >= 'a' && c <= 'f') || (c >= 'A' && c <= 'F') {
 				s = s[1:]
 			} else {
 				break
 			}
 		}

 		if start == "" {
 			Yyerror("malformed hex constant: %s", as)
 			goto bad
 		}

 		mphextofix(&a.Val, start[:len(start)-len(s)])
 		if a.Val.Ovf != 0 {
 			Yyerror("constant too large: %s", as)
 			goto bad
 		}

 		a.Exp = 0
 		mpnorm(a)
 	}

 	for {
 		c, s = intstarstringplusplus(s)
 		switch c {
 		default:
 			Yyerror("malformed constant: %s (at %c)", as, c)
 			goto bad

 		case '-':
 			f = 1
 			fallthrough

 		case ' ', '\t', '+':
 			continue

 		case '.':
 			if base == 16 {
 				Yyerror("decimal point in hex constant: %s", as)
 				goto bad
 			}

 			dp = 1
 			continue

 		case '1',
 			'2',
 			'3',
 			'4',
 			'5',
 			'6',
 			'7',
 			'8',
 			'9',
 			'0':
 			mpmulcflt(a, 10)
 			mpaddcflt(a, float64(c)-'0')
 			if dp != 0 {
 				dp++
 			}
 			continue

 		case 'P', 'p':
 			eb = 1
 			fallthrough

 		case 'E', 'e':
 			ex = 0
 			ef = 0
 			for {
 				c, s = intstarstringplusplus(s)
 				if c == '+' || c == ' ' || c == '\t' {
 					continue
 				}
 				if c == '-' {
 					ef = 1
 					continue
 				}

 				if c >= '0' && c <= '9' {
 					ex = ex*10 + (c - '0')
 					if ex > 1e8 {
 						Yyerror("constant exponent out of range: %s", as)
 						errorexit()
 					}

 					continue
 				}

 				break
 			}

 			if ef != 0 {
 				ex = -ex
 			}
 			fallthrough

 		case 0:
 			break
 		}

 		break
 	}

 	if eb != 0 {
 		if dp != 0 {
 			Yyerror("decimal point and binary point in constant: %s", as)
 			goto bad
 		}

 		mpsetexp(a, int(a.Exp)+ex)
 		goto out
 	}

 	if dp != 0 {
 		dp--
 	}
 	if mpcmpfltc(a, 0.0) != 0 {
 		if ex >= dp {
 			var b Mpflt
 			mppow10flt(&b, ex-dp)
 			mpmulfltflt(a, &b)
 		} else {
 			// 4 approximates least_upper_bound(log2(10)).
 			if dp-ex >= 1<<(32-3) || int(int16(4*(dp-ex))) != 4*(dp-ex) {
 				Mpmovecflt(a, 0.0)
 			} else {
 				var b Mpflt
 				mppow10flt(&b, dp-ex)
 				mpdivfltflt(a, &b)
 			}
 		}
 	}

 out:
 	if f != 0 {
 		mpnegflt(a)
 	}
 	return

 bad:
 	Mpmovecflt(a, 0.0)
 }

 func mpatofix(a *Mpint, as string) {
 	_, ok := a.Val.SetString(as, 0)
 	if !ok {
 		// required syntax is [+-][0[x]]d*
 		// At the moment we lose precise error cause;
 		// the old code distinguished between:
 		// - malformed hex constant
 		// - malformed octal constant
 		// - malformed decimal constant
 		// TODO(gri) use different conversion function
 		Yyerror("malformed integer constant: %s", as)
 		a.Val.SetUint64(0)
 		return
 	}
 	if mptestovf(a, 0) {
 		Yyerror("constant too large: %s", as)
 	}
 }

 func Bconv(xval *Mpint, flag int) string {
 	if flag&obj.FmtSharp != 0 {
 		return fmt.Sprintf("%#x", &xval.Val)
 	}
 	return xval.Val.String()
 }

 func _Bconv(xval *Mpfix, flag int) string {
 	var q Mpfix

 	_mpmovefixfix(&q, xval)
 	f := 0
 	if mptestfix(&q) < 0 {
 		f = 1
 		_mpnegfix(&q)
 	}

 	var buf [500]byte
 	p := len(buf)
 	var r Mpfix
 	if flag&obj.FmtSharp != 0 /*untyped*/ {
 		// Hexadecimal
 		var sixteen Mpfix
 		_Mpmovecfix(&sixteen, 16)

 		var digit int
 		for {
 			mpdivmodfixfix(&q, &r, &q, &sixteen)
 			digit = int(_Mpgetfix(&r))
 			if digit < 10 {
 				p--
 				buf[p] = byte(digit + '0')
 			} else {
 				p--
 				buf[p] = byte(digit - 10 + 'A')
 			}
 			if mptestfix(&q) <= 0 {
 				break
 			}
 		}

 		p--
 		buf[p] = 'x'
 		p--
 		buf[p] = '0'
 	} else {
 		// Decimal
 		var ten Mpfix
 		_Mpmovecfix(&ten, 10)

 		for {
 			mpdivmodfixfix(&q, &r, &q, &ten)
 			p--
 			buf[p] = byte(_Mpgetfix(&r) + '0')
 			if mptestfix(&q) <= 0 {
 				break
 			}
 		}
 	}

 	if f != 0 {
 		p--
 		buf[p] = '-'
 	}

 	return string(buf[p:])
 }

 func Fconv(fvp *Mpflt, flag int) string {
 	if flag&obj.FmtSharp != 0 /*untyped*/ {
 		// alternate form - decimal for error messages.
 		// for well in range, convert to double and use print's %g
 		exp := int(fvp.Exp) + sigfig(fvp)*Mpscale

 		var fp string
 		if -900 < exp && exp < 900 {
 			d := mpgetflt(fvp)
 			if d >= 0 && (flag&obj.FmtSign != 0 /*untyped*/) {
 				fp += "+"
 			}
 			fp += fmt.Sprintf("%.6g", d)
 			return fp
 		}

 		// very out of range. compute decimal approximation by hand.
 		// decimal exponent
 		dexp := float64(fvp.Exp) * 0.301029995663981195 // log_10(2)
 		exp = int(dexp)

 		// decimal mantissa
 		fv := *fvp

 		fv.Val.Neg = 0
 		fv.Exp = 0
 		d := mpgetflt(&fv)
 		d *= math.Pow(10, dexp-float64(exp))
 		for d >= 9.99995 {
 			d /= 10
 			exp++
 		}

 		if fvp.Val.Neg != 0 {
 			fp += "-"
 		} else if flag&obj.FmtSign != 0 /*untyped*/ {
 			fp += "+"
 		}
 		fp += fmt.Sprintf("%.5fe+%d", d, exp)
 		return fp
 	}

 	var fv Mpflt
 	var buf string
 	if sigfig(fvp) == 0 {
 		buf = "0p+0"
 		goto out
 	}

 	fv = *fvp

 	for fv.Val.A[0] == 0 {
 		_Mpshiftfix(&fv.Val, -Mpscale)
 		fv.Exp += Mpscale
 	}

 	for fv.Val.A[0]&1 == 0 {
 		_Mpshiftfix(&fv.Val, -1)
 		fv.Exp += 1
 	}

 	if fv.Exp >= 0 {
 		buf = fmt.Sprintf("%vp+%d", _Bconv(&fv.Val, obj.FmtSharp), fv.Exp)
 		goto out
 	}

 	buf = fmt.Sprintf("%vp-%d", _Bconv(&fv.Val, obj.FmtSharp), -fv.Exp)

 out:
 	var fp string
 	fp += buf
 	return fp
 }
	// Copyright 2009 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 gc

	import (
	"cmd/internal/obj"
	"fmt"
	"math"
	"math/big"
	)

	/// uses arithmetic

	func mpcmpfixflt(a Mpfix, b Mpflt) int {
	var c Mpflt

	buf := _Bconv(a, 0)
	mpatoflt(&c, buf)
	return mpcmpfltflt(&c, b)
	}

	func mpcmpfltfix(a Mpflt, b Mpfix) int {
	var c Mpflt

	buf := _Bconv(b, 0)
	mpatoflt(&c, buf)
	return mpcmpfltflt(a, &c)
	}

	func Mpcmpfixfix(a, b *Mpint) int {
	return a.Val.Cmp(&b.Val)
	}

	func mpcmpfixc(b *Mpint, c int64) int {
	return b.Val.Cmp(big.NewInt(c))
	}

	func mpcmpfltflt(a Mpflt, b Mpflt) int {
	var c Mpflt

	mpmovefltflt(&c, a)
	mpsubfltflt(&c, b)
	return mptestflt(&c)
	}

	func mpcmpfltc(b *Mpflt, c float64) int {
	var a Mpflt

	Mpmovecflt(&a, c)
	return mpcmpfltflt(b, &a)
	}

	func mpsubfixfix(a, b *Mpint) {
	a.Val.Sub(&a.Val, &b.Val)
	}

	func _mpsubfixfix(a Mpfix, b Mpfix) {
	_mpnegfix(a)
	_mpaddfixfix(a, b, 0)
	_mpnegfix(a)
	}

	func mpsubfltflt(a Mpflt, b Mpflt) {
	mpnegflt(a)
	mpaddfltflt(a, b)
	mpnegflt(a)
	}

	func mpaddcfix(a *Mpfix, c int64) {
	var b Mpfix

	_Mpmovecfix(&b, c)
	_mpaddfixfix(a, &b, 0)
	}

	func mpaddcflt(a *Mpflt, c float64) {
	var b Mpflt

	Mpmovecflt(&b, c)
	mpaddfltflt(a, &b)
	}

	func mpmulcfix(a *Mpfix, c int64) {
	var b Mpfix

	_Mpmovecfix(&b, c)
	_mpmulfixfix(a, &b)
	}

	func mpmulcflt(a *Mpflt, c float64) {
	var b Mpflt

	Mpmovecflt(&b, c)
	mpmulfltflt(a, &b)
	}

	func mpdivfixfix(a, b *Mpint) {
	a.Val.Quo(&a.Val, &b.Val)
	}

	func _mpdivfixfix(a Mpfix, b Mpfix) {
	var q Mpfix
	var r Mpfix

	mpdivmodfixfix(&q, &r, a, b)
	_mpmovefixfix(a, &q)
	}

	func mpmodfixfix(a, b *Mpint) {
	a.Val.Rem(&a.Val, &b.Val)
	}

	func _mpmodfixfix(a Mpfix, b Mpfix) {
	var q Mpfix
	var r Mpfix

	mpdivmodfixfix(&q, &r, a, b)
	_mpmovefixfix(a, &r)
	}

	func mpcomfix(a *Mpfix) {
	var b Mpfix

	_Mpmovecfix(&b, 1)
	_mpnegfix(a)
	_mpsubfixfix(a, &b)
	}

	// a = Mpfix(b)
	func mpmoveintfix(a Mpfix, b Mpint) {
	if b.Ovf {
	_Mpmovecfix(a, 0)
	a.Ovf = 1
	return
	}

	var bb big.Int
	bb.Abs(&b.Val)
	i := 0
	for ; i < Mpprec && bb.Sign() != 0; i++ {
	// depends on (unspecified) behavior of Int.Uint64
	a.A[i] = int(bb.Uint64() & Mpmask)
	bb.Rsh(&bb, Mpscale)
	}

	if bb.Sign() != 0 {
	// MPint overflows
	_Mpmovecfix(a, 0)
	a.Ovf = 1
	return
	}

	for ; i < Mpprec; i++ {
	a.A[i] = 0
	}

	a.Neg = 0
	if b.Val.Sign() < 0 {
	a.Neg = 1
	}
	a.Ovf = 0

	// leave for debugging
	// println("mpmoveintfix:", b.Val.String(), "->", _Bconv(a, 0))
	}

	// a = big.Int(b)
	func mpmovefixint(a Mpint, b Mpfix) {
	if b.Ovf != 0 {
	mpsetovf(a)
	return
	}

	i := Mpprec - 1
	for ; i >= 0 && b.A[i] == 0; i-- {
	}

	a.Val.SetUint64(0)
	var x big.Int
	for ; i >= 0; i-- {
	a.Val.Lsh(&a.Val, Mpscale)
	a.Val.Or(&a.Val, x.SetUint64(uint64(b.A[i]&Mpmask)))
	}

	if b.Neg != 0 {
	a.Val.Neg(&a.Val)
	}
	a.Ovf = false

	// leave for debugging
	// println("mpmovefixint:", _Bconv(b, 0), "->", a.Val.String())
	}

	func Mpmovefixflt(a Mpflt, b Mpint) {
	mpmoveintfix(&a.Val, b) // a.Val = *b
	a.Exp = 0
	mpnorm(a)
	}

	func _Mpmovefixflt(a Mpflt, b Mpfix) {
	a.Val = *b
	a.Exp = 0
	mpnorm(a)
	}

	// convert (truncate) b to a.
	// return -1 (but still convert) if b was non-integer.
	func mpexactfltfix(a Mpint, b Mpflt) int {
	mpmovefixint(a, &b.Val) // *a = b.Val
	Mpshiftfix(a, int(b.Exp))
	if b.Exp < 0 {
	var f Mpflt
	mpmoveintfix(&f.Val, a) // f.Val = *a
	f.Exp = 0
	mpnorm(&f)
	if mpcmpfltflt(b, &f) != 0 {
	return -1
	}
	}

	return 0
	}

	func mpmovefltfix(a Mpint, b Mpflt) int {
	if mpexactfltfix(a, b) == 0 {
	return 0
	}

	// try rounding down a little
	f := *b

	f.Val.A[0] = 0
	if mpexactfltfix(a, &f) == 0 {
	return 0
	}

	// try rounding up a little
	for i := 1; i < Mpprec; i++ {
	f.Val.A[i]++
	if f.Val.A[i] != Mpbase {
	break
	}
	f.Val.A[i] = 0
	}

	mpnorm(&f)
	if mpexactfltfix(a, &f) == 0 {
	return 0
	}

	return -1
	}

	func mpmovefixfix(a, b *Mpint) {
	a.Val.Set(&b.Val)
	}

	func _mpmovefixfix(a Mpfix, b Mpfix) {
	a = b
	}

	func mpmovefltflt(a Mpflt, b Mpflt) {
	a = b
	}

	var tab = []float64{1e0, 1e1, 1e2, 1e3, 1e4, 1e5, 1e6, 1e7}

	func mppow10flt(a *Mpflt, p int) {
	if p < 0 {
	panic("abort")
	}
	if p < len(tab) {
	Mpmovecflt(a, tab[p])
	return
	}

	mppow10flt(a, p>>1)
	mpmulfltflt(a, a)
	if p&1 != 0 {
	mpmulcflt(a, 10)
	}
	}

	func mphextofix(a *Mpfix, s string) {
	for s != "" && s[0] == '0' {
	s = s[1:]
	}

	// overflow
	if 4len(s) > MpscaleMpprec {
	a.Ovf = 1
	return
	}

	end := len(s) - 1
	var c int8
	var d int
	var bit int
	for hexdigitp := end; hexdigitp >= 0; hexdigitp-- {
	c = int8(s[hexdigitp])
	if c >= '0' && c <= '9' {
	d = int(c) - '0'
	} else if c >= 'A' && c <= 'F' {
	d = int(c) - 'A' + 10
	} else {
	d = int(c) - 'a' + 10
	}

	bit = 4 * (end - hexdigitp)
	for d > 0 {
	if d&1 != 0 {
	a.A[bit/Mpscale] \|= int(1) << uint(bit%Mpscale)
	}
	bit++
	d = d >> 1
	}
	}
	}

	//
	// floating point input
	// required syntax is [+-]d[.]d[e[+-]d] or [+-]0xH[e[+-]d*]
	//
	func mpatoflt(a *Mpflt, as string) {
	for as[0] == ' ' \|\| as[0] == '\t' {
	as = as[1:]
	}

	/* determine base */
	s := as

	base := -1
	for base == -1 {
	if s == "" {
	base = 10
	break
	}
	c := s[0]
	s = s[1:]
	switch c {
	case '-', '+':
	break

	case '0':
	if s != "" && s[0] == 'x' {
	base = 16
	} else {
	base = 10
	}

	default:
	base = 10
	}
	}

	s = as
	dp := 0 /* digits after decimal point */
	f := 0 /* sign */
	ex := 0 /* exponent */
	eb := 0 /* binary point */

	Mpmovecflt(a, 0.0)
	var ef int
	var c int
	if base == 16 {
	start := ""
	var c int
	for {
	c, _ = intstarstringplusplus(s)
	if c == '-' {
	f = 1
	s = s[1:]
	} else if c == '+' {
	s = s[1:]
	} else if c == '0' && s[1] == 'x' {
	s = s[2:]
	start = s
	} else if (c >= '0' && c <= '9') \|\| (c >= 'a' && c <= 'f') \|\| (c >= 'A' && c <= 'F') {
	s = s[1:]
	} else {
	break
	}
	}

	if start == "" {
	Yyerror("malformed hex constant: %s", as)
	goto bad
	}

	mphextofix(&a.Val, start[:len(start)-len(s)])
	if a.Val.Ovf != 0 {
	Yyerror("constant too large: %s", as)
	goto bad
	}

	a.Exp = 0
	mpnorm(a)
	}

	for {
	c, s = intstarstringplusplus(s)
	switch c {
	default:
	Yyerror("malformed constant: %s (at %c)", as, c)
	goto bad

	case '-':
	f = 1
	fallthrough

	case ' ', '\t', '+':
	continue

	case '.':
	if base == 16 {
	Yyerror("decimal point in hex constant: %s", as)
	goto bad
	}

	dp = 1
	continue

	case '1',
	'2',
	'3',
	'4',
	'5',
	'6',
	'7',
	'8',
	'9',
	'0':
	mpmulcflt(a, 10)
	mpaddcflt(a, float64(c)-'0')
	if dp != 0 {
	dp++
	}
	continue

	case 'P', 'p':
	eb = 1
	fallthrough

	case 'E', 'e':
	ex = 0
	ef = 0
	for {
	c, s = intstarstringplusplus(s)
	if c == '+' \|\| c == ' ' \|\| c == '\t' {
	continue
	}
	if c == '-' {
	ef = 1
	continue
	}

	if c >= '0' && c <= '9' {
	ex = ex*10 + (c - '0')
	if ex > 1e8 {
	Yyerror("constant exponent out of range: %s", as)
	errorexit()
	}

	continue
	}

	break
	}

	if ef != 0 {
	ex = -ex
	}
	fallthrough

	case 0:
	break
	}

	break
	}

	if eb != 0 {
	if dp != 0 {
	Yyerror("decimal point and binary point in constant: %s", as)
	goto bad
	}

	mpsetexp(a, int(a.Exp)+ex)
	goto out
	}

	if dp != 0 {
	dp--
	}
	if mpcmpfltc(a, 0.0) != 0 {
	if ex >= dp {
	var b Mpflt
	mppow10flt(&b, ex-dp)
	mpmulfltflt(a, &b)
	} else {
	// 4 approximates least_upper_bound(log2(10)).
	if dp-ex >= 1<<(32-3) \|\| int(int16(4(dp-ex))) != 4(dp-ex) {
	Mpmovecflt(a, 0.0)
	} else {
	var b Mpflt
	mppow10flt(&b, dp-ex)
	mpdivfltflt(a, &b)
	}
	}
	}

	out:
	if f != 0 {
	mpnegflt(a)
	}
	return

	bad:
	Mpmovecflt(a, 0.0)
	}

	func mpatofix(a *Mpint, as string) {
	_, ok := a.Val.SetString(as, 0)
	if !ok {
	// required syntax is [+-][0[x]]d*
	// At the moment we lose precise error cause;
	// the old code distinguished between:
	// - malformed hex constant
	// - malformed octal constant
	// - malformed decimal constant
	// TODO(gri) use different conversion function
	Yyerror("malformed integer constant: %s", as)
	a.Val.SetUint64(0)
	return
	}
	if mptestovf(a, 0) {
	Yyerror("constant too large: %s", as)
	}
	}

	func Bconv(xval *Mpint, flag int) string {
	if flag&obj.FmtSharp != 0 {
	return fmt.Sprintf("%#x", &xval.Val)
	}
	return xval.Val.String()
	}

	func _Bconv(xval *Mpfix, flag int) string {
	var q Mpfix

	_mpmovefixfix(&q, xval)
	f := 0
	if mptestfix(&q) < 0 {
	f = 1
	_mpnegfix(&q)
	}

	var buf [500]byte
	p := len(buf)
	var r Mpfix
	if flag&obj.FmtSharp != 0 /untyped/ {
	// Hexadecimal
	var sixteen Mpfix
	_Mpmovecfix(&sixteen, 16)

	var digit int
	for {
	mpdivmodfixfix(&q, &r, &q, &sixteen)
	digit = int(_Mpgetfix(&r))
	if digit < 10 {
	p--
	buf[p] = byte(digit + '0')
	} else {
	p--
	buf[p] = byte(digit - 10 + 'A')
	}
	if mptestfix(&q) <= 0 {
	break
	}
	}

	p--
	buf[p] = 'x'
	p--
	buf[p] = '0'
	} else {
	// Decimal
	var ten Mpfix
	_Mpmovecfix(&ten, 10)

	for {
	mpdivmodfixfix(&q, &r, &q, &ten)
	p--
	buf[p] = byte(_Mpgetfix(&r) + '0')
	if mptestfix(&q) <= 0 {
	break
	}
	}
	}

	if f != 0 {
	p--
	buf[p] = '-'
	}

	return string(buf[p:])
	}

	func Fconv(fvp *Mpflt, flag int) string {
	if flag&obj.FmtSharp != 0 /untyped/ {
	// alternate form - decimal for error messages.
	// for well in range, convert to double and use print's %g
	exp := int(fvp.Exp) + sigfig(fvp)*Mpscale

	var fp string
	if -900 < exp && exp < 900 {
	d := mpgetflt(fvp)
	if d >= 0 && (flag&obj.FmtSign != 0 /untyped/) {
	fp += "+"
	}
	fp += fmt.Sprintf("%.6g", d)
	return fp
	}

	// very out of range. compute decimal approximation by hand.
	// decimal exponent
	dexp := float64(fvp.Exp) * 0.301029995663981195 // log_10(2)
	exp = int(dexp)

	// decimal mantissa
	fv := *fvp

	fv.Val.Neg = 0
	fv.Exp = 0
	d := mpgetflt(&fv)
	d *= math.Pow(10, dexp-float64(exp))
	for d >= 9.99995 {
	d /= 10
	exp++
	}

	if fvp.Val.Neg != 0 {
	fp += "-"
	} else if flag&obj.FmtSign != 0 /untyped/ {
	fp += "+"
	}
	fp += fmt.Sprintf("%.5fe+%d", d, exp)
	return fp
	}

	var fv Mpflt
	var buf string
	if sigfig(fvp) == 0 {
	buf = "0p+0"
	goto out
	}

	fv = *fvp

	for fv.Val.A[0] == 0 {
	_Mpshiftfix(&fv.Val, -Mpscale)
	fv.Exp += Mpscale
	}

	for fv.Val.A[0]&1 == 0 {
	_Mpshiftfix(&fv.Val, -1)
	fv.Exp += 1
	}

	if fv.Exp >= 0 {
	buf = fmt.Sprintf("%vp+%d", _Bconv(&fv.Val, obj.FmtSharp), fv.Exp)
	goto out
	}

	buf = fmt.Sprintf("%vp-%d", _Bconv(&fv.Val, obj.FmtSharp), -fv.Exp)

	out:
	var fp string
	fp += buf
	return fp
	}