src/pkg/fmt/print.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 fmt implements formatted I/O with functions analogous
 	to C's printf.  The format 'verbs' are derived from C's but
 	are simpler.

 	The verbs:

 	General:
 		%v	for any operand type, the value in a default format.
 			when printing structs, the plus flag (%+v) adds field names
 	Boolean:
 		%t	the word true or false
 	Integer:
 		%b	base 2
 		%c	the character represented by the corresponding Unicode code point
 		%d	base 10
 		%o	base 8
 		%x	base 16, with lower-case letters for a-f
 		%X	base 16, with upper-case letters for A-F
 	Floating-point:
 		%e	scientific notation, e.g. -1234.456e+78
 		%f	decimal point but no exponent, e.g. 123.456
 		%g	whichever of %e or %f produces more compact output
 	String and slice of bytes:
 		%s	the uninterpreted bytes of the string or slice
 		%q	a double-quoted string safely escaped with Go syntax
 		%x	base 16 notation with two characters per byte
 	Pointer:
 		%p	base 16 notation, with leading 0x
 	Type:
 		%T	a Go-syntax representation of the type of the operand

 	There is no 'u' flag.  Integers are printed unsigned if they have unsigned type.
 	Similarly, there is no need to specify the size of the operand (int8, int64).

 	For numeric values, the width and precision flags control
 	formatting; width sets the width of the field, precision the
 	number of places after the decimal, if appropriate.  The
 	format %6.2f prints 123.45.

 	Other flags:
 		+	always print a sign for numeric values
 		-	pad with spaces on the right rather than the left (left-justify the field)
 		#	alternate format: add leading 0 for octal (%#o), 0x for hex (%#x);
 			suppress 0x for %p (%#p);
 			print a raw (backquoted) string if possible for %q (%#q)
 		' '	(space) leave a space for elided sign in numbers (% d);
 			put spaces between bytes printing strings or slices in hex (% x)
 		0	pad with leading zeros rather than spaces

 	For each Printf-like function, there is also a Print function
 	that takes no format and is equivalent to saying %v for every
 	operand.  Another variant Println inserts blanks between
 	operands and appends a newline.

 	If an operand implements interface Format, that interface
 	can be used for fine control of formatting.

 	If an operand implements method String() string that method
 	will be used for %v, %s, or Print etc.
 */
 package fmt


 import (
 	"fmt";
 	"io";
 	"os";
 	"reflect";
 	"utf8";
 )

 // State represents the printer state passed to custom formatters.
 // It provides access to the io.Writer interface plus information about
 // the flags and options for the operand's format specifier.
 type State interface {
 	// Write is the function to call to emit formatted output to be printed.
 	Write(b []byte) (ret int, err os.Error);
 	// Width returns the value of the width option and whether it has been set.
 	Width()	(wid int, ok bool);
 	// Precision returns the value of the precision option and whether it has been set.
 	Precision()	(prec int, ok bool);

 	// Flag returns whether the flag c, a character, has been set.
 	Flag(int)	bool;
 }

 // Format is the interface implemented by objects with a custom formatter.
 // The implementation of Format may call Sprintf or Fprintf(f) etc.
 // to generate its output.
 type Formatter interface {
 	Format(f State, c int);
 }

 // String represents any object being printed that has a String() method that
 // returns a string, which defines the ``native'' format for that object.
 // Any such object will be printed using that method if passed
 // as operand to a %s or %v format or to an unformatted printer such as Print.
 type Stringer interface {
 	String() string
 }

 const runeSelf = utf8.RuneSelf
 const allocSize = 32

 type pp struct {
 	n	int;
 	buf	[]byte;
 	fmt	*Fmt;
 }

 func newPrinter() *pp {
 	p := new(pp);
 	p.fmt = fmt.New();
 	return p;
 }

 func (p *pp) Width() (wid int, ok bool) {
 	return p.fmt.wid, p.fmt.wid_present
 }

 func (p *pp) Precision() (prec int, ok bool) {
 	return p.fmt.prec, p.fmt.prec_present
 }

 func (p *pp) Flag(b int) bool {
 	switch b {
 	case '-':
 		return p.fmt.minus;
 	case '+':
 		return p.fmt.plus;
 	case '#':
 		return p.fmt.sharp;
 	case ' ':
 		return p.fmt.space;
 	case '0':
 		return p.fmt.zero;
 	}
 	return false
 }

 func (p *pp) ensure(n int) {
 	if len(p.buf) < n {
 		newn := allocSize + len(p.buf);
 		if newn < n {
 			newn = n + allocSize
 		}
 		b := make([]byte, newn);
 		for i := 0; i < p.n; i++ {
 			b[i] = p.buf[i];
 		}
 		p.buf = b;
 	}
 }

 func (p *pp) addstr(s string) {
 	n := len(s);
 	p.ensure(p.n + n);
 	for i := 0; i < n; i++ {
 		p.buf[p.n] = s[i];
 		p.n++;
 	}
 }

 func (p *pp) addbytes(b []byte, start, end int) {
 	p.ensure(p.n + end-start);
 	for i := start; i < end; i++ {
 		p.buf[p.n] = b[i];
 		p.n++;
 	}
 }

 func (p *pp) add(c int) {
 	p.ensure(p.n + 1);
 	if c < runeSelf {
 		p.buf[p.n] = byte(c);
 		p.n++;
 	} else {
 		p.addstr(string(c));
 	}
 }

 // Implement Write so we can call fprintf on a P, for
 // recursive use in custom verbs.
 func (p *pp) Write(b []byte) (ret int, err os.Error) {
 	p.addbytes(b, 0, len(b));
 	return len(b), nil;
 }

 func (p *pp) doprintf(format string, v reflect.StructValue);
 func (p *pp) doprint(v reflect.StructValue, addspace, addnewline bool);

 // These routines end in 'f' and take a format string.

 // Fprintf formats according to a format specifier and writes to w.
 func Fprintf(w io.Writer, format string, a ...) (n int, error os.Error) {
 	v := reflect.NewValue(a).(reflect.StructValue);
 	p := newPrinter();
 	p.doprintf(format, v);
 	n, error = w.Write(p.buf[0:p.n]);
 	return n, error;
 }

 // Printf formats according to a format specifier and writes to standard output.
 func Printf(format string, v ...) (n int, errno os.Error) {
 	n, errno = Fprintf(os.Stdout, format, v);
 	return n, errno;
 }

 // Sprintf formats according to a format specifier and returns the resulting string.
 func Sprintf(format string, a ...) string {
 	v := reflect.NewValue(a).(reflect.StructValue);
 	p := newPrinter();
 	p.doprintf(format, v);
 	s := string(p.buf)[0 : p.n];
 	return s;
 }

 // These routines do not take a format string

 // Fprint formats using the default formats for its operands and writes to w.
 // Spaces are added between operands when neither is a string.
 func Fprint(w io.Writer, a ...) (n int, error os.Error) {
 	v := reflect.NewValue(a).(reflect.StructValue);
 	p := newPrinter();
 	p.doprint(v, false, false);
 	n, error = w.Write(p.buf[0:p.n]);
 	return n, error;
 }

 // Print formats using the default formats for its operands and writes to standard output.
 // Spaces are added between operands when neither is a string.
 func Print(v ...) (n int, errno os.Error) {
 	n, errno = Fprint(os.Stdout, v);
 	return n, errno;
 }

 // Sprint formats using the default formats for its operands and returns the resulting string.
 // Spaces are added between operands when neither is a string.
 func Sprint(a ...) string {
 	v := reflect.NewValue(a).(reflect.StructValue);
 	p := newPrinter();
 	p.doprint(v, false, false);
 	s := string(p.buf)[0 : p.n];
 	return s;
 }

 // These routines end in 'ln', do not take a format string,
 // always add spaces between operands, and add a newline
 // after the last operand.

 // Fprintln formats using the default formats for its operands and writes to w.
 // Spaces are always added between operands and a newline is appended.
 func Fprintln(w io.Writer, a ...) (n int, error os.Error) {
 	v := reflect.NewValue(a).(reflect.StructValue);
 	p := newPrinter();
 	p.doprint(v, true, true);
 	n, error = w.Write(p.buf[0:p.n]);
 	return n, error;
 }

 // Println formats using the default formats for its operands and writes to standard output.
 // Spaces are always added between operands and a newline is appended.
 func Println(v ...) (n int, errno os.Error) {
 	n, errno = Fprintln(os.Stdout, v);
 	return n, errno;
 }

 // Sprintln formats using the default formats for its operands and returns the resulting string.
 // Spaces are always added between operands and a newline is appended.
 func Sprintln(a ...) string {
 	v := reflect.NewValue(a).(reflect.StructValue);
 	p := newPrinter();
 	p.doprint(v, true, true);
 	s := string(p.buf)[0 : p.n];
 	return s;
 }


 // Get the i'th arg of the struct value.
 // If the arg itself is an interface, return a value for
 // the thing inside the interface, not the interface itself.
 func getField(v reflect.StructValue, i int) reflect.Value {
 	val := v.Field(i);
 	if val.Kind() == reflect.InterfaceKind {
 		inter := val.(reflect.InterfaceValue).Get();
 		return reflect.NewValue(inter);
 	}
 	return val;
 }

 // Getters for the fields of the argument structure.

 func getBool(v reflect.Value) (val bool, ok bool) {
 	switch v.Kind() {
 	case reflect.BoolKind:
 		return v.(reflect.BoolValue).Get(), true;
 	}
 	return false, false
 }

 func getInt(v reflect.Value) (val int64, signed, ok bool) {
 	switch v.Kind() {
 	case reflect.IntKind:
 		return int64(v.(reflect.IntValue).Get()), true, true;
 	case reflect.Int8Kind:
 		return int64(v.(reflect.Int8Value).Get()), true, true;
 	case reflect.Int16Kind:
 		return int64(v.(reflect.Int16Value).Get()), true, true;
 	case reflect.Int32Kind:
 		return int64(v.(reflect.Int32Value).Get()), true, true;
 	case reflect.Int64Kind:
 		return int64(v.(reflect.Int64Value).Get()), true, true;
 	case reflect.UintKind:
 		return int64(v.(reflect.UintValue).Get()), false, true;
 	case reflect.Uint8Kind:
 		return int64(v.(reflect.Uint8Value).Get()), false, true;
 	case reflect.Uint16Kind:
 		return int64(v.(reflect.Uint16Value).Get()), false, true;
 	case reflect.Uint32Kind:
 		return int64(v.(reflect.Uint32Value).Get()), false, true;
 	case reflect.Uint64Kind:
 		return int64(v.(reflect.Uint64Value).Get()), false, true;
 	case reflect.UintptrKind:
 		return int64(v.(reflect.UintptrValue).Get()), false, true;
 	}
 	return 0, false, false;
 }

 func getString(v reflect.Value) (val string, ok bool) {
 	switch v.Kind() {
 	case reflect.StringKind:
 		return v.(reflect.StringValue).Get(), true;
 	case reflect.ArrayKind:
 		if val, ok := v.Interface().([]byte); ok {
 			return string(val), true;
 		}
 	}
 	return "", false;
 }

 func getFloat32(v reflect.Value) (val float32, ok bool) {
 	switch v.Kind() {
 	case reflect.Float32Kind:
 		return float32(v.(reflect.Float32Value).Get()), true;
 	case reflect.FloatKind:
 		if v.Type().Size()*8 == 32 {
 			return float32(v.(reflect.FloatValue).Get()), true;
 		}
 	}
 	return 0.0, false;
 }

 func getFloat64(v reflect.Value) (val float64, ok bool) {
 	switch v.Kind() {
 	case reflect.FloatKind:
 		if v.Type().Size()*8 == 64 {
 			return float64(v.(reflect.FloatValue).Get()), true;
 		}
 	case reflect.Float64Kind:
 		return float64(v.(reflect.Float64Value).Get()), true;
 	}
 	return 0.0, false;
 }

 func getPtr(v reflect.Value) (val uintptr, ok bool) {
 	switch v.Kind() {
 	case reflect.PtrKind:
 		return uintptr(v.(reflect.PtrValue).Get()), true;
 	}
 	return 0, false;
 }

 func getArrayPtr(v reflect.Value) (val reflect.ArrayValue, ok bool) {
 	if v.Kind() == reflect.PtrKind {
 		v = v.(reflect.PtrValue).Sub();
 		if v.Kind() == reflect.ArrayKind {
 			return v.(reflect.ArrayValue), true;
 		}
 	}
 	return nil, false;
 }

 func getArray(v reflect.Value) (val reflect.ArrayValue, ok bool) {
 	switch v.Kind() {
 	case reflect.ArrayKind:
 		return v.(reflect.ArrayValue), true;
 	}
 	return nil, false;
 }

 // Convert ASCII to integer.  n is 0 (and got is false) if no number present.

 func parsenum(s string, start, end int) (n int, got bool, newi int) {
 	if start >= end {
 		return 0, false, end
 	}
 	isnum := false;
 	num := 0;
 	for '0' <= s[start] && s[start] <= '9' {
 		num = num*10 + int(s[start] - '0');
 		start++;
 		isnum = true;
 	}
 	return num, isnum, start;
 }

 func (p *pp) printField(field reflect.Value) (was_string bool) {
 	inter := field.Interface();
 	if inter != nil {
 		if stringer, ok := inter.(Stringer); ok {
 			p.addstr(stringer.String());
 			return false;	// this value is not a string
 		}
 	}
 	s := "";
 	switch field.Kind() {
 	case reflect.BoolKind:
 		s = p.fmt.Fmt_boolean(field.(reflect.BoolValue).Get()).Str();
 	case reflect.IntKind, reflect.Int8Kind, reflect.Int16Kind, reflect.Int32Kind, reflect.Int64Kind:
 		v, signed, ok := getInt(field);
 		s = p.fmt.Fmt_d64(v).Str();
 	case reflect.UintKind, reflect.Uint8Kind, reflect.Uint16Kind, reflect.Uint32Kind, reflect.Uint64Kind:
 		v, signed, ok := getInt(field);
 		s = p.fmt.Fmt_ud64(uint64(v)).Str();
 	case reflect.UintptrKind:
 		v, signed, ok := getInt(field);
 		p.fmt.sharp = !p.fmt.sharp;  // turn 0x on by default
 		s = p.fmt.Fmt_ux64(uint64(v)).Str();
 	case reflect.Float32Kind:
 		v, ok := getFloat32(field);
 		s = p.fmt.Fmt_g32(v).Str();
 	case reflect.Float64Kind:
 		v, ok := getFloat64(field);
 		s = p.fmt.Fmt_g64(v).Str();
 	case reflect.FloatKind:
 		if field.Type().Size()*8 == 32 {
 			v, ok := getFloat32(field);
 			s = p.fmt.Fmt_g32(v).Str();
 		} else {
 			v, ok := getFloat64(field);
 			s = p.fmt.Fmt_g64(v).Str();
 		}
 	case reflect.StringKind:
 		v, ok := getString(field);
 		s = p.fmt.Fmt_s(v).Str();
 		was_string = true;
 	case reflect.PtrKind:
 		if v, ok := getPtr(field); v == 0 {
 			s = "<nil>"
 		} else {
 			// pointer to array?  (TODO(r): holdover; delete?)
 			if a, ok := getArrayPtr(field); ok {
 				p.addstr("&[");
 				for i := 0; i < a.Len(); i++ {
 					if i > 0 {
 						p.addstr(" ");
 					}
 					p.printField(a.Elem(i));
 				}
 				p.addstr("]");
 			} else {
 				p.fmt.sharp = !p.fmt.sharp;  // turn 0x on by default
 				s = p.fmt.Fmt_uX64(uint64(v)).Str();
 			}
 		}
 	case reflect.ArrayKind:
 		if a, ok := getArray(field); ok {
 			p.addstr("[");
 			for i := 0; i < a.Len(); i++ {
 				if i > 0 {
 					p.addstr(" ");
 				}
 				p.printField(a.Elem(i));
 			}
 			p.addstr("]");
 		}
 	case reflect.StructKind:
 		p.add('{');
 		v := field.(reflect.StructValue);
 		t := v.Type().(reflect.StructType);
 		donames := p.fmt.plus;
 		p.fmt.clearflags();	// clear flags for p.printField
 		for i := 0; i < v.Len();  i++ {
 			if i > 0 {
 				p.add(' ')
 			}
 			if donames {
 				if name, typ, tag, off := t.Field(i); name != "" {
 					p.addstr(name);
 					p.add('=');
 				}
 			}
 			p.printField(getField(v, i));
 		}
 		p.add('}');
 	case reflect.InterfaceKind:
 		value := field.(reflect.InterfaceValue).Value();
 		if value == nil {
 			s = "<nil>"
 		} else {
 			return p.printField(value);
 		}
 	default:
 		s = "?" + field.Type().String() + "?";
 	}
 	p.addstr(s);
 	return was_string;
 }

 func (p *pp) doprintf(format string, v reflect.StructValue) {
 	p.ensure(len(format));	// a good starting size
 	end := len(format) - 1;
 	fieldnum := 0;	// we process one field per non-trivial format
 	for i := 0; i <= end;  {
 		c, w := utf8.DecodeRuneInString(format[i:len(format)]);
 		if c != '%' || i == end {
 			p.add(c);
 			i += w;
 			continue;
 		}
 		i++;
 		// flags and widths
 		p.fmt.clearflags();
 		F: for ; i < end; i++ {
 			switch format[i] {
 			case '#':
 				p.fmt.sharp = true;
 			case '0':
 				p.fmt.zero = true;
 			case '+':
 				p.fmt.plus = true;
 			case '-':
 				p.fmt.minus = true;
 			case ' ':
 				p.fmt.space = true;
 			default:
 				break F;
 			}
 		}
 		// do we have 20 (width)?
 		p.fmt.wid, p.fmt.wid_present, i = parsenum(format, i, end);
 		// do we have .20 (precision)?
 		if i < end && format[i] == '.' {
 			p.fmt.prec, p.fmt.prec_present, i = parsenum(format, i+1, end);
 		}
 		c, w = utf8.DecodeRuneInString(format[i:len(format)]);
 		i += w;
 		// percent is special - absorbs no operand
 		if c == '%' {
 			p.add('%');	// TODO: should we bother with width & prec?
 			continue;
 		}
 		if fieldnum >= v.Len() {	// out of operands
 			p.add('%');
 			p.add(c);
 			p.addstr("(missing)");
 			continue;
 		}
 		field := getField(v, fieldnum);
 		fieldnum++;
 		inter := field.Interface();
 		if inter != nil && c != 'T' {	// don't want thing to describe itself if we're asking for its type
 			if formatter, ok := inter.(Formatter); ok {
 				formatter.Format(p, c);
 				continue;
 			}
 		}
 		s := "";
 		switch c {
 			// bool
 			case 't':
 				if v, ok := getBool(field); ok {
 					if v {
 						s = "true";
 					} else {
 						s = "false";
 					}
 				} else {
 					goto badtype;
 				}

 			// int
 			case 'b':
 				if v, signed, ok := getInt(field); ok {
 					s = p.fmt.Fmt_b64(uint64(v)).Str()	// always unsigned
 				} else if v, ok := getFloat32(field); ok {
 					s = p.fmt.Fmt_fb32(v).Str()
 				} else if v, ok := getFloat64(field); ok {
 					s = p.fmt.Fmt_fb64(v).Str()
 				} else {
 					goto badtype
 				}
 			case 'c':
 				if v, signed, ok := getInt(field); ok {
 					s = p.fmt.Fmt_c(int(v)).Str()
 				} else {
 					goto badtype
 				}
 			case 'd':
 				if v, signed, ok := getInt(field); ok {
 					if signed {
 						s = p.fmt.Fmt_d64(v).Str()
 					} else {
 						s = p.fmt.Fmt_ud64(uint64(v)).Str()
 					}
 				} else {
 					goto badtype
 				}
 			case 'o':
 				if v, signed, ok := getInt(field); ok {
 					if signed {
 						s = p.fmt.Fmt_o64(v).Str()
 					} else {
 						s = p.fmt.Fmt_uo64(uint64(v)).Str()
 					}
 				} else {
 					goto badtype
 				}
 			case 'x':
 				if v, signed, ok := getInt(field); ok {
 					if signed {
 						s = p.fmt.Fmt_x64(v).Str()
 					} else {
 						s = p.fmt.Fmt_ux64(uint64(v)).Str()
 					}
 				} else if v, ok := getString(field); ok {
 					s = p.fmt.Fmt_sx(v).Str();
 				} else {
 					goto badtype
 				}
 			case 'X':
 				if v, signed, ok := getInt(field); ok {
 					if signed {
 						s = p.fmt.Fmt_X64(v).Str()
 					} else {
 						s = p.fmt.Fmt_uX64(uint64(v)).Str()
 					}
 				} else if v, ok := getString(field); ok {
 					s = p.fmt.Fmt_sX(v).Str();
 				} else {
 					goto badtype
 				}

 			// float
 			case 'e':
 				if v, ok := getFloat32(field); ok {
 					s = p.fmt.Fmt_e32(v).Str()
 				} else if v, ok := getFloat64(field); ok {
 					s = p.fmt.Fmt_e64(v).Str()
 				} else {
 					goto badtype
 				}
 			case 'f':
 				if v, ok := getFloat32(field); ok {
 					s = p.fmt.Fmt_f32(v).Str()
 				} else if v, ok := getFloat64(field); ok {
 					s = p.fmt.Fmt_f64(v).Str()
 				} else {
 					goto badtype
 				}
 			case 'g':
 				if v, ok := getFloat32(field); ok {
 					s = p.fmt.Fmt_g32(v).Str()
 				} else if v, ok := getFloat64(field); ok {
 					s = p.fmt.Fmt_g64(v).Str()
 				} else {
 					goto badtype
 				}

 			// string
 			case 's':
 				if inter != nil {
 					// if object implements String, use the result.
 					if stringer, ok := inter.(Stringer); ok {
 						s = p.fmt.Fmt_s(stringer.String()).Str();
 						break;
 					}
 				}
 				if v, ok := getString(field); ok {
 					s = p.fmt.Fmt_s(v).Str()
 				} else {
 					goto badtype
 				}
 			case 'q':
 				if v, ok := getString(field); ok {
 					s = p.fmt.Fmt_q(v).Str()
 				} else {
 					goto badtype
 				}

 			// pointer
 			case 'p':
 				if v, ok := getPtr(field); ok {
 					if v == 0 {
 						s = "<nil>"
 					} else {
 						s = "0x" + p.fmt.Fmt_uX64(uint64(v)).Str()
 					}
 				} else {
 					goto badtype
 				}

 			// arbitrary value; do your best
 			case 'v':
 				p.printField(field);

 			// the value's type
 			case 'T':
 				s = field.Type().String();

 			default:
 			badtype:
 				s = "%" + string(c) + "(" + field.Type().String() + ")%";
 		}
 		p.addstr(s);
 	}
 	if fieldnum < v.Len() {
 		p.addstr("?(extra ");
 		for ; fieldnum < v.Len(); fieldnum++ {
 			p.addstr(getField(v, fieldnum).Type().String());
 			if fieldnum + 1 < v.Len() {
 				p.addstr(", ");
 			}
 		}
 		p.addstr(")");
 	}
 }

 func (p *pp) doprint(v reflect.StructValue, addspace, addnewline bool) {
 	prev_string := false;
 	for fieldnum := 0; fieldnum < v.Len();  fieldnum++ {
 		// always add spaces if we're doing println
 		field := getField(v, fieldnum);
 		if fieldnum > 0 {
 			if addspace {
 				p.add(' ')
 			} else if field.Kind() != reflect.StringKind && !prev_string{
 				// if not doing println, add spaces if neither side is a string
 				p.add(' ')
 			}
 		}
 		was_string := p.printField(field);
 		prev_string = was_string;
 	}
 	if addnewline {
 		p.add('\n')
 	}
 }
	// 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 fmt implements formatted I/O with functions analogous
	to C's printf. The format 'verbs' are derived from C's but
	are simpler.

	The verbs:

	General:
	%v for any operand type, the value in a default format.
	when printing structs, the plus flag (%+v) adds field names
	Boolean:
	%t the word true or false
	Integer:
	%b base 2
	%c the character represented by the corresponding Unicode code point
	%d base 10
	%o base 8
	%x base 16, with lower-case letters for a-f
	%X base 16, with upper-case letters for A-F
	Floating-point:
	%e scientific notation, e.g. -1234.456e+78
	%f decimal point but no exponent, e.g. 123.456
	%g whichever of %e or %f produces more compact output
	String and slice of bytes:
	%s the uninterpreted bytes of the string or slice
	%q a double-quoted string safely escaped with Go syntax
	%x base 16 notation with two characters per byte
	Pointer:
	%p base 16 notation, with leading 0x
	Type:
	%T a Go-syntax representation of the type of the operand

	There is no 'u' flag. Integers are printed unsigned if they have unsigned type.
	Similarly, there is no need to specify the size of the operand (int8, int64).

	For numeric values, the width and precision flags control
	formatting; width sets the width of the field, precision the
	number of places after the decimal, if appropriate. The
	format %6.2f prints 123.45.

	Other flags:
	+ always print a sign for numeric values
	- pad with spaces on the right rather than the left (left-justify the field)
	# alternate format: add leading 0 for octal (%#o), 0x for hex (%#x);
	suppress 0x for %p (%#p);
	print a raw (backquoted) string if possible for %q (%#q)
	' ' (space) leave a space for elided sign in numbers (% d);
	put spaces between bytes printing strings or slices in hex (% x)
	0 pad with leading zeros rather than spaces

	For each Printf-like function, there is also a Print function
	that takes no format and is equivalent to saying %v for every
	operand. Another variant Println inserts blanks between
	operands and appends a newline.

	If an operand implements interface Format, that interface
	can be used for fine control of formatting.

	If an operand implements method String() string that method
	will be used for %v, %s, or Print etc.
	*/
	package fmt


	import (
	"fmt";
	"io";
	"os";
	"reflect";
	"utf8";
	)

	// State represents the printer state passed to custom formatters.
	// It provides access to the io.Writer interface plus information about
	// the flags and options for the operand's format specifier.
	type State interface {
	// Write is the function to call to emit formatted output to be printed.
	Write(b []byte) (ret int, err os.Error);
	// Width returns the value of the width option and whether it has been set.
	Width() (wid int, ok bool);
	// Precision returns the value of the precision option and whether it has been set.
	Precision() (prec int, ok bool);

	// Flag returns whether the flag c, a character, has been set.
	Flag(int) bool;
	}

	// Format is the interface implemented by objects with a custom formatter.
	// The implementation of Format may call Sprintf or Fprintf(f) etc.
	// to generate its output.
	type Formatter interface {
	Format(f State, c int);
	}

	// String represents any object being printed that has a String() method that
	// returns a string, which defines the ``native'' format for that object.
	// Any such object will be printed using that method if passed
	// as operand to a %s or %v format or to an unformatted printer such as Print.
	type Stringer interface {
	String() string
	}

	const runeSelf = utf8.RuneSelf
	const allocSize = 32

	type pp struct {
	n int;
	buf []byte;
	fmt *Fmt;
	}

	func newPrinter() *pp {
	p := new(pp);
	p.fmt = fmt.New();
	return p;
	}

	func (p *pp) Width() (wid int, ok bool) {
	return p.fmt.wid, p.fmt.wid_present
	}

	func (p *pp) Precision() (prec int, ok bool) {
	return p.fmt.prec, p.fmt.prec_present
	}

	func (p *pp) Flag(b int) bool {
	switch b {
	case '-':
	return p.fmt.minus;
	case '+':
	return p.fmt.plus;
	case '#':
	return p.fmt.sharp;
	case ' ':
	return p.fmt.space;
	case '0':
	return p.fmt.zero;
	}
	return false
	}

	func (p *pp) ensure(n int) {
	if len(p.buf) < n {
	newn := allocSize + len(p.buf);
	if newn < n {
	newn = n + allocSize
	}
	b := make([]byte, newn);
	for i := 0; i < p.n; i++ {
	b[i] = p.buf[i];
	}
	p.buf = b;
	}
	}

	func (p *pp) addstr(s string) {
	n := len(s);
	p.ensure(p.n + n);
	for i := 0; i < n; i++ {
	p.buf[p.n] = s[i];
	p.n++;
	}
	}

	func (p *pp) addbytes(b []byte, start, end int) {
	p.ensure(p.n + end-start);
	for i := start; i < end; i++ {
	p.buf[p.n] = b[i];
	p.n++;
	}
	}

	func (p *pp) add(c int) {
	p.ensure(p.n + 1);
	if c < runeSelf {
	p.buf[p.n] = byte(c);
	p.n++;
	} else {
	p.addstr(string(c));
	}
	}

	// Implement Write so we can call fprintf on a P, for
	// recursive use in custom verbs.
	func (p *pp) Write(b []byte) (ret int, err os.Error) {
	p.addbytes(b, 0, len(b));
	return len(b), nil;
	}

	func (p *pp) doprintf(format string, v reflect.StructValue);
	func (p *pp) doprint(v reflect.StructValue, addspace, addnewline bool);

	// These routines end in 'f' and take a format string.

	// Fprintf formats according to a format specifier and writes to w.
	func Fprintf(w io.Writer, format string, a ...) (n int, error os.Error) {
	v := reflect.NewValue(a).(reflect.StructValue);
	p := newPrinter();
	p.doprintf(format, v);
	n, error = w.Write(p.buf[0:p.n]);
	return n, error;
	}

	// Printf formats according to a format specifier and writes to standard output.
	func Printf(format string, v ...) (n int, errno os.Error) {
	n, errno = Fprintf(os.Stdout, format, v);
	return n, errno;
	}

	// Sprintf formats according to a format specifier and returns the resulting string.
	func Sprintf(format string, a ...) string {
	v := reflect.NewValue(a).(reflect.StructValue);
	p := newPrinter();
	p.doprintf(format, v);
	s := string(p.buf)[0 : p.n];
	return s;
	}

	// These routines do not take a format string

	// Fprint formats using the default formats for its operands and writes to w.
	// Spaces are added between operands when neither is a string.
	func Fprint(w io.Writer, a ...) (n int, error os.Error) {
	v := reflect.NewValue(a).(reflect.StructValue);
	p := newPrinter();
	p.doprint(v, false, false);
	n, error = w.Write(p.buf[0:p.n]);
	return n, error;
	}

	// Print formats using the default formats for its operands and writes to standard output.
	// Spaces are added between operands when neither is a string.
	func Print(v ...) (n int, errno os.Error) {
	n, errno = Fprint(os.Stdout, v);
	return n, errno;
	}

	// Sprint formats using the default formats for its operands and returns the resulting string.
	// Spaces are added between operands when neither is a string.
	func Sprint(a ...) string {
	v := reflect.NewValue(a).(reflect.StructValue);
	p := newPrinter();
	p.doprint(v, false, false);
	s := string(p.buf)[0 : p.n];
	return s;
	}

	// These routines end in 'ln', do not take a format string,
	// always add spaces between operands, and add a newline
	// after the last operand.

	// Fprintln formats using the default formats for its operands and writes to w.
	// Spaces are always added between operands and a newline is appended.
	func Fprintln(w io.Writer, a ...) (n int, error os.Error) {
	v := reflect.NewValue(a).(reflect.StructValue);
	p := newPrinter();
	p.doprint(v, true, true);
	n, error = w.Write(p.buf[0:p.n]);
	return n, error;
	}

	// Println formats using the default formats for its operands and writes to standard output.
	// Spaces are always added between operands and a newline is appended.
	func Println(v ...) (n int, errno os.Error) {
	n, errno = Fprintln(os.Stdout, v);
	return n, errno;
	}

	// Sprintln formats using the default formats for its operands and returns the resulting string.
	// Spaces are always added between operands and a newline is appended.
	func Sprintln(a ...) string {
	v := reflect.NewValue(a).(reflect.StructValue);
	p := newPrinter();
	p.doprint(v, true, true);
	s := string(p.buf)[0 : p.n];
	return s;
	}


	// Get the i'th arg of the struct value.
	// If the arg itself is an interface, return a value for
	// the thing inside the interface, not the interface itself.
	func getField(v reflect.StructValue, i int) reflect.Value {
	val := v.Field(i);
	if val.Kind() == reflect.InterfaceKind {
	inter := val.(reflect.InterfaceValue).Get();
	return reflect.NewValue(inter);
	}
	return val;
	}

	// Getters for the fields of the argument structure.

	func getBool(v reflect.Value) (val bool, ok bool) {
	switch v.Kind() {
	case reflect.BoolKind:
	return v.(reflect.BoolValue).Get(), true;
	}
	return false, false
	}

	func getInt(v reflect.Value) (val int64, signed, ok bool) {
	switch v.Kind() {
	case reflect.IntKind:
	return int64(v.(reflect.IntValue).Get()), true, true;
	case reflect.Int8Kind:
	return int64(v.(reflect.Int8Value).Get()), true, true;
	case reflect.Int16Kind:
	return int64(v.(reflect.Int16Value).Get()), true, true;
	case reflect.Int32Kind:
	return int64(v.(reflect.Int32Value).Get()), true, true;
	case reflect.Int64Kind:
	return int64(v.(reflect.Int64Value).Get()), true, true;
	case reflect.UintKind:
	return int64(v.(reflect.UintValue).Get()), false, true;
	case reflect.Uint8Kind:
	return int64(v.(reflect.Uint8Value).Get()), false, true;
	case reflect.Uint16Kind:
	return int64(v.(reflect.Uint16Value).Get()), false, true;
	case reflect.Uint32Kind:
	return int64(v.(reflect.Uint32Value).Get()), false, true;
	case reflect.Uint64Kind:
	return int64(v.(reflect.Uint64Value).Get()), false, true;
	case reflect.UintptrKind:
	return int64(v.(reflect.UintptrValue).Get()), false, true;
	}
	return 0, false, false;
	}

	func getString(v reflect.Value) (val string, ok bool) {
	switch v.Kind() {
	case reflect.StringKind:
	return v.(reflect.StringValue).Get(), true;
	case reflect.ArrayKind:
	if val, ok := v.Interface().([]byte); ok {
	return string(val), true;
	}
	}
	return "", false;
	}

	func getFloat32(v reflect.Value) (val float32, ok bool) {
	switch v.Kind() {
	case reflect.Float32Kind:
	return float32(v.(reflect.Float32Value).Get()), true;
	case reflect.FloatKind:
	if v.Type().Size()*8 == 32 {
	return float32(v.(reflect.FloatValue).Get()), true;
	}
	}
	return 0.0, false;
	}

	func getFloat64(v reflect.Value) (val float64, ok bool) {
	switch v.Kind() {
	case reflect.FloatKind:
	if v.Type().Size()*8 == 64 {
	return float64(v.(reflect.FloatValue).Get()), true;
	}
	case reflect.Float64Kind:
	return float64(v.(reflect.Float64Value).Get()), true;
	}
	return 0.0, false;
	}

	func getPtr(v reflect.Value) (val uintptr, ok bool) {
	switch v.Kind() {
	case reflect.PtrKind:
	return uintptr(v.(reflect.PtrValue).Get()), true;
	}
	return 0, false;
	}

	func getArrayPtr(v reflect.Value) (val reflect.ArrayValue, ok bool) {
	if v.Kind() == reflect.PtrKind {
	v = v.(reflect.PtrValue).Sub();
	if v.Kind() == reflect.ArrayKind {
	return v.(reflect.ArrayValue), true;
	}
	}
	return nil, false;
	}

	func getArray(v reflect.Value) (val reflect.ArrayValue, ok bool) {
	switch v.Kind() {
	case reflect.ArrayKind:
	return v.(reflect.ArrayValue), true;
	}
	return nil, false;
	}

	// Convert ASCII to integer. n is 0 (and got is false) if no number present.

	func parsenum(s string, start, end int) (n int, got bool, newi int) {
	if start >= end {
	return 0, false, end
	}
	isnum := false;
	num := 0;
	for '0' <= s[start] && s[start] <= '9' {
	num = num*10 + int(s[start] - '0');
	start++;
	isnum = true;
	}
	return num, isnum, start;
	}

	func (p *pp) printField(field reflect.Value) (was_string bool) {
	inter := field.Interface();
	if inter != nil {
	if stringer, ok := inter.(Stringer); ok {
	p.addstr(stringer.String());
	return false; // this value is not a string
	}
	}
	s := "";
	switch field.Kind() {
	case reflect.BoolKind:
	s = p.fmt.Fmt_boolean(field.(reflect.BoolValue).Get()).Str();
	case reflect.IntKind, reflect.Int8Kind, reflect.Int16Kind, reflect.Int32Kind, reflect.Int64Kind:
	v, signed, ok := getInt(field);
	s = p.fmt.Fmt_d64(v).Str();
	case reflect.UintKind, reflect.Uint8Kind, reflect.Uint16Kind, reflect.Uint32Kind, reflect.Uint64Kind:
	v, signed, ok := getInt(field);
	s = p.fmt.Fmt_ud64(uint64(v)).Str();
	case reflect.UintptrKind:
	v, signed, ok := getInt(field);
	p.fmt.sharp = !p.fmt.sharp; // turn 0x on by default
	s = p.fmt.Fmt_ux64(uint64(v)).Str();
	case reflect.Float32Kind:
	v, ok := getFloat32(field);
	s = p.fmt.Fmt_g32(v).Str();
	case reflect.Float64Kind:
	v, ok := getFloat64(field);
	s = p.fmt.Fmt_g64(v).Str();
	case reflect.FloatKind:
	if field.Type().Size()*8 == 32 {
	v, ok := getFloat32(field);
	s = p.fmt.Fmt_g32(v).Str();
	} else {
	v, ok := getFloat64(field);
	s = p.fmt.Fmt_g64(v).Str();
	}
	case reflect.StringKind:
	v, ok := getString(field);
	s = p.fmt.Fmt_s(v).Str();
	was_string = true;
	case reflect.PtrKind:
	if v, ok := getPtr(field); v == 0 {
	s = "<nil>"
	} else {
	// pointer to array? (TODO(r): holdover; delete?)
	if a, ok := getArrayPtr(field); ok {
	p.addstr("&[");
	for i := 0; i < a.Len(); i++ {
	if i > 0 {
	p.addstr(" ");
	}
	p.printField(a.Elem(i));
	}
	p.addstr("]");
	} else {
	p.fmt.sharp = !p.fmt.sharp; // turn 0x on by default
	s = p.fmt.Fmt_uX64(uint64(v)).Str();
	}
	}
	case reflect.ArrayKind:
	if a, ok := getArray(field); ok {
	p.addstr("[");
	for i := 0; i < a.Len(); i++ {
	if i > 0 {
	p.addstr(" ");
	}
	p.printField(a.Elem(i));
	}
	p.addstr("]");
	}
	case reflect.StructKind:
	p.add('{');
	v := field.(reflect.StructValue);
	t := v.Type().(reflect.StructType);
	donames := p.fmt.plus;
	p.fmt.clearflags(); // clear flags for p.printField
	for i := 0; i < v.Len(); i++ {
	if i > 0 {
	p.add(' ')
	}
	if donames {
	if name, typ, tag, off := t.Field(i); name != "" {
	p.addstr(name);
	p.add('=');
	}
	}
	p.printField(getField(v, i));
	}
	p.add('}');
	case reflect.InterfaceKind:
	value := field.(reflect.InterfaceValue).Value();
	if value == nil {
	s = "<nil>"
	} else {
	return p.printField(value);
	}
	default:
	s = "?" + field.Type().String() + "?";
	}
	p.addstr(s);
	return was_string;
	}

	func (p *pp) doprintf(format string, v reflect.StructValue) {
	p.ensure(len(format)); // a good starting size
	end := len(format) - 1;
	fieldnum := 0; // we process one field per non-trivial format
	for i := 0; i <= end; {
	c, w := utf8.DecodeRuneInString(format[i:len(format)]);
	if c != '%' \|\| i == end {
	p.add(c);
	i += w;
	continue;
	}
	i++;
	// flags and widths
	p.fmt.clearflags();
	F: for ; i < end; i++ {
	switch format[i] {
	case '#':
	p.fmt.sharp = true;
	case '0':
	p.fmt.zero = true;
	case '+':
	p.fmt.plus = true;
	case '-':
	p.fmt.minus = true;
	case ' ':
	p.fmt.space = true;
	default:
	break F;
	}
	}
	// do we have 20 (width)?
	p.fmt.wid, p.fmt.wid_present, i = parsenum(format, i, end);
	// do we have .20 (precision)?
	if i < end && format[i] == '.' {
	p.fmt.prec, p.fmt.prec_present, i = parsenum(format, i+1, end);
	}
	c, w = utf8.DecodeRuneInString(format[i:len(format)]);
	i += w;
	// percent is special - absorbs no operand
	if c == '%' {
	p.add('%'); // TODO: should we bother with width & prec?
	continue;
	}
	if fieldnum >= v.Len() { // out of operands
	p.add('%');
	p.add(c);
	p.addstr("(missing)");
	continue;
	}
	field := getField(v, fieldnum);
	fieldnum++;
	inter := field.Interface();
	if inter != nil && c != 'T' { // don't want thing to describe itself if we're asking for its type
	if formatter, ok := inter.(Formatter); ok {
	formatter.Format(p, c);
	continue;
	}
	}
	s := "";
	switch c {
	// bool
	case 't':
	if v, ok := getBool(field); ok {
	if v {
	s = "true";
	} else {
	s = "false";
	}
	} else {
	goto badtype;
	}

	// int
	case 'b':
	if v, signed, ok := getInt(field); ok {
	s = p.fmt.Fmt_b64(uint64(v)).Str() // always unsigned
	} else if v, ok := getFloat32(field); ok {
	s = p.fmt.Fmt_fb32(v).Str()
	} else if v, ok := getFloat64(field); ok {
	s = p.fmt.Fmt_fb64(v).Str()
	} else {
	goto badtype
	}
	case 'c':
	if v, signed, ok := getInt(field); ok {
	s = p.fmt.Fmt_c(int(v)).Str()
	} else {
	goto badtype
	}
	case 'd':
	if v, signed, ok := getInt(field); ok {
	if signed {
	s = p.fmt.Fmt_d64(v).Str()
	} else {
	s = p.fmt.Fmt_ud64(uint64(v)).Str()
	}
	} else {
	goto badtype
	}
	case 'o':
	if v, signed, ok := getInt(field); ok {
	if signed {
	s = p.fmt.Fmt_o64(v).Str()
	} else {
	s = p.fmt.Fmt_uo64(uint64(v)).Str()
	}
	} else {
	goto badtype
	}
	case 'x':
	if v, signed, ok := getInt(field); ok {
	if signed {
	s = p.fmt.Fmt_x64(v).Str()
	} else {
	s = p.fmt.Fmt_ux64(uint64(v)).Str()
	}
	} else if v, ok := getString(field); ok {
	s = p.fmt.Fmt_sx(v).Str();
	} else {
	goto badtype
	}
	case 'X':
	if v, signed, ok := getInt(field); ok {
	if signed {
	s = p.fmt.Fmt_X64(v).Str()
	} else {
	s = p.fmt.Fmt_uX64(uint64(v)).Str()
	}
	} else if v, ok := getString(field); ok {
	s = p.fmt.Fmt_sX(v).Str();
	} else {
	goto badtype
	}

	// float
	case 'e':
	if v, ok := getFloat32(field); ok {
	s = p.fmt.Fmt_e32(v).Str()
	} else if v, ok := getFloat64(field); ok {
	s = p.fmt.Fmt_e64(v).Str()
	} else {
	goto badtype
	}
	case 'f':
	if v, ok := getFloat32(field); ok {
	s = p.fmt.Fmt_f32(v).Str()
	} else if v, ok := getFloat64(field); ok {
	s = p.fmt.Fmt_f64(v).Str()
	} else {
	goto badtype
	}
	case 'g':
	if v, ok := getFloat32(field); ok {
	s = p.fmt.Fmt_g32(v).Str()
	} else if v, ok := getFloat64(field); ok {
	s = p.fmt.Fmt_g64(v).Str()
	} else {
	goto badtype
	}

	// string
	case 's':
	if inter != nil {
	// if object implements String, use the result.
	if stringer, ok := inter.(Stringer); ok {
	s = p.fmt.Fmt_s(stringer.String()).Str();
	break;
	}
	}
	if v, ok := getString(field); ok {
	s = p.fmt.Fmt_s(v).Str()
	} else {
	goto badtype
	}
	case 'q':
	if v, ok := getString(field); ok {
	s = p.fmt.Fmt_q(v).Str()
	} else {
	goto badtype
	}

	// pointer
	case 'p':
	if v, ok := getPtr(field); ok {
	if v == 0 {
	s = "<nil>"
	} else {
	s = "0x" + p.fmt.Fmt_uX64(uint64(v)).Str()
	}
	} else {
	goto badtype
	}

	// arbitrary value; do your best
	case 'v':
	p.printField(field);

	// the value's type
	case 'T':
	s = field.Type().String();

	default:
	badtype:
	s = "%" + string(c) + "(" + field.Type().String() + ")%";
	}
	p.addstr(s);
	}
	if fieldnum < v.Len() {
	p.addstr("?(extra ");
	for ; fieldnum < v.Len(); fieldnum++ {
	p.addstr(getField(v, fieldnum).Type().String());
	if fieldnum + 1 < v.Len() {
	p.addstr(", ");
	}
	}
	p.addstr(")");
	}
	}

	func (p *pp) doprint(v reflect.StructValue, addspace, addnewline bool) {
	prev_string := false;
	for fieldnum := 0; fieldnum < v.Len(); fieldnum++ {
	// always add spaces if we're doing println
	field := getField(v, fieldnum);
	if fieldnum > 0 {
	if addspace {
	p.add(' ')
	} else if field.Kind() != reflect.StringKind && !prev_string{
	// if not doing println, add spaces if neither side is a string
	p.add(' ')
	}
	}
	was_string := p.printField(field);
	prev_string = was_string;
	}
	if addnewline {
	p.add('\n')
	}
	}