summaryrefslogtreecommitdiff
path: root/src/pkg/fmt/print.go
diff options
context:
space:
mode:
Diffstat (limited to 'src/pkg/fmt/print.go')
-rw-r--r--src/pkg/fmt/print.go410
1 files changed, 205 insertions, 205 deletions
diff --git a/src/pkg/fmt/print.go b/src/pkg/fmt/print.go
index 6fa747c29..d4ef3c62f 100644
--- a/src/pkg/fmt/print.go
+++ b/src/pkg/fmt/print.go
@@ -77,25 +77,25 @@ package fmt
import (
- "bytes";
- "io";
- "os";
- "reflect";
- "utf8";
+ "bytes"
+ "io"
+ "os"
+ "reflect"
+ "utf8"
)
// Some constants in the form of bytes, to avoid string overhead.
// Needlessly fastidious, I suppose.
var (
- trueBytes = []byte{'t', 'r', 'u', 'e'};
- falseBytes = []byte{'f', 'a', 'l', 's', 'e'};
- commaSpaceBytes = []byte{',', ' '};
- nilAngleBytes = []byte{'<', 'n', 'i', 'l', '>'};
- nilParenBytes = []byte{'(', 'n', 'i', 'l', ')'};
- nilBytes = []byte{'n', 'i', 'l'};
- mapBytes = []byte{'m', 'a', 'p', '['};
- missingBytes = []byte{'m', 'i', 's', 's', 'i', 'n', 'g'};
- extraBytes = []byte{'?', '(', 'e', 'x', 't', 'r', 'a', ' '};
+ trueBytes = []byte{'t', 'r', 'u', 'e'}
+ falseBytes = []byte{'f', 'a', 'l', 's', 'e'}
+ commaSpaceBytes = []byte{',', ' '}
+ nilAngleBytes = []byte{'<', 'n', 'i', 'l', '>'}
+ nilParenBytes = []byte{'(', 'n', 'i', 'l', ')'}
+ nilBytes = []byte{'n', 'i', 'l'}
+ mapBytes = []byte{'m', 'a', 'p', '['}
+ missingBytes = []byte{'m', 'i', 's', 's', 'i', 'n', 'g'}
+ extraBytes = []byte{'?', '(', 'e', 'x', 't', 'r', 'a', ' '}
)
// State represents the printer state passed to custom formatters.
@@ -103,21 +103,21 @@ var (
// 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);
+ 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);
+ Width() (wid int, ok bool)
// Precision returns the value of the precision option and whether it has been set.
- Precision() (prec int, ok bool);
+ Precision() (prec int, ok bool)
// Flag returns whether the flag c, a character, has been set.
- Flag(int) bool;
+ Flag(int) bool
}
// Formatter is the interface implemented by values 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);
+ Format(f State, c int)
}
// Stringer is implemented by any value that has a String method(),
@@ -125,7 +125,7 @@ type Formatter interface {
// The String method is used to print values passed as an operand
// to a %s or %v format or to an unformatted printer such as Print.
type Stringer interface {
- String() string;
+ String() string
}
// GoStringer is implemented by any value that has a GoString() method,
@@ -133,16 +133,16 @@ type Stringer interface {
// The GoString method is used to print values passed as an operand
// to a %#v format.
type GoStringer interface {
- GoString() string;
+ GoString() string
}
const allocSize = 32
type pp struct {
- n int;
- buf bytes.Buffer;
- runeBuf [utf8.UTFMax]byte;
- fmt fmt;
+ n int
+ buf bytes.Buffer
+ runeBuf [utf8.UTFMax]byte
+ fmt fmt
}
// A leaky bucket of reusable pp structures.
@@ -150,12 +150,12 @@ var ppFree = make(chan *pp, 100)
// Allocate a new pp struct. Probably can grab the previous one from ppFree.
func newPrinter() *pp {
- p, ok := <-ppFree;
+ p, ok := <-ppFree
if !ok {
p = new(pp)
}
- p.fmt.init(&p.buf);
- return p;
+ p.fmt.init(&p.buf)
+ return p
}
// Save used pp structs in ppFree; avoids an allocation per invocation.
@@ -164,13 +164,13 @@ func (p *pp) free() {
if cap(p.buf.Bytes()) > 1024 {
return
}
- p.buf.Reset();
- _ = ppFree <- p;
+ p.buf.Reset()
+ _ = ppFree <- p
}
-func (p *pp) Width() (wid int, ok bool) { return p.fmt.wid, p.fmt.widPresent }
+func (p *pp) Width() (wid int, ok bool) { return p.fmt.wid, p.fmt.widPresent }
-func (p *pp) Precision() (prec int, ok bool) { return p.fmt.prec, p.fmt.precPresent }
+func (p *pp) Precision() (prec int, ok bool) { return p.fmt.prec, p.fmt.precPresent }
func (p *pp) Flag(b int) bool {
switch b {
@@ -185,15 +185,15 @@ func (p *pp) Flag(b int) bool {
case '0':
return p.fmt.zero
}
- return false;
+ return false
}
func (p *pp) add(c int) {
if c < utf8.RuneSelf {
p.buf.WriteByte(byte(c))
} else {
- w := utf8.EncodeRune(c, &p.runeBuf);
- p.buf.Write(p.runeBuf[0:w]);
+ w := utf8.EncodeRune(c, &p.runeBuf)
+ p.buf.Write(p.runeBuf[0:w])
}
}
@@ -207,28 +207,28 @@ func (p *pp) Write(b []byte) (ret int, err os.Error) {
// 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);
- n64, error := p.buf.WriteTo(w);
- p.free();
- return int(n64), error;
+ v := reflect.NewValue(a).(*reflect.StructValue)
+ p := newPrinter()
+ p.doprintf(format, v)
+ n64, error := p.buf.WriteTo(w)
+ p.free()
+ return int(n64), 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;
+ 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 := p.buf.String();
- p.free();
- return s;
+ v := reflect.NewValue(a).(*reflect.StructValue)
+ p := newPrinter()
+ p.doprintf(format, v)
+ s := p.buf.String()
+ p.free()
+ return s
}
// These routines do not take a format string
@@ -236,30 +236,30 @@ func Sprintf(format string, a ...) 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);
- n64, error := p.buf.WriteTo(w);
- p.free();
- return int(n64), error;
+ v := reflect.NewValue(a).(*reflect.StructValue)
+ p := newPrinter()
+ p.doprint(v, false, false)
+ n64, error := p.buf.WriteTo(w)
+ p.free()
+ return int(n64), 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;
+ 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 := p.buf.String();
- p.free();
- return s;
+ v := reflect.NewValue(a).(*reflect.StructValue)
+ p := newPrinter()
+ p.doprint(v, false, false)
+ s := p.buf.String()
+ p.free()
+ return s
}
// These routines end in 'ln', do not take a format string,
@@ -269,30 +269,30 @@ func Sprint(a ...) string {
// 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);
- n64, error := p.buf.WriteTo(w);
- p.free();
- return int(n64), error;
+ v := reflect.NewValue(a).(*reflect.StructValue)
+ p := newPrinter()
+ p.doprint(v, true, true)
+ n64, error := p.buf.WriteTo(w)
+ p.free()
+ return int(n64), 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;
+ 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 := p.buf.String();
- p.free();
- return s;
+ v := reflect.NewValue(a).(*reflect.StructValue)
+ p := newPrinter()
+ p.doprint(v, true, true)
+ s := p.buf.String()
+ p.free()
+ return s
}
@@ -300,13 +300,13 @@ func Sprintln(a ...) string {
// 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);
+ val := v.Field(i)
if i, ok := val.(*reflect.InterfaceValue); ok {
if inter := i.Interface(); inter != nil {
return reflect.NewValue(inter)
}
}
- return val;
+ return val
}
// Getters for the fields of the argument structure.
@@ -315,7 +315,7 @@ func getBool(v reflect.Value) (val bool, ok bool) {
if b, ok := v.(*reflect.BoolValue); ok {
return b.Get(), true
}
- return;
+ return
}
func getInt(v reflect.Value) (val int64, signed, ok bool) {
@@ -343,7 +343,7 @@ func getInt(v reflect.Value) (val int64, signed, ok bool) {
case *reflect.UintptrValue:
return int64(v.Get()), false, true
}
- return;
+ return
}
func getString(v reflect.Value) (val string, ok bool) {
@@ -353,7 +353,7 @@ func getString(v reflect.Value) (val string, ok bool) {
if bytes, ok := v.Interface().([]byte); ok {
return string(bytes), true
}
- return;
+ return
}
func getFloat32(v reflect.Value) (val float32, ok bool) {
@@ -365,7 +365,7 @@ func getFloat32(v reflect.Value) (val float32, ok bool) {
return float32(v.Get()), true
}
}
- return;
+ return
}
func getFloat64(v reflect.Value) (val float64, ok bool) {
@@ -377,7 +377,7 @@ func getFloat64(v reflect.Value) (val float64, ok bool) {
case *reflect.Float64Value:
return float64(v.Get()), true
}
- return;
+ return
}
func getPtr(v reflect.Value) (val uintptr, ok bool) {
@@ -385,7 +385,7 @@ func getPtr(v reflect.Value) (val uintptr, ok bool) {
case *reflect.PtrValue:
return uintptr(v.Get()), true
}
- return;
+ return
}
// Convert ASCII to integer. n is 0 (and got is false) if no number present.
@@ -394,33 +394,33 @@ func parsenum(s string, start, end int) (n int, got bool, newi int) {
if start >= end {
return 0, false, end
}
- isnum := false;
- num := 0;
+ isnum := false
+ num := 0
for '0' <= s[start] && s[start] <= '9' {
- num = num*10 + int(s[start]-'0');
- start++;
- isnum = true;
+ num = num*10 + int(s[start]-'0')
+ start++
+ isnum = true
}
- return num, isnum, start;
+ return num, isnum, start
}
type uintptrGetter interface {
- Get() uintptr;
+ Get() uintptr
}
func (p *pp) printField(field reflect.Value, plus, sharp bool, depth int) (was_string bool) {
- inter := field.Interface();
+ inter := field.Interface()
if inter != nil {
switch {
default:
if stringer, ok := inter.(Stringer); ok {
- p.buf.WriteString(stringer.String());
- return false; // this value is not a string
+ p.buf.WriteString(stringer.String())
+ return false // this value is not a string
}
case sharp:
if stringer, ok := inter.(GoStringer); ok {
- p.buf.WriteString(stringer.GoString());
- return false; // this value is not a string
+ p.buf.WriteString(stringer.GoString())
+ return false // this value is not a string
}
}
}
@@ -442,17 +442,17 @@ BigSwitch:
if sharp {
p.fmt.fmt_q(f.Get())
} else {
- p.fmt.fmt_s(f.Get());
- was_string = true;
+ p.fmt.fmt_s(f.Get())
+ was_string = true
}
case *reflect.MapValue:
if sharp {
- p.buf.WriteString(field.Type().String());
- p.buf.WriteByte('{');
+ p.buf.WriteString(field.Type().String())
+ p.buf.WriteByte('{')
} else {
p.buf.Write(mapBytes)
}
- keys := f.Keys();
+ keys := f.Keys()
for i, key := range keys {
if i > 0 {
if sharp {
@@ -461,9 +461,9 @@ BigSwitch:
p.buf.WriteByte(' ')
}
}
- p.printField(key, plus, sharp, depth+1);
- p.buf.WriteByte(':');
- p.printField(f.Elem(key), plus, sharp, depth+1);
+ p.printField(key, plus, sharp, depth+1)
+ p.buf.WriteByte(':')
+ p.printField(f.Elem(key), plus, sharp, depth+1)
}
if sharp {
p.buf.WriteByte('}')
@@ -474,10 +474,10 @@ BigSwitch:
if sharp {
p.buf.WriteString(field.Type().String())
}
- p.add('{');
- v := f;
- t := v.Type().(*reflect.StructType);
- p.fmt.clearflags(); // clear flags for p.printField
+ p.add('{')
+ v := f
+ t := v.Type().(*reflect.StructType)
+ p.fmt.clearflags() // clear flags for p.printField
for i := 0; i < v.NumField(); i++ {
if i > 0 {
if sharp {
@@ -488,19 +488,19 @@ BigSwitch:
}
if plus || sharp {
if f := t.Field(i); f.Name != "" {
- p.buf.WriteString(f.Name);
- p.buf.WriteByte(':');
+ p.buf.WriteString(f.Name)
+ p.buf.WriteByte(':')
}
}
- p.printField(getField(v, i), plus, sharp, depth+1);
+ p.printField(getField(v, i), plus, sharp, depth+1)
}
- p.buf.WriteByte('}');
+ p.buf.WriteByte('}')
case *reflect.InterfaceValue:
- value := f.Elem();
+ value := f.Elem()
if value == nil {
if sharp {
- p.buf.WriteString(field.Type().String());
- p.buf.Write(nilParenBytes);
+ p.buf.WriteString(field.Type().String())
+ p.buf.Write(nilParenBytes)
} else {
p.buf.Write(nilAngleBytes)
}
@@ -509,8 +509,8 @@ BigSwitch:
}
case reflect.ArrayOrSliceValue:
if sharp {
- p.buf.WriteString(field.Type().String());
- p.buf.WriteByte('{');
+ p.buf.WriteString(field.Type().String())
+ p.buf.WriteByte('{')
} else {
p.buf.WriteByte('[')
}
@@ -522,7 +522,7 @@ BigSwitch:
p.buf.WriteByte(' ')
}
}
- p.printField(f.Elem(i), plus, sharp, depth+1);
+ p.printField(f.Elem(i), plus, sharp, depth+1)
}
if sharp {
p.buf.WriteByte('}')
@@ -530,99 +530,99 @@ BigSwitch:
p.buf.WriteByte(']')
}
case *reflect.PtrValue:
- v := f.Get();
+ v := f.Get()
// pointer to array or slice or struct? ok at top level
// but not embedded (avoid loops)
if v != 0 && depth == 0 {
switch a := f.Elem().(type) {
case reflect.ArrayOrSliceValue:
- p.buf.WriteByte('&');
- p.printField(a, plus, sharp, depth+1);
- break BigSwitch;
+ p.buf.WriteByte('&')
+ p.printField(a, plus, sharp, depth+1)
+ break BigSwitch
case *reflect.StructValue:
- p.buf.WriteByte('&');
- p.printField(a, plus, sharp, depth+1);
- break BigSwitch;
+ p.buf.WriteByte('&')
+ p.printField(a, plus, sharp, depth+1)
+ break BigSwitch
}
}
if sharp {
- p.buf.WriteByte('(');
- p.buf.WriteString(field.Type().String());
- p.buf.WriteByte(')');
- p.buf.WriteByte('(');
+ p.buf.WriteByte('(')
+ p.buf.WriteString(field.Type().String())
+ p.buf.WriteByte(')')
+ p.buf.WriteByte('(')
if v == 0 {
p.buf.Write(nilBytes)
} else {
- p.fmt.sharp = true;
- p.fmt.fmt_ux64(uint64(v));
+ p.fmt.sharp = true
+ p.fmt.fmt_ux64(uint64(v))
}
- p.buf.WriteByte(')');
- break;
+ p.buf.WriteByte(')')
+ break
}
if v == 0 {
- p.buf.Write(nilAngleBytes);
- break;
+ p.buf.Write(nilAngleBytes)
+ break
}
- p.fmt.sharp = true; // turn 0x on
- p.fmt.fmt_ux64(uint64(v));
+ p.fmt.sharp = true // turn 0x on
+ p.fmt.fmt_ux64(uint64(v))
case uintptrGetter:
- v := f.Get();
+ v := f.Get()
if sharp {
- p.buf.WriteByte('(');
- p.buf.WriteString(field.Type().String());
- p.buf.WriteByte(')');
- p.buf.WriteByte('(');
+ p.buf.WriteByte('(')
+ p.buf.WriteString(field.Type().String())
+ p.buf.WriteByte(')')
+ p.buf.WriteByte('(')
if v == 0 {
p.buf.Write(nilBytes)
} else {
- p.fmt.sharp = true;
- p.fmt.fmt_ux64(uint64(v));
+ p.fmt.sharp = true
+ p.fmt.fmt_ux64(uint64(v))
}
- p.buf.WriteByte(')');
+ p.buf.WriteByte(')')
} else {
- p.fmt.sharp = true; // turn 0x on
- p.fmt.fmt_ux64(uint64(f.Get()));
+ p.fmt.sharp = true // turn 0x on
+ p.fmt.fmt_ux64(uint64(f.Get()))
}
default:
- v, signed, ok := getInt(field);
+ v, signed, ok := getInt(field)
if ok {
if signed {
p.fmt.fmt_d64(v)
} else {
if sharp {
- p.fmt.sharp = true; // turn on 0x
- p.fmt.fmt_ux64(uint64(v));
+ p.fmt.sharp = true // turn on 0x
+ p.fmt.fmt_ux64(uint64(v))
} else {
p.fmt.fmt_ud64(uint64(v))
}
}
- break;
+ break
}
- p.buf.WriteByte('?');
- p.buf.WriteString(field.Type().String());
- p.buf.WriteByte('?');
+ p.buf.WriteByte('?')
+ p.buf.WriteString(field.Type().String())
+ p.buf.WriteByte('?')
}
- return was_string;
+ return was_string
}
func (p *pp) doprintf(format string, v *reflect.StructValue) {
- end := len(format) - 1;
- fieldnum := 0; // we process one field per non-trivial format
+ 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:]);
+ c, w := utf8.DecodeRuneInString(format[i:])
if c != '%' || i == end {
if w == 1 {
p.buf.WriteByte(byte(c))
} else {
p.buf.WriteString(format[i : i+w])
}
- i += w;
- continue;
+ i += w
+ continue
}
- i++;
+ i++
// flags and widths
- p.fmt.clearflags();
- F: for ; i < end; i++ {
+ p.fmt.clearflags()
+ F: for ; i < end; i++ {
switch format[i] {
case '#':
p.fmt.sharp = true
@@ -639,34 +639,34 @@ func (p *pp) doprintf(format string, v *reflect.StructValue) {
}
}
// do we have 20 (width)?
- p.fmt.wid, p.fmt.widPresent, i = parsenum(format, i, end);
+ p.fmt.wid, p.fmt.widPresent, i = parsenum(format, i, end)
// do we have .20 (precision)?
if i < end && format[i] == '.' {
p.fmt.prec, p.fmt.precPresent, i = parsenum(format, i+1, end)
}
- c, w = utf8.DecodeRuneInString(format[i:]);
- i += w;
+ c, w = utf8.DecodeRuneInString(format[i:])
+ i += w
// percent is special - absorbs no operand
if c == '%' {
- p.buf.WriteByte('%'); // TODO: should we bother with width & prec?
- continue;
+ p.buf.WriteByte('%') // TODO: should we bother with width & prec?
+ continue
}
- if fieldnum >= v.NumField() { // out of operands
- p.buf.WriteByte('%');
- p.add(c);
- p.buf.Write(missingBytes);
- continue;
+ if fieldnum >= v.NumField() { // out of operands
+ p.buf.WriteByte('%')
+ p.add(c)
+ p.buf.Write(missingBytes)
+ continue
}
- field := getField(v, fieldnum);
- fieldnum++;
+ field := getField(v, fieldnum)
+ fieldnum++
// Try formatter except for %T,
// which is special and handled internally.
- inter := field.Interface();
+ inter := field.Interface()
if inter != nil && c != 'T' {
if formatter, ok := inter.(Formatter); ok {
- formatter.Format(p, c);
- continue;
+ formatter.Format(p, c)
+ continue
}
}
@@ -686,7 +686,7 @@ 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)
} else if v, ok := getFloat64(field); ok {
@@ -792,8 +792,8 @@ 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());
- break;
+ p.fmt.fmt_s(stringer.String())
+ break
}
}
if v, ok := getString(field); ok {
@@ -814,8 +814,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
@@ -823,10 +823,10 @@ func (p *pp) doprintf(format string, v *reflect.StructValue) {
// arbitrary value; do your best
case 'v':
- plus, sharp := p.fmt.plus, p.fmt.sharp;
- p.fmt.plus = false;
- p.fmt.sharp = false;
- p.printField(field, plus, sharp, 0);
+ plus, sharp := p.fmt.plus, p.fmt.sharp
+ p.fmt.plus = false
+ p.fmt.sharp = false
+ p.printField(field, plus, sharp, 0)
// the value's type
case 'T':
@@ -834,42 +834,42 @@ func (p *pp) doprintf(format string, v *reflect.StructValue) {
default:
badtype:
- p.buf.WriteByte('%');
- p.add(c);
- p.buf.WriteByte('(');
- p.buf.WriteString(field.Type().String());
- p.buf.WriteByte('=');
- p.printField(field, false, false, 0);
- p.buf.WriteByte(')');
+ p.buf.WriteByte('%')
+ p.add(c)
+ p.buf.WriteByte('(')
+ p.buf.WriteString(field.Type().String())
+ p.buf.WriteByte('=')
+ p.printField(field, false, false, 0)
+ p.buf.WriteByte(')')
}
}
if fieldnum < v.NumField() {
- p.buf.Write(extraBytes);
+ p.buf.Write(extraBytes)
for ; fieldnum < v.NumField(); fieldnum++ {
- field := getField(v, fieldnum);
- p.buf.WriteString(field.Type().String());
- p.buf.WriteByte('=');
- p.printField(field, false, false, 0);
+ field := getField(v, fieldnum)
+ p.buf.WriteString(field.Type().String())
+ p.buf.WriteByte('=')
+ p.printField(field, false, false, 0)
if fieldnum+1 < v.NumField() {
p.buf.Write(commaSpaceBytes)
}
}
- p.buf.WriteByte(')');
+ p.buf.WriteByte(')')
}
}
func (p *pp) doprint(v *reflect.StructValue, addspace, addnewline bool) {
- prev_string := false;
+ prev_string := false
for fieldnum := 0; fieldnum < v.NumField(); fieldnum++ {
// always add spaces if we're doing println
- field := getField(v, fieldnum);
+ field := getField(v, fieldnum)
if fieldnum > 0 {
- _, is_string := field.(*reflect.StringValue);
+ _, is_string := field.(*reflect.StringValue)
if addspace || !is_string && !prev_string {
p.buf.WriteByte(' ')
}
}
- prev_string = p.printField(field, false, false, 0);
+ prev_string = p.printField(field, false, false, 0)
}
if addnewline {
p.buf.WriteByte('\n')
generated by cgit v1.2.3 (git 2.46.0) at 2025-10-25 15:49:30 +0000