From: Rob Pike <r@golang.org>
Date: Sun, 6 Dec 2009 20:58:16 +0000 (-0800)
Subject: unexport Fmt. it's not needed outside this package any more
X-Git-Tag: weekly.2009-12-07~10
X-Git-Url: http://www.git.cypherpunks.su/?a=commitdiff_plain;h=353ef80f659a09bc38d616763867ca3bfc4ae07d;p=gostls13.git

unexport Fmt. it's not needed outside this package any more
cleans up godoc's output for package fmt substantially.

R=rsc
CC=golang-dev
https://golang.org/cl/165070
---

diff --git a/src/pkg/fmt/format.go b/src/pkg/fmt/format.go
index d09f3522f5..5d0fbc4636 100644
--- a/src/pkg/fmt/format.go
+++ b/src/pkg/fmt/format.go
@@ -11,7 +11,6 @@ import (
 
 const (
 	nByte	= 64;
-	nPows10	= 160;
 
 	ldigits	= "0123456789abcdef";
 	udigits	= "0123456789ABCDEF";
@@ -29,12 +28,9 @@ func init() {
 	}
 }
 
-/*
-	Fmt is the raw formatter used by Printf etc.  Not meant for normal use.
-	It prints into a bytes.Buffer that must be set up externally.
-	See print.go for a more palatable interface.
-*/
-type Fmt struct {
+// A fmt is the raw formatter used by Printf etc.
+// It prints into a bytes.Buffer that must be set up externally.
+type fmt struct {
 	intbuf		[nByte]byte;
 	buf		*bytes.Buffer;
 	wid		int;
@@ -49,7 +45,7 @@ type Fmt struct {
 	zero	bool;
 }
 
-func (f *Fmt) ClearFlags() {
+func (f *fmt) clearflags() {
 	f.wid = 0;
 	f.widPresent = false;
 	f.prec = 0;
@@ -61,35 +57,13 @@ func (f *Fmt) ClearFlags() {
 	f.zero = false;
 }
 
-func (f *Fmt) Init(buf *bytes.Buffer) {
+func (f *fmt) init(buf *bytes.Buffer) {
 	f.buf = buf;
-	f.ClearFlags();
-}
-
-func (f *Fmt) Reset()	{ f.ClearFlags() }
-
-// Wp sets the width and precision for formatting the next item.
-func (f *Fmt) Wp(w, p int) {
-	f.widPresent = true;
-	f.wid = w;
-	f.precPresent = true;
-	f.prec = p;
-}
-
-// P sets the precision for formatting the next item.
-func (f *Fmt) P(p int) {
-	f.precPresent = true;
-	f.prec = p;
-}
-
-// W sets the width for formatting the next item.
-func (f *Fmt) W(x int) {
-	f.widPresent = true;
-	f.wid = x;
+	f.clearflags();
 }
 
 // Compute left and right padding widths (only one will be non-zero).
-func (f *Fmt) computePadding(width int) (padding []byte, leftWidth, rightWidth int) {
+func (f *fmt) computePadding(width int) (padding []byte, leftWidth, rightWidth int) {
 	left := !f.minus;
 	w := f.wid;
 	if w < 0 {
@@ -112,7 +86,7 @@ func (f *Fmt) computePadding(width int) (padding []byte, leftWidth, rightWidth i
 }
 
 // Generate n bytes of padding.
-func (f *Fmt) writePadding(n int, padding []byte) {
+func (f *fmt) writePadding(n int, padding []byte) {
 	for n > 0 {
 		m := n;
 		if m > nByte {
@@ -124,7 +98,7 @@ func (f *Fmt) writePadding(n int, padding []byte) {
 }
 
 // Append b to f.buf, padded on left (w > 0) or right (w < 0 or f.minus)
-func (f *Fmt) padBytes(b []byte) {
+func (f *fmt) padBytes(b []byte) {
 	var padding []byte;
 	var left, right int;
 	if f.widPresent && f.wid != 0 {
@@ -140,7 +114,7 @@ func (f *Fmt) padBytes(b []byte) {
 }
 
 // append s to buf, padded on left (w > 0) or right (w < 0 or f.minus)
-func (f *Fmt) pad(s string) {
+func (f *fmt) pad(s string) {
 	var padding []byte;
 	var left, right int;
 	if f.widPresent && f.wid != 0 {
@@ -171,18 +145,18 @@ func putint(buf []byte, base, val uint64, digits string) int {
 	return i - 1;
 }
 
-// Fmt_boolean formats a boolean.
-func (f *Fmt) Fmt_boolean(v bool) {
+// fmt_boolean formats a boolean.
+func (f *fmt) fmt_boolean(v bool) {
 	if v {
 		f.pad("true")
 	} else {
 		f.pad("false")
 	}
-	f.ClearFlags();
+	f.clearflags();
 }
 
 // integer; interprets prec but not wid.
-func (f *Fmt) integer(a int64, base uint, is_signed bool, digits string) []byte {
+func (f *fmt) integer(a int64, base uint, is_signed bool, digits string) []byte {
 	var buf []byte = &f.intbuf;
 	negative := is_signed && a < 0;
 	if negative {
@@ -236,134 +210,134 @@ func (f *Fmt) integer(a int64, base uint, is_signed bool, digits string) []byte
 	return buf[i+1 : nByte];
 }
 
-// Fmt_d64 formats an int64 in decimal.
-func (f *Fmt) Fmt_d64(v int64) {
+// fmt_d64 formats an int64 in decimal.
+func (f *fmt) fmt_d64(v int64) {
 	f.padBytes(f.integer(v, 10, true, ldigits));
-	f.ClearFlags();
+	f.clearflags();
 }
 
-// Fmt_d32 formats an int32 in decimal.
-func (f *Fmt) Fmt_d32(v int32)	{ f.Fmt_d64(int64(v)) }
+// fmt_d32 formats an int32 in decimal.
+func (f *fmt) fmt_d32(v int32)	{ f.fmt_d64(int64(v)) }
 
-// Fmt_d formats an int in decimal.
-func (f *Fmt) Fmt_d(v int)	{ f.Fmt_d64(int64(v)) }
+// fmt_d formats an int in decimal.
+func (f *fmt) fmt_d(v int)	{ f.fmt_d64(int64(v)) }
 
-// Fmt_ud64 formats a uint64 in decimal.
-func (f *Fmt) Fmt_ud64(v uint64) *Fmt {
+// fmt_ud64 formats a uint64 in decimal.
+func (f *fmt) fmt_ud64(v uint64) *fmt {
 	f.padBytes(f.integer(int64(v), 10, false, ldigits));
-	f.ClearFlags();
+	f.clearflags();
 	return f;
 }
 
-// Fmt_ud32 formats a uint32 in decimal.
-func (f *Fmt) Fmt_ud32(v uint32)	{ f.Fmt_ud64(uint64(v)) }
+// fmt_ud32 formats a uint32 in decimal.
+func (f *fmt) fmt_ud32(v uint32)	{ f.fmt_ud64(uint64(v)) }
 
-// Fmt_ud formats a uint in decimal.
-func (f *Fmt) Fmt_ud(v uint)	{ f.Fmt_ud64(uint64(v)) }
+// fmt_ud formats a uint in decimal.
+func (f *fmt) fmt_ud(v uint)	{ f.fmt_ud64(uint64(v)) }
 
-// Fmt_x64 formats an int64 in hexadecimal.
-func (f *Fmt) Fmt_x64(v int64) {
+// fmt_x64 formats an int64 in hexadecimal.
+func (f *fmt) fmt_x64(v int64) {
 	f.padBytes(f.integer(v, 16, true, ldigits));
-	f.ClearFlags();
+	f.clearflags();
 }
 
-// Fmt_x32 formats an int32 in hexadecimal.
-func (f *Fmt) Fmt_x32(v int32)	{ f.Fmt_x64(int64(v)) }
+// fmt_x32 formats an int32 in hexadecimal.
+func (f *fmt) fmt_x32(v int32)	{ f.fmt_x64(int64(v)) }
 
-// Fmt_x formats an int in hexadecimal.
-func (f *Fmt) Fmt_x(v int)	{ f.Fmt_x64(int64(v)) }
+// fmt_x formats an int in hexadecimal.
+func (f *fmt) fmt_x(v int)	{ f.fmt_x64(int64(v)) }
 
-// Fmt_ux64 formats a uint64 in hexadecimal.
-func (f *Fmt) Fmt_ux64(v uint64) {
+// fmt_ux64 formats a uint64 in hexadecimal.
+func (f *fmt) fmt_ux64(v uint64) {
 	f.padBytes(f.integer(int64(v), 16, false, ldigits));
-	f.ClearFlags();
+	f.clearflags();
 }
 
-// Fmt_ux32 formats a uint32 in hexadecimal.
-func (f *Fmt) Fmt_ux32(v uint32)	{ f.Fmt_ux64(uint64(v)) }
+// fmt_ux32 formats a uint32 in hexadecimal.
+func (f *fmt) fmt_ux32(v uint32)	{ f.fmt_ux64(uint64(v)) }
 
-// Fmt_ux formats a uint in hexadecimal.
-func (f *Fmt) Fmt_ux(v uint)	{ f.Fmt_ux64(uint64(v)) }
+// fmt_ux formats a uint in hexadecimal.
+func (f *fmt) fmt_ux(v uint)	{ f.fmt_ux64(uint64(v)) }
 
-// Fmt_X64 formats an int64 in upper case hexadecimal.
-func (f *Fmt) Fmt_X64(v int64) {
+// fmt_X64 formats an int64 in upper case hexadecimal.
+func (f *fmt) fmt_X64(v int64) {
 	f.padBytes(f.integer(v, 16, true, udigits));
-	f.ClearFlags();
+	f.clearflags();
 }
 
-// Fmt_X32 formats an int32 in upper case hexadecimal.
-func (f *Fmt) Fmt_X32(v int32)	{ f.Fmt_X64(int64(v)) }
+// fmt_X32 formats an int32 in upper case hexadecimal.
+func (f *fmt) fmt_X32(v int32)	{ f.fmt_X64(int64(v)) }
 
-// Fmt_X formats an int in upper case hexadecimal.
-func (f *Fmt) Fmt_X(v int)	{ f.Fmt_X64(int64(v)) }
+// fmt_X formats an int in upper case hexadecimal.
+func (f *fmt) fmt_X(v int)	{ f.fmt_X64(int64(v)) }
 
-// Fmt_uX64 formats a uint64 in upper case hexadecimal.
-func (f *Fmt) Fmt_uX64(v uint64) {
+// fmt_uX64 formats a uint64 in upper case hexadecimal.
+func (f *fmt) fmt_uX64(v uint64) {
 	f.padBytes(f.integer(int64(v), 16, false, udigits));
-	f.ClearFlags();
+	f.clearflags();
 }
 
-// Fmt_uX32 formats a uint32 in upper case hexadecimal.
-func (f *Fmt) Fmt_uX32(v uint32)	{ f.Fmt_uX64(uint64(v)) }
+// fmt_uX32 formats a uint32 in upper case hexadecimal.
+func (f *fmt) fmt_uX32(v uint32)	{ f.fmt_uX64(uint64(v)) }
 
-// Fmt_uX formats a uint in upper case hexadecimal.
-func (f *Fmt) Fmt_uX(v uint)	{ f.Fmt_uX64(uint64(v)) }
+// fmt_uX formats a uint in upper case hexadecimal.
+func (f *fmt) fmt_uX(v uint)	{ f.fmt_uX64(uint64(v)) }
 
-// Fmt_o64 formats an int64 in octal.
-func (f *Fmt) Fmt_o64(v int64) {
+// fmt_o64 formats an int64 in octal.
+func (f *fmt) fmt_o64(v int64) {
 	f.padBytes(f.integer(v, 8, true, ldigits));
-	f.ClearFlags();
+	f.clearflags();
 }
 
-// Fmt_o32 formats an int32 in octal.
-func (f *Fmt) Fmt_o32(v int32)	{ f.Fmt_o64(int64(v)) }
+// fmt_o32 formats an int32 in octal.
+func (f *fmt) fmt_o32(v int32)	{ f.fmt_o64(int64(v)) }
 
-// Fmt_o formats an int in octal.
-func (f *Fmt) Fmt_o(v int)	{ f.Fmt_o64(int64(v)) }
+// fmt_o formats an int in octal.
+func (f *fmt) fmt_o(v int)	{ f.fmt_o64(int64(v)) }
 
-// Fmt_uo64 formats a uint64 in octal.
-func (f *Fmt) Fmt_uo64(v uint64) {
+// fmt_uo64 formats a uint64 in octal.
+func (f *fmt) fmt_uo64(v uint64) {
 	f.padBytes(f.integer(int64(v), 8, false, ldigits));
-	f.ClearFlags();
+	f.clearflags();
 }
 
-// Fmt_uo32 formats a uint32 in octal.
-func (f *Fmt) Fmt_uo32(v uint32)	{ f.Fmt_uo64(uint64(v)) }
+// fmt_uo32 formats a uint32 in octal.
+func (f *fmt) fmt_uo32(v uint32)	{ f.fmt_uo64(uint64(v)) }
 
-// Fmt_uo formats a uint in octal.
-func (f *Fmt) Fmt_uo(v uint)	{ f.Fmt_uo64(uint64(v)) }
+// fmt_uo formats a uint in octal.
+func (f *fmt) fmt_uo(v uint)	{ f.fmt_uo64(uint64(v)) }
 
-// Fmt_b64 formats a uint64 in binary.
-func (f *Fmt) Fmt_b64(v uint64) {
+// fmt_b64 formats a uint64 in binary.
+func (f *fmt) fmt_b64(v uint64) {
 	f.padBytes(f.integer(int64(v), 2, false, ldigits));
-	f.ClearFlags();
+	f.clearflags();
 }
 
-// Fmt_b32 formats a uint32 in binary.
-func (f *Fmt) Fmt_b32(v uint32)	{ f.Fmt_b64(uint64(v)) }
+// fmt_b32 formats a uint32 in binary.
+func (f *fmt) fmt_b32(v uint32)	{ f.fmt_b64(uint64(v)) }
 
-// Fmt_b formats a uint in binary.
-func (f *Fmt) Fmt_b(v uint)	{ f.Fmt_b64(uint64(v)) }
+// fmt_b formats a uint in binary.
+func (f *fmt) fmt_b(v uint)	{ f.fmt_b64(uint64(v)) }
 
-// Fmt_c formats a Unicode character.
-func (f *Fmt) Fmt_c(v int) {
+// fmt_c formats a Unicode character.
+func (f *fmt) fmt_c(v int) {
 	f.pad(string(v));
-	f.ClearFlags();
+	f.clearflags();
 }
 
-// Fmt_s formats a string.
-func (f *Fmt) Fmt_s(s string) {
+// fmt_s formats a string.
+func (f *fmt) fmt_s(s string) {
 	if f.precPresent {
 		if f.prec < len(s) {
 			s = s[0:f.prec]
 		}
 	}
 	f.pad(s);
-	f.ClearFlags();
+	f.clearflags();
 }
 
-// Fmt_sx formats a string as a hexadecimal encoding of its bytes.
-func (f *Fmt) Fmt_sx(s string) {
+// fmt_sx formats a string as a hexadecimal encoding of its bytes.
+func (f *fmt) fmt_sx(s string) {
 	t := "";
 	for i := 0; i < len(s); i++ {
 		if i > 0 && f.space {
@@ -374,11 +348,11 @@ func (f *Fmt) Fmt_sx(s string) {
 		t += string(ldigits[v&0xF]);
 	}
 	f.pad(t);
-	f.ClearFlags();
+	f.clearflags();
 }
 
-// Fmt_sX formats a string as an uppercase hexadecimal encoding of its bytes.
-func (f *Fmt) Fmt_sX(s string) {
+// fmt_sX formats a string as an uppercase hexadecimal encoding of its bytes.
+func (f *fmt) fmt_sX(s string) {
 	t := "";
 	for i := 0; i < len(s); i++ {
 		v := s[i];
@@ -386,11 +360,11 @@ func (f *Fmt) Fmt_sX(s string) {
 		t += string(udigits[v&0xF]);
 	}
 	f.pad(t);
-	f.ClearFlags();
+	f.clearflags();
 }
 
-// Fmt_q formats a string as a double-quoted, escaped Go string constant.
-func (f *Fmt) Fmt_q(s string) {
+// fmt_q formats a string as a double-quoted, escaped Go string constant.
+func (f *fmt) fmt_q(s string) {
 	var quoted string;
 	if f.sharp && strconv.CanBackquote(s) {
 		quoted = "`" + s + "`"
@@ -398,25 +372,25 @@ func (f *Fmt) Fmt_q(s string) {
 		quoted = strconv.Quote(s)
 	}
 	f.pad(quoted);
-	f.ClearFlags();
+	f.clearflags();
 }
 
 // floating-point
 
-func doPrec(f *Fmt, def int) int {
+func doPrec(f *fmt, def int) int {
 	if f.precPresent {
 		return f.prec
 	}
 	return def;
 }
 
-func fmtString(f *Fmt, s string) {
+func fmtString(f *fmt, s string) {
 	f.pad(s);
-	f.ClearFlags();
+	f.clearflags();
 }
 
 // Add a plus sign or space to the string if missing and required.
-func (f *Fmt) plusSpace(s string) {
+func (f *fmt) plusSpace(s string) {
 	if s[0] != '-' {
 		if f.plus {
 			s = "+" + s
@@ -427,75 +401,75 @@ func (f *Fmt) plusSpace(s string) {
 	fmtString(f, s);
 }
 
-// Fmt_e64 formats a float64 in the form -1.23e+12.
-func (f *Fmt) Fmt_e64(v float64)	{ f.plusSpace(strconv.Ftoa64(v, 'e', doPrec(f, 6))) }
+// fmt_e64 formats a float64 in the form -1.23e+12.
+func (f *fmt) fmt_e64(v float64)	{ f.plusSpace(strconv.Ftoa64(v, 'e', doPrec(f, 6))) }
 
-// Fmt_E64 formats a float64 in the form -1.23E+12.
-func (f *Fmt) Fmt_E64(v float64)	{ f.plusSpace(strconv.Ftoa64(v, 'E', doPrec(f, 6))) }
+// fmt_E64 formats a float64 in the form -1.23E+12.
+func (f *fmt) fmt_E64(v float64)	{ f.plusSpace(strconv.Ftoa64(v, 'E', doPrec(f, 6))) }
 
-// Fmt_f64 formats a float64 in the form -1.23.
-func (f *Fmt) Fmt_f64(v float64)	{ f.plusSpace(strconv.Ftoa64(v, 'f', doPrec(f, 6))) }
+// fmt_f64 formats a float64 in the form -1.23.
+func (f *fmt) fmt_f64(v float64)	{ f.plusSpace(strconv.Ftoa64(v, 'f', doPrec(f, 6))) }
 
-// Fmt_g64 formats a float64 in the 'f' or 'e' form according to size.
-func (f *Fmt) Fmt_g64(v float64)	{ f.plusSpace(strconv.Ftoa64(v, 'g', doPrec(f, -1))) }
+// fmt_g64 formats a float64 in the 'f' or 'e' form according to size.
+func (f *fmt) fmt_g64(v float64)	{ f.plusSpace(strconv.Ftoa64(v, 'g', doPrec(f, -1))) }
 
-// Fmt_g64 formats a float64 in the 'f' or 'E' form according to size.
-func (f *Fmt) Fmt_G64(v float64)	{ f.plusSpace(strconv.Ftoa64(v, 'G', doPrec(f, -1))) }
+// fmt_g64 formats a float64 in the 'f' or 'E' form according to size.
+func (f *fmt) fmt_G64(v float64)	{ f.plusSpace(strconv.Ftoa64(v, 'G', doPrec(f, -1))) }
 
-// Fmt_fb64 formats a float64 in the form -123p3 (exponent is power of 2).
-func (f *Fmt) Fmt_fb64(v float64)	{ f.plusSpace(strconv.Ftoa64(v, 'b', 0)) }
+// fmt_fb64 formats a float64 in the form -123p3 (exponent is power of 2).
+func (f *fmt) fmt_fb64(v float64)	{ f.plusSpace(strconv.Ftoa64(v, 'b', 0)) }
 
 // float32
 // cannot defer to float64 versions
 // because it will get rounding wrong in corner cases.
 
-// Fmt_e32 formats a float32 in the form -1.23e+12.
-func (f *Fmt) Fmt_e32(v float32)	{ f.plusSpace(strconv.Ftoa32(v, 'e', doPrec(f, 6))) }
+// fmt_e32 formats a float32 in the form -1.23e+12.
+func (f *fmt) fmt_e32(v float32)	{ f.plusSpace(strconv.Ftoa32(v, 'e', doPrec(f, 6))) }
 
-// Fmt_E32 formats a float32 in the form -1.23E+12.
-func (f *Fmt) Fmt_E32(v float32)	{ f.plusSpace(strconv.Ftoa32(v, 'E', doPrec(f, 6))) }
+// fmt_E32 formats a float32 in the form -1.23E+12.
+func (f *fmt) fmt_E32(v float32)	{ f.plusSpace(strconv.Ftoa32(v, 'E', doPrec(f, 6))) }
 
-// Fmt_f32 formats a float32 in the form -1.23.
-func (f *Fmt) Fmt_f32(v float32)	{ f.plusSpace(strconv.Ftoa32(v, 'f', doPrec(f, 6))) }
+// fmt_f32 formats a float32 in the form -1.23.
+func (f *fmt) fmt_f32(v float32)	{ f.plusSpace(strconv.Ftoa32(v, 'f', doPrec(f, 6))) }
 
-// Fmt_g32 formats a float32 in the 'f' or 'e' form according to size.
-func (f *Fmt) Fmt_g32(v float32)	{ f.plusSpace(strconv.Ftoa32(v, 'g', doPrec(f, -1))) }
+// fmt_g32 formats a float32 in the 'f' or 'e' form according to size.
+func (f *fmt) fmt_g32(v float32)	{ f.plusSpace(strconv.Ftoa32(v, 'g', doPrec(f, -1))) }
 
-// Fmt_G32 formats a float32 in the 'f' or 'E' form according to size.
-func (f *Fmt) Fmt_G32(v float32)	{ f.plusSpace(strconv.Ftoa32(v, 'G', doPrec(f, -1))) }
+// fmt_G32 formats a float32 in the 'f' or 'E' form according to size.
+func (f *fmt) fmt_G32(v float32)	{ f.plusSpace(strconv.Ftoa32(v, 'G', doPrec(f, -1))) }
 
-// Fmt_fb32 formats a float32 in the form -123p3 (exponent is power of 2).
-func (f *Fmt) Fmt_fb32(v float32)	{ fmtString(f, strconv.Ftoa32(v, 'b', 0)) }
+// fmt_fb32 formats a float32 in the form -123p3 (exponent is power of 2).
+func (f *fmt) fmt_fb32(v float32)	{ fmtString(f, strconv.Ftoa32(v, 'b', 0)) }
 
 // float
-func (x *Fmt) f(a float) {
+func (x *fmt) f(a float) {
 	if strconv.FloatSize == 32 {
-		x.Fmt_f32(float32(a))
+		x.fmt_f32(float32(a))
 	} else {
-		x.Fmt_f64(float64(a))
+		x.fmt_f64(float64(a))
 	}
 }
 
-func (x *Fmt) e(a float) {
+func (x *fmt) e(a float) {
 	if strconv.FloatSize == 32 {
-		x.Fmt_e32(float32(a))
+		x.fmt_e32(float32(a))
 	} else {
-		x.Fmt_e64(float64(a))
+		x.fmt_e64(float64(a))
 	}
 }
 
-func (x *Fmt) g(a float) {
+func (x *fmt) g(a float) {
 	if strconv.FloatSize == 32 {
-		x.Fmt_g32(float32(a))
+		x.fmt_g32(float32(a))
 	} else {
-		x.Fmt_g64(float64(a))
+		x.fmt_g64(float64(a))
 	}
 }
 
-func (x *Fmt) fb(a float) {
+func (x *fmt) fb(a float) {
 	if strconv.FloatSize == 32 {
-		x.Fmt_fb32(float32(a))
+		x.fmt_fb32(float32(a))
 	} else {
-		x.Fmt_fb64(float64(a))
+		x.fmt_fb64(float64(a))
 	}
 }
diff --git a/src/pkg/fmt/print.go b/src/pkg/fmt/print.go
index bf54b642c1..8a6935173b 100644
--- a/src/pkg/fmt/print.go
+++ b/src/pkg/fmt/print.go
@@ -143,7 +143,7 @@ type pp struct {
 	n	int;
 	buf	bytes.Buffer;
 	runeBuf	[utf8.UTFMax]byte;
-	fmt	Fmt;
+	fmt	fmt;
 }
 
 // A leaky bucket of reusable pp structures.
@@ -155,7 +155,7 @@ func newPrinter() *pp {
 		p = new(pp)
 	}
 	p.buf.Reset();
-	p.fmt.Init(&p.buf);
+	p.fmt.init(&p.buf);
 	return p;
 }
 
@@ -419,22 +419,22 @@ func (p *pp) printField(field reflect.Value, plus, sharp bool, depth int) (was_s
 BigSwitch:
 	switch f := field.(type) {
 	case *reflect.BoolValue:
-		p.fmt.Fmt_boolean(f.Get())
+		p.fmt.fmt_boolean(f.Get())
 	case *reflect.Float32Value:
-		p.fmt.Fmt_g32(f.Get())
+		p.fmt.fmt_g32(f.Get())
 	case *reflect.Float64Value:
-		p.fmt.Fmt_g64(f.Get())
+		p.fmt.fmt_g64(f.Get())
 	case *reflect.FloatValue:
 		if field.Type().Size()*8 == 32 {
-			p.fmt.Fmt_g32(float32(f.Get()))
+			p.fmt.fmt_g32(float32(f.Get()))
 		} else {
-			p.fmt.Fmt_g64(float64(f.Get()))
+			p.fmt.fmt_g64(float64(f.Get()))
 		}
 	case *reflect.StringValue:
 		if sharp {
-			p.fmt.Fmt_q(f.Get())
+			p.fmt.fmt_q(f.Get())
 		} else {
-			p.fmt.Fmt_s(f.Get());
+			p.fmt.fmt_s(f.Get());
 			was_string = true;
 		}
 	case *reflect.MapValue:
@@ -469,7 +469,7 @@ BigSwitch:
 		p.add('{');
 		v := f;
 		t := v.Type().(*reflect.StructType);
-		p.fmt.ClearFlags();	// clear flags for p.printField
+		p.fmt.clearflags();	// clear flags for p.printField
 		for i := 0; i < v.NumField(); i++ {
 			if i > 0 {
 				if sharp {
@@ -546,7 +546,7 @@ BigSwitch:
 				p.buf.Write(nilBytes)
 			} else {
 				p.fmt.sharp = true;
-				p.fmt.Fmt_ux64(uint64(v));
+				p.fmt.fmt_ux64(uint64(v));
 			}
 			p.buf.WriteByte(')');
 			break;
@@ -556,7 +556,7 @@ BigSwitch:
 			break;
 		}
 		p.fmt.sharp = true;	// turn 0x on
-		p.fmt.Fmt_ux64(uint64(v));
+		p.fmt.fmt_ux64(uint64(v));
 	case uintptrGetter:
 		v := f.Get();
 		if sharp {
@@ -568,24 +568,24 @@ BigSwitch:
 				p.buf.Write(nilBytes)
 			} else {
 				p.fmt.sharp = true;
-				p.fmt.Fmt_ux64(uint64(v));
+				p.fmt.fmt_ux64(uint64(v));
 			}
 			p.buf.WriteByte(')');
 		} else {
 			p.fmt.sharp = true;	// turn 0x on
-			p.fmt.Fmt_ux64(uint64(f.Get()));
+			p.fmt.fmt_ux64(uint64(f.Get()));
 		}
 	default:
 		v, signed, ok := getInt(field);
 		if ok {
 			if signed {
-				p.fmt.Fmt_d64(v)
+				p.fmt.fmt_d64(v)
 			} else {
 				if sharp {
 					p.fmt.sharp = true;	// turn on 0x
-					p.fmt.Fmt_ux64(uint64(v));
+					p.fmt.fmt_ux64(uint64(v));
 				} else {
-					p.fmt.Fmt_ud64(uint64(v))
+					p.fmt.fmt_ud64(uint64(v))
 				}
 			}
 			break;
@@ -613,7 +613,7 @@ func (p *pp) doprintf(format string, v *reflect.StructValue) {
 		}
 		i++;
 		// flags and widths
-		p.fmt.ClearFlags();
+		p.fmt.clearflags();
 	F:	for ; i < end; i++ {
 			switch format[i] {
 			case '#':
@@ -678,26 +678,26 @@ func (p *pp) doprintf(format string, v *reflect.StructValue) {
 		// int
 		case 'b':
 			if v, _, ok := getInt(field); ok {
-				p.fmt.Fmt_b64(uint64(v))	// always unsigned
+				p.fmt.fmt_b64(uint64(v))	// always unsigned
 			} else if v, ok := getFloat32(field); ok {
-				p.fmt.Fmt_fb32(v)
+				p.fmt.fmt_fb32(v)
 			} else if v, ok := getFloat64(field); ok {
-				p.fmt.Fmt_fb64(v)
+				p.fmt.fmt_fb64(v)
 			} else {
 				goto badtype
 			}
 		case 'c':
 			if v, _, ok := getInt(field); ok {
-				p.fmt.Fmt_c(int(v))
+				p.fmt.fmt_c(int(v))
 			} else {
 				goto badtype
 			}
 		case 'd':
 			if v, signed, ok := getInt(field); ok {
 				if signed {
-					p.fmt.Fmt_d64(v)
+					p.fmt.fmt_d64(v)
 				} else {
-					p.fmt.Fmt_ud64(uint64(v))
+					p.fmt.fmt_ud64(uint64(v))
 				}
 			} else {
 				goto badtype
@@ -705,9 +705,9 @@ func (p *pp) doprintf(format string, v *reflect.StructValue) {
 		case 'o':
 			if v, signed, ok := getInt(field); ok {
 				if signed {
-					p.fmt.Fmt_o64(v)
+					p.fmt.fmt_o64(v)
 				} else {
-					p.fmt.Fmt_uo64(uint64(v))
+					p.fmt.fmt_uo64(uint64(v))
 				}
 			} else {
 				goto badtype
@@ -715,24 +715,24 @@ func (p *pp) doprintf(format string, v *reflect.StructValue) {
 		case 'x':
 			if v, signed, ok := getInt(field); ok {
 				if signed {
-					p.fmt.Fmt_x64(v)
+					p.fmt.fmt_x64(v)
 				} else {
-					p.fmt.Fmt_ux64(uint64(v))
+					p.fmt.fmt_ux64(uint64(v))
 				}
 			} else if v, ok := getString(field); ok {
-				p.fmt.Fmt_sx(v)
+				p.fmt.fmt_sx(v)
 			} else {
 				goto badtype
 			}
 		case 'X':
 			if v, signed, ok := getInt(field); ok {
 				if signed {
-					p.fmt.Fmt_X64(v)
+					p.fmt.fmt_X64(v)
 				} else {
-					p.fmt.Fmt_uX64(uint64(v))
+					p.fmt.fmt_uX64(uint64(v))
 				}
 			} else if v, ok := getString(field); ok {
-				p.fmt.Fmt_sX(v)
+				p.fmt.fmt_sX(v)
 			} else {
 				goto badtype
 			}
@@ -740,41 +740,41 @@ func (p *pp) doprintf(format string, v *reflect.StructValue) {
 		// float
 		case 'e':
 			if v, ok := getFloat32(field); ok {
-				p.fmt.Fmt_e32(v)
+				p.fmt.fmt_e32(v)
 			} else if v, ok := getFloat64(field); ok {
-				p.fmt.Fmt_e64(v)
+				p.fmt.fmt_e64(v)
 			} else {
 				goto badtype
 			}
 		case 'E':
 			if v, ok := getFloat32(field); ok {
-				p.fmt.Fmt_E32(v)
+				p.fmt.fmt_E32(v)
 			} else if v, ok := getFloat64(field); ok {
-				p.fmt.Fmt_E64(v)
+				p.fmt.fmt_E64(v)
 			} else {
 				goto badtype
 			}
 		case 'f':
 			if v, ok := getFloat32(field); ok {
-				p.fmt.Fmt_f32(v)
+				p.fmt.fmt_f32(v)
 			} else if v, ok := getFloat64(field); ok {
-				p.fmt.Fmt_f64(v)
+				p.fmt.fmt_f64(v)
 			} else {
 				goto badtype
 			}
 		case 'g':
 			if v, ok := getFloat32(field); ok {
-				p.fmt.Fmt_g32(v)
+				p.fmt.fmt_g32(v)
 			} else if v, ok := getFloat64(field); ok {
-				p.fmt.Fmt_g64(v)
+				p.fmt.fmt_g64(v)
 			} else {
 				goto badtype
 			}
 		case 'G':
 			if v, ok := getFloat32(field); ok {
-				p.fmt.Fmt_G32(v)
+				p.fmt.fmt_G32(v)
 			} else if v, ok := getFloat64(field); ok {
-				p.fmt.Fmt_G64(v)
+				p.fmt.fmt_G64(v)
 			} else {
 				goto badtype
 			}
@@ -784,18 +784,18 @@ func (p *pp) doprintf(format string, v *reflect.StructValue) {
 			if inter != nil {
 				// if object implements String, use the result.
 				if stringer, ok := inter.(Stringer); ok {
-					p.fmt.Fmt_s(stringer.String());
+					p.fmt.fmt_s(stringer.String());
 					break;
 				}
 			}
 			if v, ok := getString(field); ok {
-				p.fmt.Fmt_s(v)
+				p.fmt.fmt_s(v)
 			} else {
 				goto badtype
 			}
 		case 'q':
 			if v, ok := getString(field); ok {
-				p.fmt.Fmt_q(v)
+				p.fmt.fmt_q(v)
 			} else {
 				goto badtype
 			}
@@ -806,8 +806,8 @@ func (p *pp) doprintf(format string, v *reflect.StructValue) {
 				if v == 0 {
 					p.buf.Write(nilAngleBytes)
 				} else {
-					p.fmt.Fmt_s("0x");
-					p.fmt.Fmt_uX64(uint64(v));
+					p.fmt.fmt_s("0x");
+					p.fmt.fmt_uX64(uint64(v));
 				}
 			} else {
 				goto badtype