a += uint32(p[i]);
b += a;
// invariant: a <= b
- if b > (0xffffffff - 255)/2 {
+ if b > (0xffffffff-255)/2 {
a %= mod;
b %= mod;
// invariant: a < mod && b < mod
func (d *digest) Sum() []byte {
p := make([]byte, 4);
s := d.Sum32();
- p[0] = byte(s>>24);
- p[1] = byte(s>>16);
- p[2] = byte(s>>8);
+ p[0] = byte(s >> 24);
+ p[1] = byte(s >> 16);
+ p[2] = byte(s >> 8);
p[3] = byte(s);
return p;
}
crc := uint32(i);
for j := 0; j < 8; j++ {
if crc&1 == 1 {
- crc = (crc>>1)^poly
+ crc = (crc >> 1) ^ poly
} else {
crc >>= 1
}
func update(crc uint32, tab *Table, p []byte) uint32 {
crc = ^crc;
for i := 0; i < len(p); i++ {
- crc = tab[byte(crc)^p[i]]^(crc>>8)
+ crc = tab[byte(crc)^p[i]] ^ (crc >> 8)
}
return ^crc;
}
func (d *digest) Sum() []byte {
p := make([]byte, 4);
s := d.Sum32();
- p[0] = byte(s>>24);
- p[1] = byte(s>>16);
- p[2] = byte(s>>8);
+ p[0] = byte(s >> 24);
+ p[1] = byte(s >> 16);
+ p[2] = byte(s >> 8);
p[3] = byte(s);
return p;
}
if len(f) < 3 {
return nil, &badStringError{"malformed HTTP response", line}
}
- resp.Status = f[1]+" "+f[2];
+ resp.Status = f[1] + " " + f[2];
resp.StatusCode, err = strconv.Atoi(f[1]);
if err != nil {
return nil, &badStringError{"malformed HTTP status code", f[1]}
const indexPage = "/index.html";
// redirect to strip off any index.html
- n := len(name)-len(indexPage);
+ n := len(name) - len(indexPage);
if n >= 0 && name[n:len(name)] == indexPage {
- Redirect(c, name[0 : n+1], StatusMovedPermanently);
+ Redirect(c, name[0:n+1], StatusMovedPermanently);
return;
}
}
} else {
if url[len(url)-1] == '/' {
- Redirect(c, url[0 : len(url)-1], StatusMovedPermanently);
+ Redirect(c, url[0:len(url)-1], StatusMovedPermanently);
return;
}
}
return;
}
path = path[len(f.prefix):len(path)];
- serveFileInternal(c, r, f.root + "/" + path, true);
+ serveFileInternal(c, r, f.root+"/"+path, true);
}
maxLineLength = 1024; // assumed < bufio.DefaultBufSize
maxValueLength = 1024;
maxHeaderLines = 1024;
- chunkSize = 4<<10; // 4 KB chunks
+ chunkSize = 4 << 10; // 4 KB chunks
)
// HTTP request parsing errors.
if line, e = readLineBytes(b); e != nil {
return "", "", e
}
- value += " "+string(line);
+ value += " " + string(line);
if len(value) >= maxValueLength {
return "", "", &badStringError{"value too long for key", key}
upper := true;
for i, v := range a {
if upper && 'a' <= v && v <= 'z' {
- a[i] = v+'A'-'a'
+ a[i] = v + 'A' - 'a'
}
if !upper && 'A' <= v && v <= 'Z' {
- a[i] = v+'a'-'A'
+ a[i] = v + 'a' - 'A'
}
upper = false;
if v == '-' {
}
}
if uint64(len(b)) > cr.n {
- b = b[0 : cr.n]
+ b = b[0:cr.n]
}
n, cr.err = cr.r.Read(b);
cr.n -= uint64(n);
// to concatenating the values separated by commas.
oldvalue, present := req.Header[key];
if present {
- req.Header[key] = oldvalue+","+value
+ req.Header[key] = oldvalue + "," + value
} else {
req.Header[key] = value
}
if !ok {
text = "status code " + codestring
}
- io.WriteString(c.buf, proto + " " + codestring + " " + text + "\r\n");
+ io.WriteString(c.buf, proto+" "+codestring+" "+text+"\r\n");
for k, v := range c.header {
io.WriteString(c.buf, k+": "+v+"\r\n")
}
if url == "" || url[0] != '/' {
// make relative path absolute
olddir, _ := path.Split(oldpath);
- url = olddir+url;
+ url = olddir + url;
}
// clean up but preserve trailing slash
return "/"
}
if p[0] != '/' {
- p = "/"+p
+ p = "/" + p
}
np := path.Clean(p);
// path.Clean removes trailing slash except for root;
// If pattern is /tree/, insert permanent redirect for /tree.
n := len(pattern);
if n > 0 && pattern[n-1] == '/' {
- mux.m[pattern[0 : n-1]] = RedirectHandler(pattern, StatusMovedPermanently)
+ mux.m[pattern[0:n-1]] = RedirectHandler(pattern, StatusMovedPermanently)
}
}
func unhex(c byte) byte {
switch {
case '0' <= c && c <= '9':
- return c-'0'
+ return c - '0'
case 'a' <= c && c <= 'f':
- return c-'a'+10
+ return c - 'a' + 10
case 'A' <= c && c <= 'F':
- return c-'A'+10
+ return c - 'A' + 10
}
return 0;
}
return s, nil
}
- t := make([]byte, len(s) - 2*n);
+ t := make([]byte, len(s)-2*n);
j := 0;
for i := 0; i < len(s); {
switch s[i] {
return s
}
- t := make([]byte, len(s) + 2*hexCount);
+ t := make([]byte, len(s)+2*hexCount);
j := 0;
for i := 0; i < len(s); i++ {
switch c := s[i]; {
func (c RGBAColor) RGBA() (r, g, b, a uint32) {
r = uint32(c.R);
- r |= r<<8;
- r |= r<<16;
+ r |= r << 8;
+ r |= r << 16;
g = uint32(c.G);
- g |= g<<8;
- g |= g<<16;
+ g |= g << 8;
+ g |= g << 16;
b = uint32(c.B);
- b |= b<<8;
- b |= b<<16;
+ b |= b << 8;
+ b |= b << 16;
a = uint32(c.A);
- a |= a<<8;
- a |= a<<16;
+ a |= a << 8;
+ a |= a << 16;
return;
}
func (c RGBA64Color) RGBA() (r, g, b, a uint32) {
r = uint32(c.R);
- r |= r<<16;
+ r |= r << 16;
g = uint32(c.G);
- g |= g<<16;
+ g |= g << 16;
b = uint32(c.B);
- b |= b<<16;
+ b |= b << 16;
a = uint32(c.A);
- a |= a<<16;
+ a |= a << 16;
return;
}
func (c NRGBAColor) RGBA() (r, g, b, a uint32) {
r = uint32(c.R);
- r |= r<<8;
+ r |= r << 8;
r *= uint32(c.A);
r /= 0xff;
- r |= r<<16;
+ r |= r << 16;
g = uint32(c.G);
- g |= g<<8;
+ g |= g << 8;
g *= uint32(c.A);
g /= 0xff;
- g |= g<<16;
+ g |= g << 16;
b = uint32(c.B);
- b |= b<<8;
+ b |= b << 8;
b *= uint32(c.A);
b /= 0xff;
- b |= b<<16;
+ b |= b << 16;
a = uint32(c.A);
- a |= a<<8;
- a |= a<<16;
+ a |= a << 8;
+ a |= a << 16;
return;
}
r = uint32(c.R);
r *= uint32(c.A);
r /= 0xffff;
- r |= r<<16;
+ r |= r << 16;
g = uint32(c.G);
g *= uint32(c.A);
g /= 0xffff;
- g |= g<<16;
+ g |= g << 16;
b = uint32(c.B);
b *= uint32(c.A);
b /= 0xffff;
- b |= b<<16;
+ b |= b << 16;
a = uint32(c.A);
- a |= a<<8;
- a |= a<<16;
+ a |= a << 8;
+ a |= a << 16;
return;
}
return c
}
r, g, b, a := c.RGBA();
- return RGBAColor{uint8(r>>24), uint8(g>>24), uint8(b>>24), uint8(a>>24)};
+ return RGBAColor{uint8(r >> 24), uint8(g >> 24), uint8(b >> 24), uint8(a >> 24)};
}
func toRGBA64Color(c Color) Color {
return c
}
r, g, b, a := c.RGBA();
- return RGBA64Color{uint16(r>>16), uint16(g>>16), uint16(b>>16), uint16(a>>16)};
+ return RGBA64Color{uint16(r >> 16), uint16(g >> 16), uint16(b >> 16), uint16(a >> 16)};
}
func toNRGBAColor(c Color) Color {
r, g, b, a := c.RGBA();
a >>= 16;
if a == 0xffff {
- return NRGBAColor{uint8(r>>24), uint8(g>>24), uint8(b>>24), 0xff}
+ return NRGBAColor{uint8(r >> 24), uint8(g >> 24), uint8(b >> 24), 0xff}
}
if a == 0 {
return NRGBAColor{0, 0, 0, 0}
g >>= 16;
b >>= 16;
// Since Color.RGBA returns a alpha-premultiplied color, we should have r <= a && g <= a && b <= a.
- r = (r*0xffff)/a;
- g = (g*0xffff)/a;
- b = (b*0xffff)/a;
- return NRGBAColor{uint8(r>>8), uint8(g>>8), uint8(b>>8), uint8(a>>8)};
+ r = (r * 0xffff) / a;
+ g = (g * 0xffff) / a;
+ b = (b * 0xffff) / a;
+ return NRGBAColor{uint8(r >> 8), uint8(g >> 8), uint8(b >> 8), uint8(a >> 8)};
}
func toNRGBA64Color(c Color) Color {
return NRGBA64Color{0, 0, 0, 0}
}
// Since Color.RGBA returns a alpha-premultiplied color, we should have r <= a && g <= a && b <= a.
- r = (r*0xffff)/a;
- g = (g*0xffff)/a;
- b = (b*0xffff)/a;
+ r = (r * 0xffff) / a;
+ g = (g * 0xffff) / a;
+ b = (b * 0xffff) / a;
return NRGBA64Color{uint16(r), uint16(g), uint16(b), uint16(a)};
}
func diff(a, b uint32) uint32 {
if a > b {
- return a-b
+ return a - b
}
- return b-a;
+ return b - a;
}
// Convert returns the palette color closest to c in Euclidean R,G,B space.
vg >>= 17;
vb >>= 17;
dr, dg, db := diff(cr, vr), diff(cg, vg), diff(cb, vb);
- ssd := (dr*dr)+(dg*dg)+(db*db);
+ ssd := (dr * dr) + (dg * dg) + (db * db);
if ssd < bestSSD {
bestSSD = ssd;
result = v;
stage int;
idatWriter io.WriteCloser;
idatDone chan os.Error;
- tmp [3*256]byte;
+ tmp [3 * 256]byte;
}
// A FormatError reports that the input is not a valid PNG.
if w < 0 || h < 0 {
return FormatError("negative dimension")
}
- nPixels := int64(w)*int64(h);
+ nPixels := int64(w) * int64(h);
if nPixels != int64(int(nPixels)) {
return UnsupportedError("dimension overflow")
}
}
func (d *decoder) parsePLTE(r io.Reader, crc hash.Hash32, length uint32) os.Error {
- np := int(length/3); // The number of palette entries.
+ np := int(length / 3); // The number of palette entries.
if length%3 != 0 || np <= 0 || np > 256 {
return FormatError("bad PLTE length")
}
- n, err := io.ReadFull(r, d.tmp[0 : 3*np]);
+ n, err := io.ReadFull(r, d.tmp[0:3*np]);
if err != nil {
return err
}
case ctPaletted:
palette := make([]image.Color, np);
for i := 0; i < np; i++ {
- palette[i] = image.RGBAColor{d.tmp[3*i + 0], d.tmp[3*i + 1], d.tmp[3*i + 2], 0xff}
+ palette[i] = image.RGBAColor{d.tmp[3*i+0], d.tmp[3*i+1], d.tmp[3*i+2], 0xff}
}
d.image.(*image.Paletted).Palette = image.PalettedColorModel(palette);
case ctTrueColor, ctTrueColorAlpha:
// The Paeth filter function, as per the PNG specification.
func paeth(a, b, c uint8) uint8 {
- p := int(a)+int(b)-int(c);
- pa := abs(p-int(a));
- pb := abs(p-int(b));
- pc := abs(p-int(c));
+ p := int(a) + int(b) - int(c);
+ pa := abs(p - int(a));
+ pb := abs(p - int(b));
+ pc := abs(p - int(c));
if pa <= pb && pa <= pc {
return a
} else if pb <= pc {
case ctPaletted:
bpp = 1;
paletted = d.image.(*image.Paletted);
- maxPalette = uint8(len(paletted.Palette)-1);
+ maxPalette = uint8(len(paletted.Palette) - 1);
case ctTrueColorAlpha:
bpp = 4;
nrgba = d.image.(*image.NRGBA);
}
// cr and pr are the bytes for the current and previous row.
// The +1 is for the per-row filter type, which is at cr[0].
- cr := make([]uint8, 1 + bpp * d.width);
- pr := make([]uint8, 1 + bpp * d.width);
+ cr := make([]uint8, 1+bpp*d.width);
+ pr := make([]uint8, 1+bpp*d.width);
for y := 0; y < d.height; y++ {
// Read the decompressed bytes.
}
case ftAverage:
for i := 0; i < bpp; i++ {
- cdat[i] += pdat[i]/2
+ cdat[i] += pdat[i] / 2
}
for i := bpp; i < len(cdat); i++ {
- cdat[i] += uint8((int(cdat[i-bpp])+int(pdat[i]))/2)
+ cdat[i] += uint8((int(cdat[i-bpp]) + int(pdat[i])) / 2)
}
case ftPaeth:
for i := 0; i < bpp; i++ {
switch d.colorType {
case ctTrueColor:
for x := 0; x < d.width; x++ {
- rgba.Set(x, y, image.RGBAColor{cdat[3*x + 0], cdat[3*x + 1], cdat[3*x + 2], 0xff})
+ rgba.Set(x, y, image.RGBAColor{cdat[3*x+0], cdat[3*x+1], cdat[3*x+2], 0xff})
}
case ctPaletted:
for x := 0; x < d.width; x++ {
}
case ctTrueColorAlpha:
for x := 0; x < d.width; x++ {
- nrgba.Set(x, y, image.NRGBAColor{cdat[4*x + 0], cdat[4*x + 1], cdat[4*x + 2], cdat[4*x + 3]})
+ nrgba.Set(x, y, image.NRGBAColor{cdat[4*x+0], cdat[4*x+1], cdat[4*x+2], cdat[4*x+3]})
}
}
}
var buf [4096]byte;
for length > 0 {
- n, err1 := r.Read(buf[0 : min(len(buf), int(length))]);
+ n, err1 := r.Read(buf[0:min(len(buf), int(length))]);
// We delay checking err1. It is possible to get n bytes and an error,
// but if the n bytes themselves contain a FormatError, for example, we
// want to report that error, and not the one that made the Read stop.
// Ignore this chunk (of a known length).
var ignored [4096]byte;
for length > 0 {
- n, err = io.ReadFull(r, ignored[0 : min(len(ignored), int(length))]);
+ n, err = io.ReadFull(r, ignored[0:min(len(ignored), int(length))]);
if err != nil {
return err
}
bitdepth := 8;
// Write the filename and IHDR.
- io.WriteString(w, "#SNG: from " + filename + ".png\nIHDR {\n");
+ io.WriteString(w, "#SNG: from "+filename+".png\nIHDR {\n");
fmt.Fprintf(w, " width: %d; height: %d; bitdepth: %d;\n", png.Width(), png.Height(), bitdepth);
cm := png.ColorModel();
var paletted *image.Paletted;
defer piper.Close();
// Read the .sng file.
- sf, err := os.Open("testdata/pngsuite/" + fn + ".sng", os.O_RDONLY, 0444);
+ sf, err := os.Open("testdata/pngsuite/"+fn+".sng", os.O_RDONLY, 0444);
if err != nil {
t.Error(fn, err);
continue;
err os.Error;
header [8]byte;
footer [4]byte;
- tmp [3*256]byte;
+ tmp [3 * 256]byte;
}
// Big-endian.
func writeUint32(b []uint8, u uint32) {
- b[0] = uint8(u>>24);
- b[1] = uint8(u>>16);
- b[2] = uint8(u>>8);
- b[3] = uint8(u>>0);
+ b[0] = uint8(u >> 24);
+ b[1] = uint8(u >> 16);
+ b[2] = uint8(u >> 8);
+ b[3] = uint8(u >> 0);
}
// Returns whether or not the image is fully opaque.
if d < 128 {
return int(d)
}
- return 256-int(d);
+ return 256 - int(d);
}
func (e *encoder) writeChunk(b []byte, name string) {
e.err = UnsupportedError("non-opaque palette color");
return;
}
- e.tmp[3*i + 0] = uint8(r>>24);
- e.tmp[3*i + 1] = uint8(g>>24);
- e.tmp[3*i + 2] = uint8(b>>24);
+ e.tmp[3*i+0] = uint8(r >> 24);
+ e.tmp[3*i+1] = uint8(g >> 24);
+ e.tmp[3*i+2] = uint8(b >> 24);
}
- e.writeChunk(e.tmp[0 : 3*len(p)], "PLTE");
+ e.writeChunk(e.tmp[0:3*len(p)], "PLTE");
}
// An encoder is an io.Writer that satisfies writes by writing PNG IDAT chunks,
// The up filter.
sum := 0;
for i := 0; i < n; i++ {
- cdat2[i] = cdat0[i]-pdat[i];
+ cdat2[i] = cdat0[i] - pdat[i];
sum += abs8(cdat2[i]);
}
best := sum;
sum += abs8(cdat1[i]);
}
for i := bpp; i < n; i++ {
- cdat1[i] = cdat0[i]-cdat0[i-bpp];
+ cdat1[i] = cdat0[i] - cdat0[i-bpp];
sum += abs8(cdat1[i]);
if sum >= best {
break
sum += abs8(cdat3[i]);
}
for i := bpp; i < n; i++ {
- cdat3[i] = cdat0[i]-uint8((int(cdat0[i-bpp])+int(pdat[i]))/2);
+ cdat3[i] = cdat0[i] - uint8((int(cdat0[i-bpp])+int(pdat[i]))/2);
sum += abs8(cdat3[i]);
if sum >= best {
break
// The +1 is for the per-row filter type, which is at cr[*][0].
var cr [nFilter][]uint8;
for i := 0; i < len(cr); i++ {
- cr[i] = make([]uint8, 1 + bpp * m.Width());
+ cr[i] = make([]uint8, 1+bpp*m.Width());
cr[i][0] = uint8(i);
}
- pr := make([]uint8, 1 + bpp * m.Width());
+ pr := make([]uint8, 1+bpp*m.Width());
for y := 0; y < m.Height(); y++ {
// Convert from colors to bytes.
for x := 0; x < m.Width(); x++ {
// We have previously verified that the alpha value is fully opaque.
r, g, b, _ := m.At(x, y).RGBA();
- cr[0][3*x + 1] = uint8(r>>24);
- cr[0][3*x + 2] = uint8(g>>24);
- cr[0][3*x + 3] = uint8(b>>24);
+ cr[0][3*x+1] = uint8(r >> 24);
+ cr[0][3*x+2] = uint8(g >> 24);
+ cr[0][3*x+3] = uint8(b >> 24);
}
case ctPaletted:
for x := 0; x < m.Width(); x++ {
// Convert from image.Image (which is alpha-premultiplied) to PNG's non-alpha-premultiplied.
for x := 0; x < m.Width(); x++ {
c := image.NRGBAColorModel.Convert(m.At(x, y)).(image.NRGBAColor);
- cr[0][4*x + 1] = c.R;
- cr[0][4*x + 2] = c.G;
- cr[0][4*x + 3] = c.B;
- cr[0][4*x + 4] = c.A;
+ cr[0][4*x+1] = c.R;
+ cr[0][4*x+2] = c.G;
+ cr[0][4*x+3] = c.B;
+ cr[0][4*x+4] = c.A;
}
}
buf := make([]byte, 32*1024);
for written < n {
l := len(buf);
- if d := n-written; d < int64(l) {
+ if d := n - written; d < int64(l) {
l = int(d)
}
nr, er := src.Read(buf[0:l]);
return 0, os.EOF
}
if int64(len(p)) > l.n {
- p = p[0 : l.n]
+ p = p[0:l.n]
}
n, err = l.r.Read(p);
l.n -= int64(n);
// NewSectionReader returns a SectionReader that reads from r
// starting at offset off and stops with os.EOF after n bytes.
func NewSectionReader(r ReaderAt, off int64, n int64) *SectionReader {
- return &SectionReader{r, off, off, off+n}
+ return &SectionReader{r, off, off, off + n}
}
// SectionReader implements Read, Seek, and ReadAt on a section
}
func (s *SectionReader) ReadAt(p []byte, off int64) (n int, err os.Error) {
- if off < 0 || off >= s.limit - s.base {
+ if off < 0 || off >= s.limit-s.base {
return 0, os.EOF
}
off += s.base;
go reader(t, r, c);
var buf = make([]byte, 64);
for i := 0; i < 5; i++ {
- p := buf[0 : 5 + i*10];
+ p := buf[0 : 5+i*10];
n, err := w.Write(p);
if n != len(p) {
t.Errorf("wrote %d, got %d", len(p), n)
// If the file does not exist, WriteFile creates it with permissions perm;
// otherwise WriteFile truncates it before writing.
func WriteFile(filename string, data []byte, perm int) os.Error {
- f, err := os.Open(filename, os.O_WRONLY | os.O_CREAT | os.O_TRUNC, perm);
+ f, err := os.Open(filename, os.O_WRONLY|os.O_CREAT|os.O_TRUNC, perm);
if err != nil {
return err
}
v *= 16;
switch {
case '0' <= p[i] && p[i] <= '9':
- v += int(p[i]-'0')
+ v += int(p[i] - '0')
case 'a' <= p[i] && p[i] <= 'f':
- v += int(p[i]-'a'+10)
+ v += int(p[i] - 'a' + 10)
case 'A' <= p[i] && p[i] <= 'F':
- v += int(p[i]-'A'+10)
+ v += int(p[i] - 'A' + 10)
default:
return 0, false
}
if i >= len(p) {
return i
}
- return i+1;
+ return i + 1;
}
func (t *_Lexer) Next() {
v.Set(nv);
}
if v.Len() <= i && i < v.Cap() {
- v.SetLen(i+1)
+ v.SetLen(i + 1)
}
if i < v.Len() {
return &structBuilder{val: v.Elem(i)}
// order they appear (the order listed here) or the format they present (as
// described in the comments). A colon appears after these items:
// 2009/0123 01:23:23.123123 /a/b/c/d.go:23: message
- Ldate = 1<<iota; // the date: 2009/0123
+ Ldate = 1 << iota; // the date: 2009/0123
Ltime; // the time: 01:23:23
Lmicroseconds; // microsecond resolution: 01:23:23.123123. assumes Ltime.
Llongfile; // full file name and line number: /a/b/c/d.go:23
for ; u > 0 || wid > 0; u /= 10 {
bp--;
wid--;
- b[bp] = byte(u%10)+'0';
+ b[bp] = byte(u%10) + '0';
}
return string(b[bp:len(b)]);
func (l *Logger) formatHeader(ns int64, calldepth int) string {
h := l.prefix;
- if l.flag & (Ldate | Ltime | Lmicroseconds) != 0 {
- t := time.SecondsToLocalTime(ns/1e9);
- if l.flag & (Ldate) != 0 {
+ if l.flag&(Ldate|Ltime|Lmicroseconds) != 0 {
+ t := time.SecondsToLocalTime(ns / 1e9);
+ if l.flag&(Ldate) != 0 {
h += itoa(int(t.Year), 4) + "/" + itoa(t.Month, 2) + "/" + itoa(t.Day, 2) + " "
}
- if l.flag & (Ltime | Lmicroseconds) != 0 {
+ if l.flag&(Ltime|Lmicroseconds) != 0 {
h += itoa(t.Hour, 2) + ":" + itoa(t.Minute, 2) + ":" + itoa(t.Second, 2);
- if l.flag & Lmicroseconds != 0 {
+ if l.flag&Lmicroseconds != 0 {
h += "." + itoa(int(ns%1e9)/1e3, 6)
}
h += " ";
}
}
- if l.flag & (Lshortfile | Llongfile) != 0 {
+ if l.flag&(Lshortfile|Llongfile) != 0 {
_, file, line, ok := runtime.Caller(calldepth);
if ok {
- if l.flag & Lshortfile != 0 {
+ if l.flag&Lshortfile != 0 {
short, ok := shortnames[file];
if !ok {
short = file;
- for i := len(file)-1; i > 0; i-- {
+ for i := len(file) - 1; i > 0; i-- {
if file[i] == '/' {
short = file[i+1 : len(file)];
break;
if len(s) > 0 && s[len(s)-1] == '\n' {
newline = ""
}
- s = l.formatHeader(now, calldepth + 1) + s + newline;
+ s = l.formatHeader(now, calldepth+1) + s + newline;
io.WriteString(l.out0, s);
if l.out1 != nil {
io.WriteString(l.out1, s)
// individual pieces:
tester{0, "", ""},
tester{0, "XXX", "XXX"},
- tester{Lok|Ldate, "", Rdate+" "},
- tester{Lok|Ltime, "", Rtime+" "},
+ tester{Lok | Ldate, "", Rdate + " "},
+ tester{Lok | Ltime, "", Rtime + " "},
tester{Lok | Ltime | Lmicroseconds, "", Rtime + Rmicroseconds + " "},
tester{Lok | Lmicroseconds, "", Rtime + Rmicroseconds + " "}, // microsec implies time
tester{Lok | Llongfile, "", Rlongfile + " "},
}
func tolerance(a, b, e float64) bool {
- d := a-b;
+ d := a - b;
if d < 0 {
d = -d
}
if a != 0 {
- e = e*a;
+ e = e * a;
if e < 0 {
e = -e
}
func TestAsin(t *testing.T) {
for i := 0; i < len(vf); i++ {
- if f := Asin(vf[i]/10); !veryclose(asin[i], f) {
+ if f := Asin(vf[i] / 10); !veryclose(asin[i], f) {
t.Errorf("Asin(%g) = %g, want %g\n", vf[i]/10, f, asin[i])
}
}
func TestHypot(t *testing.T) {
for i := 0; i < len(vf); i++ {
- a := Fabs(tanh[i]*Sqrt(2));
+ a := Fabs(tanh[i] * Sqrt(2));
if f := Hypot(tanh[i], tanh[i]); !veryclose(a, f) {
t.Errorf("Hypot(%g, %g) = %g, want %g\n", tanh[i], tanh[i], f, a)
}
if x > 0.7 {
temp = Pi/2 - Atan(temp/x)
} else {
- temp = Atan(x/temp)
+ temp = Atan(x / temp)
}
if sign {
Q1 = .207933497444540981287275926e4;
Q0 = .89678597403663861962481162e3;
)
- sq := arg*arg;
- value := ((((P4*sq + P3)*sq + P2)*sq + P1)*sq + P0);
- value = value/(((((sq+Q4)*sq + Q3)*sq + Q2)*sq + Q1)*sq + Q0);
- return value*arg;
+ sq := arg * arg;
+ value := ((((P4*sq+P3)*sq+P2)*sq + P1) * sq + P0);
+ value = value / (((((sq+Q4)*sq+Q3)*sq+Q2)*sq+Q1)*sq + Q0);
+ return value * arg;
}
/*
// Determine the quadrant and call atan.
if x+y == x {
if x >= 0 {
- return Pi/2
+ return Pi / 2
}
return -Pi / 2;
}
- q := Atan(x/y);
+ q := Atan(x / y);
if y < 0 {
if q <= 0 {
- return q+Pi
+ return q + Pi
}
- return q-Pi;
+ return q - Pi;
}
return q;
}
uvinf = 0x7FF0000000000000;
uvneginf = 0xFFF0000000000000;
mask = 0x7FF;
- shift = 64-11-1;
+ shift = 64 - 11 - 1;
bias = 1022;
)
return
}
x := Float64bits(f);
- exp = int((x>>shift)&mask)-bias;
- x &^= mask<<shift;
- x |= bias<<shift;
+ exp = int((x>>shift)&mask) - bias;
+ x &^= mask << shift;
+ x |= bias << shift;
frac = Float64frombits(x);
return;
}
// It returns frac × 2<sup>exp</sup>.
func Ldexp(frac float64, exp int) float64 {
x := Float64bits(frac);
- exp += int(x>>shift)&mask;
+ exp += int(x>>shift) & mask;
if exp <= 0 {
return 0 // underflow
}
}
return Inf(1);
}
- x &^= mask<<shift;
- x |= uint64(exp)<<shift;
+ x &^= mask << shift;
+ x |= uint64(exp) << shift;
return Float64frombits(x);
}
x &^= 1<<(64-11-e) - 1
}
int = Float64frombits(x);
- frac = f-int;
+ frac = f - int;
return;
}
SqrtPhi = 1.27201964951406896425242246173749149171560804184009624861664038; // A139339
Ln2 = 0.693147180559945309417232121458176568075500134360255254120680009; // A002162
- Log2E = 1/Ln2;
+ Log2E = 1 / Ln2;
Ln10 = 2.30258509299404568401799145468436420760110148862877297603332790; // A002392
- Log10E = 1/Ln10;
+ Log10E = 1 / Ln10;
)
// Floating-point limit values.
Overflow = 7.09782712893383973096e+02;
Underflow = -7.45133219101941108420e+02;
- NearZero = 1.0/(1<<28); // 2^-28
+ NearZero = 1.0 / (1 << 28); // 2^-28
)
// special cases
k = int(Log2e*x + 0.5)
}
hi := x - float64(k)*Ln2Hi;
- lo := float64(k)*Ln2Lo;
- r := hi-lo;
+ lo := float64(k) * Ln2Lo;
+ r := hi - lo;
// compute
- t := r*r;
- c := r - t*(P1 + t*(P2 + t*(P3 + t*(P4 + t*P5))));
- y := 1-((lo - (r*c)/(2-c))-hi);
+ t := r * r;
+ c := r - t*(P1+t*(P2+t*(P3+t*(P4+t*P5))));
+ y := 1 - ((lo - (r*c)/(2-c)) - hi);
// TODO(rsc): make sure Ldexp can handle boundary k
return Ldexp(y, k);
}
if x < 0 {
d, fract := Modf(-x);
if fract != 0.0 {
- d = d+1
+ d = d + 1
}
return -d;
}
for r >= y {
rfr, rexp := Frexp(r);
if rfr < yfr {
- rexp = rexp-1
+ rexp = rexp - 1
}
r = r - Ldexp(y, rexp-yexp);
}
}
pfac := p;
- q = q/p;
+ q = q / p;
r := q;
p = 1;
for {
- r = r*r;
- s := r+4;
+ r = r * r;
+ s := r + 4;
if s == 4 {
- return p*pfac
+ return p * pfac
}
- r = r/s;
+ r = r / s;
p = p + 2*r*p;
- q = q*r;
- r = q/p;
+ q = q * r;
+ r = q / p;
}
panic("unreachable");
}
f1 *= 2;
ki--;
}
- f := f1-1;
+ f := f1 - 1;
k := float64(ki);
// compute
- s := f/(2+f);
- s2 := s*s;
- s4 := s2*s2;
- t1 := s2*(L1 + s4*(L3 + s4*(L5 + s4*L7)));
- t2 := s4*(L2 + s4*(L4 + s4*L6));
- R := t1+t2;
- hfsq := 0.5*f*f;
- return k*Ln2Hi - ((hfsq-(s*(hfsq+R) + k*Ln2Lo))-f);
+ s := f / (2 + f);
+ s2 := s * s;
+ s4 := s2 * s2;
+ t1 := s2 * (L1 + s4*(L3+s4*(L5+s4*L7)));
+ t2 := s4 * (L2 + s4*(L4+s4*L6));
+ R := t1 + t2;
+ hfsq := 0.5 * f * f;
+ return k*Ln2Hi - ((hfsq - (s*(hfsq+R) + k*Ln2Lo)) - f);
}
// Log10 returns the decimal logarithm of x.
if x <= 0 {
return NaN()
}
- return Log(x)*(1/Ln10);
+ return Log(x) * (1 / Ln10);
}
case y == 0.5:
return Sqrt(x)
case y == -0.5:
- return 1/Sqrt(x)
+ return 1 / Sqrt(x)
}
absy := y;
return NaN()
}
if yi >= 1<<63 {
- return Exp(y*Log(x))
+ return Exp(y * Log(x))
}
// ans = a1 * 2^ae (= 1 for now).
yf--;
yi++;
}
- a1 = Exp(yf*Log(x));
+ a1 = Exp(yf * Log(x));
}
// ans *= x^yi
// if flip { ans = 1 / ans }
// but in the opposite order
if flip {
- a1 = 1/a1;
+ a1 = 1 / a1;
ae = -ae;
}
return Ldexp(a1, ae);
// Pow10 returns 10**x, the base-10 exponential of x.
func Pow10(e int) float64 {
if e < 0 {
- return 1/Pow10(-e)
+ return 1 / Pow10(-e)
}
if e < len(pow10tab) {
return pow10tab[e]
}
- m := e/2;
- return Pow10(m)*Pow10(e-m);
+ m := e / 2;
+ return Pow10(m) * Pow10(e-m);
}
func init() {
pow10tab[0] = 1.0e0;
pow10tab[1] = 1.0e1;
for i := 2; i < len(pow10tab); i++ {
- m := i/2;
- pow10tab[i] = pow10tab[m]*pow10tab[i-m];
+ m := i / 2;
+ pow10tab[i] = pow10tab[m] * pow10tab[i-m];
}
}
)
if x < 0 {
x = -x;
- quad = quad+2;
+ quad = quad + 2;
}
- x = x*(2/Pi); /* underflow? */
+ x = x * (2 / Pi); /* underflow? */
var y float64;
if x > 32764 {
var e float64;
e, y = Modf(x);
- e = e+float64(quad);
- _, f := Modf(0.25*e);
+ e = e + float64(quad);
+ _, f := Modf(0.25 * e);
quad = int(e - 4*f);
} else {
k := int32(x);
- y = x-float64(k);
- quad = (quad+int(k))&3;
+ y = x - float64(k);
+ quad = (quad + int(k)) & 3;
}
if quad&1 != 0 {
- y = 1-y
+ y = 1 - y
}
if quad > 1 {
y = -y
}
- yy := y*y;
- temp1 := ((((P4*yy + P3)*yy + P2)*yy + P1)*yy + P0)*y;
- temp2 := ((((yy+Q3)*yy + Q2)*yy + Q1)*yy + Q0);
- return temp1/temp2;
+ yy := y * y;
+ temp1 := ((((P4*yy+P3)*yy+P2)*yy+P1)*yy + P0) * y;
+ temp2 := ((((yy+Q3)*yy+Q2)*yy + Q1) * yy + Q0);
+ return temp1 / temp2;
}
// Cos returns the cosine of x.
var temp float64;
switch true {
case x > 21:
- temp = Exp(x)/2
+ temp = Exp(x) / 2
case x > 0.5:
- temp = (Exp(x)-Exp(-x))/2
+ temp = (Exp(x) - Exp(-x)) / 2
default:
- sq := x*x;
- temp = (((P3*sq + P2)*sq + P1)*sq + P0)*x;
- temp = temp/(((sq+Q2)*sq + Q1)*sq + Q0);
+ sq := x * x;
+ temp = (((P3*sq+P2)*sq+P1)*sq + P0) * x;
+ temp = temp / (((sq+Q2)*sq+Q1)*sq + Q0);
}
if sign {
x = -x
}
if x > 21 {
- return Exp(x)/2
+ return Exp(x) / 2
}
- return (Exp(x)+Exp(-x))/2;
+ return (Exp(x) + Exp(-x)) / 2;
}
y, exp := Frexp(x);
for y < 0.5 {
- y = y*2;
- exp = exp-1;
+ y = y * 2;
+ exp = exp - 1;
}
if exp&1 != 0 {
- y = y*2;
- exp = exp-1;
+ y = y * 2;
+ exp = exp - 1;
}
- temp := 0.5*(1+y);
+ temp := 0.5 * (1 + y);
for exp > 60 {
- temp = temp*float64(1<<30);
- exp = exp-60;
+ temp = temp * float64(1<<30);
+ exp = exp - 60;
}
for exp < -60 {
- temp = temp/float64(1<<30);
- exp = exp+60;
+ temp = temp / float64(1<<30);
+ exp = exp + 60;
}
if exp >= 0 {
- exp = 1<<uint(exp/2);
- temp = temp*float64(exp);
+ exp = 1 << uint(exp/2);
+ temp = temp * float64(exp);
} else {
- exp = 1<<uint(-exp / 2);
- temp = temp/float64(exp);
+ exp = 1 << uint(-exp/2);
+ temp = temp / float64(exp);
}
for i := 0; i <= 4; i++ {
- temp = 0.5*(temp + x/temp)
+ temp = 0.5 * (temp + x/temp)
}
return temp;
}
x = -x;
sign = true;
}
- x = x*(4/Pi); /* overflow? */
+ x = x * (4 / Pi); /* overflow? */
var e float64;
e, x = Modf(x);
i := int32(e);
- switch i&3 {
+ switch i & 3 {
case 1:
- x = 1-x;
+ x = 1 - x;
flag = true;
case 2:
flag = true;
case 3:
- x = 1-x;
+ x = 1 - x;
sign = !sign;
}
- xsq := x*x;
- temp := ((((P4*xsq + P3)*xsq + P2)*xsq + P1)*xsq + P0)*x;
- temp = temp/(((xsq+Q2)*xsq + Q1)*xsq + Q0);
+ xsq := x * x;
+ temp := ((((P4*xsq+P3)*xsq+P2)*xsq+P1)*xsq + P0) * x;
+ temp = temp / (((xsq+Q2)*xsq+Q1)*xsq + Q0);
if flag {
if temp == 0 {
panic(NaN())
}
- temp = 1/temp;
+ temp = 1 / temp;
}
if sign {
temp = -temp
if x > 21 {
return 1
}
- return Sinh(x)/Cosh(x);
+ return Sinh(x) / Cosh(x);
}
const (
// __DNS_Header.Bits
- _QR = 1<<15; // query/response (response=1)
- _AA = 1<<10; // authoritative
- _TC = 1<<9; // truncated
- _RD = 1<<8; // recursion desired
- _RA = 1<<7; // recursion available
+ _QR = 1 << 15; // query/response (response=1)
+ _AA = 1 << 10; // authoritative
+ _TC = 1 << 9; // truncated
+ _RD = 1 << 8; // recursion desired
+ _RA = 1 << 7; // recursion available
)
// DNS queries.
// We trade each dot byte for a length byte.
// There is also a trailing zero.
// Check that we have all the space we need.
- tot := len(s)+1;
+ tot := len(s) + 1;
if off+tot > len(msg) {
return len(msg), false
}
if i-begin >= 1<<6 { // top two bits of length must be clear
return len(msg), false
}
- msg[off] = byte(i-begin);
+ msg[off] = byte(i - begin);
off++;
for j := begin; j < i; j++ {
msg[off] = s[j];
off++;
}
- begin = i+1;
+ begin = i + 1;
}
}
msg[off] = 0;
}
c := int(msg[off]);
off++;
- switch c&0xC0 {
+ switch c & 0xC0 {
case 0x00:
if c == 0x00 {
// end of name
if off+c > len(msg) {
return "", len(msg), false
}
- s += string(msg[off : off+c])+".";
+ s += string(msg[off:off+c]) + ".";
off += c;
case 0xC0:
// pointer to somewhere else in msg.
if off+2 > len(msg) {
return len(msg), false
}
- msg[off] = byte(i>>8);
+ msg[off] = byte(i >> 8);
msg[off+1] = byte(i);
off += 2;
case *reflect.Uint32Value:
if off+4 > len(msg) {
return len(msg), false
}
- msg[off] = byte(i>>24);
- msg[off+1] = byte(i>>16);
- msg[off+2] = byte(i>>8);
+ msg[off] = byte(i >> 24);
+ msg[off+1] = byte(i >> 16);
+ msg[off+2] = byte(i >> 8);
msg[off+4] = byte(i);
off += 4;
case *reflect.StringValue:
return len(msg), false
}
// pack a third time; redo header with correct data length
- rr.Header().Rdlength = uint16(off2-off1);
+ rr.Header().Rdlength = uint16(off2 - off1);
packStruct(rr.Header(), msg, off);
return off2, true;
}
if off, ok = unpackStruct(&h, msg, off); !ok {
return nil, len(msg), false
}
- end := off+int(h.Rdlength);
+ end := off + int(h.Rdlength);
// make an rr of that type and re-unpack.
// again inefficient but doesn't need to be fast.
}
dns.id = dh.Id;
dns.response = (dh.Bits & _QR) != 0;
- dns.opcode = int(dh.Bits >> 11)&0xF;
+ dns.opcode = int(dh.Bits>>11) & 0xF;
dns.authoritative = (dh.Bits & _AA) != 0;
dns.truncated = (dh.Bits & _TC) != 0;
dns.recursion_desired = (dh.Bits & _RD) != 0;
}
var t int64;
- key := intfd<<1;
+ key := intfd << 1;
if mode == 'r' {
fd.ncr++;
t = fd.rdeadline;
}
func (s *pollServer) LookupFD(fd int, mode int) *netFD {
- key := fd<<1;
+ key := fd << 1;
if mode == 'w' {
key++
}
if err != nil {
panic("net: os.Time: ", err.String())
}
- nsec += sec*1e9;
+ nsec += sec * 1e9;
return nsec;
}
if e != 0 {
return os.NewSyscallError("kevent", e)
}
- if n != 1 || (ev.Flags & syscall.EV_ERROR) == 0 || int(ev.Ident) != fd || int(ev.Filter) != kmode {
+ if n != 1 || (ev.Flags&syscall.EV_ERROR) == 0 || int(ev.Ident) != fd || int(ev.Filter) != kmode {
return os.ErrorString("kqueue phase error")
}
if ev.Data != 0 {
// EV_DELETE - delete event from kqueue list
// EV_RECEIPT - generate fake EV_ERROR as result of add,
// rather than waiting for real event
- syscall.SetKevent(ev, fd, kmode, syscall.EV_DELETE | syscall.EV_RECEIPT);
+ syscall.SetKevent(ev, fd, kmode, syscall.EV_DELETE|syscall.EV_RECEIPT);
syscall.Kevent(p.kq, &events, &events, nil);
}
// If syscall.EPOLLONESHOT is not set, the wait
// is a repeating wait, so don't change it.
- if events & syscall.EPOLLONESHOT == 0 {
+ if events&syscall.EPOLLONESHOT == 0 {
return
}
// If we're still waiting for other events, modify the fd
// event in the kernel. Otherwise, delete it.
events &= ^uint32(bits);
- if int32(events) & ^syscall.EPOLLONESHOT != 0 {
+ if int32(events)&^syscall.EPOLLONESHOT != 0 {
var ev syscall.EpollEvent;
ev.Fd = int32(fd);
ev.Events = events;
ev := &evarray[0];
var msec int = -1;
if nsec > 0 {
- msec = int((nsec+1e6-1)/1e6)
+ msec = int((nsec + 1e6 - 1) / 1e6)
}
n, e := syscall.EpollWait(p.epfd, &evarray, msec);
for e == syscall.EAGAIN || e == syscall.EINTR {
}
fd = int(ev.Fd);
- if ev.Events & writeFlags != 0 {
+ if ev.Events&writeFlags != 0 {
p.StopWaiting(fd, writeFlags);
return fd, 'w', nil;
}
- if ev.Events & readFlags != 0 {
+ if ev.Events&readFlags != 0 {
p.StopWaiting(fd, readFlags);
return fd, 'r', nil;
}
// Other events are error conditions - wake whoever is waiting.
events, _ := p.events[fd];
- if events & writeFlags != 0 {
+ if events&writeFlags != 0 {
p.StopWaiting(fd, writeFlags);
return fd, 'w', nil;
}
}
out := make(IP, n);
for i := 0; i < n; i++ {
- out[i] = ip[i]&mask[i]
+ out[i] = ip[i] & mask[i]
}
return out;
}
bp := len(b);
for ; i > 0; i /= 10 {
bp--;
- b[bp] = byte(i%10)+'0';
+ b[bp] = byte(i%10) + '0';
}
return string(b[bp:len(b)]);
} else if i > 0 {
s += ":"
}
- s += itox((uint(p[i])<<8)|uint(p[i+1]));
+ s += itox((uint(p[i]) << 8) | uint(p[i+1]));
}
return s;
}
break
}
}
- n := 8*i;
+ n := 8 * i;
v := mask[i];
for v&0x80 != 0 {
n++;
}
// Save this 16-bit chunk.
- p[j] = byte(n>>8);
+ p[j] = byte(n >> 8);
p[j+1] = byte(n);
j += 2;
if ellipsis < 0 {
return nil
}
- n := IPv6len-j;
- for k := j-1; k >= ellipsis; k-- {
+ n := IPv6len - j;
+ for k := j - 1; k >= ellipsis; k-- {
p[k+n] = p[k]
}
- for k := ellipsis+n-1; k >= ellipsis; k-- {
+ for k := ellipsis + n - 1; k >= ellipsis; k-- {
p[k] = 0
}
}
return;
}
- host, port = hostport[0:i], hostport[i+1 : len(hostport)];
+ host, port = hostport[0:i], hostport[i+1:len(hostport)];
// Can put brackets around host ...
if len(host) > 0 && host[0] == '[' && host[len(host)-1] == ']' {
func joinHostPort(host, port string) string {
// If host has colons, have to bracket it.
if byteIndex(host, ':') >= 0 {
- return "["+host+"]:"+port
+ return "[" + host + "]:" + port
}
- return host+":"+port;
+ return host + ":" + port;
}
// Convert "host:port" into IP address and port.
}
err = UnknownNetworkError(net);
Error:
- return nil, &OpError{"dial", net+" "+raddr, nil, err};
+ return nil, &OpError{"dial", net + " " + raddr, nil, err};
}
// Listen announces on the local network address laddr.
ok = true;
// move data
i++;
- n := len(data)-i;
+ n := len(data) - i;
for j := 0; j < n; j++ {
data[j] = data[i+j]
}
// Split s at any bytes in t.
func splitAtBytes(s string, t string) []string {
- a := make([]string, 1 + countAnyByte(s, t));
+ a := make([]string, 1+countAnyByte(s, t));
n := 0;
last := 0;
for i := 0; i < len(s); i++ {
a[n] = string(s[last:i]);
n++;
}
- last = i+1;
+ last = i + 1;
}
}
if last < len(s) {
for i = i0; i < len(s); i++ {
if '0' <= s[i] && s[i] <= '9' {
n *= 16;
- n += int(s[i]-'0');
+ n += int(s[i] - '0');
} else if 'a' <= s[i] && s[i] <= 'f' {
n *= 16;
- n += int(s[i]-'a')+10;
+ n += int(s[i]-'a') + 10;
} else if 'A' <= s[i] && s[i] <= 'F' {
n *= 16;
- n += int(s[i]-'A')+10;
+ n += int(s[i]-'A') + 10;
} else {
break
}
break
}
lineno++;
- byteno += len(line)+1;
+ byteno += len(line) + 1;
}
}
return
}
}
- return 0, &AddrError{"unknown port", network+"/"+service};
+ return 0, &AddrError{"unknown port", network + "/" + service};
}
func connect(t *testing.T, network, addr string) {
var laddr string;
if network == "unixgram" {
- laddr = addr+".local"
+ laddr = addr + ".local"
}
fd, err := Dial(network, laddr, addr);
if err != nil {
go runServe(t, network, listenaddr, listening, done);
addr := <-listening; // wait for server to start
if network == "tcp" {
- dialaddr += addr[strings.LastIndex(addr, ":") : len(addr)]
+ dialaddr += addr[strings.LastIndex(addr, ":"):len(addr)]
}
connect(t, network, dialaddr);
<-done; // make sure server stopped
go runPacket(t, network, listenaddr, listening, done);
addr := <-listening; // wait for server to start
if network == "udp" {
- dialaddr += addr[strings.LastIndex(addr, ":") : len(addr)]
+ dialaddr += addr[strings.LastIndex(addr, ":"):len(addr)]
}
connect(t, network, dialaddr);
<-done; // tell server to stop
continue
}
bytes := (*[len(dirent.Name)]byte)(unsafe.Pointer(&dirent.Name[0]));
- var name = string(bytes[0 : dirent.Namlen]);
+ var name = string(bytes[0:dirent.Namlen]);
if name == "." || name == ".." { // Useless names
continue
}
// check i < len(a) for safety,
// in case env is changing underfoot.
if i < len(a) {
- a[i] = k+"="+v;
+ a[i] = k + "=" + v;
i++;
}
}
WNOHANG = syscall.WNOHANG; // Don't wait if no process has exited.
WSTOPPED = syscall.WSTOPPED; // If set, status of stopped subprocesses is also reported.
WUNTRACED = WSTOPPED;
- WRUSAGE = 1<<20; // Record resource usage.
+ WRUSAGE = 1 << 20; // Record resource usage.
)
// WRUSAGE must not be too high a bit, to avoid clashing with Linux's
bp := len(b);
for ; u > 0; u /= 10 {
bp--;
- b[bp] = byte(u%10)+'0';
+ b[bp] = byte(u%10) + '0';
}
if i < 0 {
// if applicable. If successful, methods on the returned File can be used for I/O.
// It returns the File and an Error, if any.
func Open(name string, flag int, perm int) (file *File, err Error) {
- r, e := syscall.Open(name, flag | syscall.O_CLOEXEC, perm);
+ r, e := syscall.Open(name, flag|syscall.O_CLOEXEC, perm);
if e != 0 {
return nil, &PathError{"open", name, Errno(e)}
}
return nil, &PathError{"stat", name, Errno(e)}
}
statp := &lstat;
- if lstat.Mode & syscall.S_IFMT == syscall.S_IFLNK {
+ if lstat.Mode&syscall.S_IFMT == syscall.S_IFLNK {
e := syscall.Stat(name, &stat);
if e == 0 {
statp = &stat
}
dirs = make([]Dir, len(names));
for i, filename := range names {
- dirp, err := Lstat(dirname+filename);
+ dirp, err := Lstat(dirname + filename);
if dirp == nil || err != nil {
dirs[i].Name = filename // rest is already zeroed out
} else {
// and then find name of parent. Each iteration
// adds /name to the beginning of pwd.
pwd = "";
- for parent := ".."; ; parent = "../"+parent {
+ for parent := ".."; ; parent = "../" + parent {
if len(parent) >= 1024 { // Sanity check
return "", ENAMETOOLONG
}
return "", err;
}
for _, name := range names {
- d, _ := Lstat(parent+"/"+name);
+ d, _ := Lstat(parent + "/" + name);
if d.Dev == dot.Dev && d.Ino == dot.Ino {
- pwd = "/"+name+pwd;
+ pwd = "/" + name + pwd;
goto Found;
}
}
func TestLongSymlink(t *testing.T) {
s := "0123456789abcdef";
- s = s+s+s+s+s+s+s+s+s+s+s+s+s+s+s+s+s;
+ s = s + s + s + s + s + s + s + s + s + s + s + s + s + s + s + s + s;
from := "longsymlinktestfrom";
err := Symlink(s, from);
if err != nil {
if err != nil {
t.Fatalf("Stat %q (looking for mode %#o): %s", path, mode, err)
}
- if dir.Mode & 0777 != mode {
+ if dir.Mode&0777 != mode {
t.Errorf("Stat %q: mode %#o want %#o", path, dir.Mode, 0777)
}
}
test{5, 0, 5},
test{0, 2, int64(len(data))},
test{0, 0, 0},
- test{-1, 2, int64(len(data))-1},
- test{1<<40, 0, 1<<40},
- test{1<<40, 2, 1<<40 + int64(len(data))},
+ test{-1, 2, int64(len(data)) - 1},
+ test{1 << 40, 0, 1 << 40},
+ test{1 << 40, 2, 1<<40 + int64(len(data))},
};
for i, tt := range tests {
off, err := f.Seek(tt.in, tt.whence);
if j > 0 {
// Create parent
- err = MkdirAll(path[0 : j-1], perm);
+ err = MkdirAll(path[0:j-1], perm);
if err != nil {
return err
}
for {
names, err1 := fd.Readdirnames(100);
for _, name := range names {
- err1 := RemoveAll(path+"/"+name);
+ err1 := RemoveAll(path + "/" + name);
if err == nil {
err = err1
}
}
// Make file.
- fpath := path+"/file";
+ fpath := path + "/file";
_, err = Open(fpath, O_WRONLY|O_CREAT, 0666);
if err != nil {
t.Fatalf("create %q: %s", fpath, err)
func TestRemoveAll(t *testing.T) {
// Work directory.
path := "_obj/_TestRemoveAll_";
- fpath := path+"/file";
- dpath := path+"/dir";
+ fpath := path + "/file";
+ dpath := path + "/dir";
// Make directory with 1 file and remove.
if err := MkdirAll(path, 0777); err != nil {
t.Fatalf("MkdirAll %q: %s", dpath, err)
}
- for _, s := range []string{fpath, dpath+"/file1", path+"/zzz"} {
+ for _, s := range []string{fpath, dpath + "/file1", path + "/zzz"} {
fd, err = Open(s, O_WRONLY|O_CREAT, 0666);
if err != nil {
t.Fatalf("create %q: %s", s, err)
if err = Chmod(dpath, 0777); err != nil {
t.Fatalf("Chmod %q 0777: %s", dpath, err)
}
- for _, s := range []string{fpath, path+"/zzz"} {
+ for _, s := range []string{fpath, path + "/zzz"} {
if _, err := Lstat(s); err == nil {
t.Fatalf("Lstat %q succeeded after partial RemoveAll", s)
}
import "syscall"
func isSymlink(stat *syscall.Stat_t) bool {
- return stat.Mode & syscall.S_IFMT == syscall.S_IFLNK
+ return stat.Mode&syscall.S_IFMT == syscall.S_IFLNK
}
func dirFromStat(name string, dir *Dir, lstat, stat *syscall.Stat_t) *Dir {
dir.Atime_ns = uint64(syscall.TimespecToNsec(stat.Atimespec));
dir.Mtime_ns = uint64(syscall.TimespecToNsec(stat.Mtimespec));
dir.Ctime_ns = uint64(syscall.TimespecToNsec(stat.Ctimespec));
- for i := len(name)-1; i >= 0; i-- {
+ for i := len(name) - 1; i >= 0; i-- {
if name[i] == '/' {
name = name[i+1 : len(name)];
break;
import "syscall"
func isSymlink(stat *syscall.Stat_t) bool {
- return stat.Mode & syscall.S_IFMT == syscall.S_IFLNK
+ return stat.Mode&syscall.S_IFMT == syscall.S_IFLNK
}
func dirFromStat(name string, dir *Dir, lstat, stat *syscall.Stat_t) *Dir {
dir.Atime_ns = uint64(syscall.TimespecToNsec(stat.Atim));
dir.Mtime_ns = uint64(syscall.TimespecToNsec(stat.Mtim));
dir.Ctime_ns = uint64(syscall.TimespecToNsec(stat.Ctim));
- for i := len(name)-1; i >= 0; i-- {
+ for i := len(name) - 1; i >= 0; i-- {
if name[i] == '/' {
name = name[i+1 : len(name)];
break;
import "syscall"
func isSymlink(stat *syscall.Stat_t) bool {
- return stat.Mode & syscall.S_IFMT == syscall.S_IFLNK
+ return stat.Mode&syscall.S_IFMT == syscall.S_IFLNK
}
func dirFromStat(name string, dir *Dir, lstat, stat *syscall.Stat_t) *Dir {
dir.Size = uint64(stat.Size);
dir.Blksize = uint64(stat.Blksize);
dir.Blocks = uint64(stat.Blocks);
- dir.Atime_ns = uint64(stat.Atime)*1e9;
- dir.Mtime_ns = uint64(stat.Mtime)*1e9;
- dir.Ctime_ns = uint64(stat.Ctime)*1e9;
- for i := len(name)-1; i >= 0; i-- {
+ dir.Atime_ns = uint64(stat.Atime) * 1e9;
+ dir.Mtime_ns = uint64(stat.Mtime) * 1e9;
+ dir.Ctime_ns = uint64(stat.Ctime) * 1e9;
+ for i := len(name) - 1; i >= 0; i-- {
if name[i] == '/' {
name = name[i+1 : len(name)];
break;
if errno := syscall.Gettimeofday(&tv); errno != 0 {
return 0, 0, NewSyscallError("gettimeofday", errno)
}
- return int64(tv.Sec), int64(tv.Usec)*1000, err;
+ return int64(tv.Sec), int64(tv.Usec) * 1000, err;
}
func unhex(c byte) uint8 {
switch {
case '0' <= c && c <= '9':
- return c-'0'
+ return c - '0'
case 'a' <= c && c <= 'f':
- return c-'a'+10
+ return c - 'a' + 10
case 'A' <= c && c <= 'F':
- return c-'A'+10
+ return c - 'A' + 10
}
return 255;
}
n &^= 1; // Only take an even number of hex digits.
data = make([]byte, n/2);
for i := range data {
- data[i] = unhex(s[2*i])<<4 | unhex(s[2*i + 1])
+ data[i] = unhex(s[2*i])<<4 | unhex(s[2*i+1])
}
rest = s[n:len(s)];
return;
if oldLine+delta != newLine {
return nil, SyntaxError("chunk delta is out of sync with previous chunks")
}
- delta += nnew-nold;
+ delta += nnew - nold;
c.Line = oldLine;
var old, new bytes.Buffer;
for _, c := range d {
var ok bool;
var prefix []byte;
- prefix, data, ok = getLine(data, c.Line - line);
+ prefix, data, ok = getLine(data, c.Line-line);
if !ok || !bytes.HasPrefix(data, c.Old) {
return nil, ErrPatchFailure
}
// If there is no slash in path, DirFile returns an empty dir and
// file set to path.
func Split(path string) (dir, file string) {
- for i := len(path)-1; i >= 0; i-- {
+ for i := len(path) - 1; i >= 0; i-- {
if path[i] == '/' {
return path[0 : i+1], path[i+1 : len(path)]
}
if dir == "" {
return file
}
- return Clean(dir+"/"+file);
+ return Clean(dir + "/" + file);
}
// Ext returns the file name extension used by path.
// in the final slash-separated element of path;
// it is empty if there is no dot.
func Ext(path string) string {
- for i := len(path)-1; i >= 0 && path[i] != '/'; i-- {
+ for i := len(path) - 1; i >= 0 && path[i] != '/'; i-- {
if path[i] == '.' {
return path[i:len(path)]
}
func (r *Rand) ExpFloat64() float64 {
for {
j := r.Uint32();
- i := j&0xFF;
- x := float64(j)*float64(we[i]);
+ i := j & 0xFF;
+ x := float64(j) * float64(we[i]);
if j < ke[i] {
return x
}
if i == 0 {
return re - math.Log(r.Float64())
}
- if fe[i] + float32(r.Float64())*(fe[i-1]-fe[i]) < float32(math.Exp(-x)) {
+ if fe[i]+float32(r.Float64())*(fe[i-1]-fe[i]) < float32(math.Exp(-x)) {
return x
}
}
func (r *Rand) NormFloat64() float64 {
for {
j := int32(r.Uint32()); // Possibly negative
- i := j&0x7F;
- x := float64(j)*float64(wn[i]);
+ i := j & 0x7F;
+ x := float64(j) * float64(wn[i]);
if absInt32(j) < kn[i] {
// This case should be hit better than 99% of the time.
return x
if i == 0 {
// This extra work is only required for the base strip.
for {
- x = -math.Log(r.Float64()) * (1.0/rn);
+ x = -math.Log(r.Float64()) * (1.0 / rn);
y := -math.Log(r.Float64());
if y+y >= x*x {
break
}
}
if j > 0 {
- return rn+x
+ return rn + x
}
return -rn - x;
}
- if fn[i] + float32(r.Float64())*(fn[i-1]-fn[i]) < float32(math.Exp(-.5 * x * x)) {
+ if fn[i]+float32(r.Float64())*(fn[i-1]-fn[i]) < float32(math.Exp(-.5*x*x)) {
return x
}
}
// Int returns a non-negative pseudo-random int.
func (r *Rand) Int() int {
u := uint(r.Int63());
- return int(u<<1>>1); // clear sign bit if int == int32
+ return int(u << 1 >> 1); // clear sign bit if int == int32
}
// Int63n returns, as an int64, a non-negative pseudo-random number in [0,n).
if n <= 0 {
return 0
}
- max := int64((1<<63) - 1 - (1<<63)%uint64(n));
+ max := int64((1 << 63) - 1 - (1<<63)%uint64(n));
v := r.Int63();
for v > max {
v = r.Int63()
}
- return v%n;
+ return v % n;
}
// Int31n returns, as an int32, a non-negative pseudo-random number in [0,n).
func (r *Rand) Intn(n int) int { return int(r.Int63n(int64(n))) }
// Float64 returns, as a float64, a pseudo-random number in [0.0,1.0).
-func (r *Rand) Float64() float64 { return float64(r.Int63())/(1<<63) }
+func (r *Rand) Float64() float64 { return float64(r.Int63()) / (1 << 63) }
// Float32 returns, as a float32, a pseudo-random number in [0.0,1.0).
func (r *Rand) Float32() float32 { return float32(r.Float64()) }
m[i] = i
}
for i := 0; i < n; i++ {
- j := r.Intn(i+1);
+ j := r.Intn(i + 1);
m[i], m[j] = m[j], m[i];
}
return m;
}
func nearEqual(a, b, closeEnough, maxError float64) bool {
- absDiff := math.Fabs(a-b);
+ absDiff := math.Fabs(a - b);
if absDiff < closeEnough { // Necessary when one value is zero and one value is close to zero.
return true
}
- return absDiff / max(math.Fabs(a), math.Fabs(b)) < maxError;
+ return absDiff/max(math.Fabs(a), math.Fabs(b)) < maxError;
}
var testSeeds = []int64{1, 1754801282, 1698661970, 1550503961}
for i := range samples {
sum += samples[i]
}
- res.mean = sum/float64(len(samples));
+ res.mean = sum / float64(len(samples));
var devsum float64;
for i := range samples {
- devsum += math.Pow(samples[i] - res.mean, 2)
+ devsum += math.Pow(samples[i]-res.mean, 2)
}
- res.stddev = math.Sqrt(devsum/float64(len(samples)));
+ res.stddev = math.Sqrt(devsum / float64(len(samples)));
return res;
}
}
func checkSampleSliceDistributions(t *testing.T, samples []float64, nslices int, expected *statsResults) {
- chunk := len(samples)/nslices;
+ chunk := len(samples) / nslices;
for i := 0; i < nslices; i++ {
- low := i*chunk;
+ low := i * chunk;
var high int;
if i == nslices-1 {
- high = len(samples)-1
+ high = len(samples) - 1
} else {
- high = (i+1)*chunk
+ high = (i + 1) * chunk
}
checkSampleDistribution(t, samples[low:high], expected);
}
r := New(NewSource(seed));
samples := make([]float64, nsamples);
for i := range samples {
- samples[i] = r.NormFloat64() * stddev + mean
+ samples[i] = r.NormFloat64()*stddev + mean
}
return samples;
}
func testExponentialDistribution(t *testing.T, nsamples int, rate float64, seed int64) {
//fmt.Printf("testing nsamples=%v rate=%v seed=%v\n", nsamples, rate, seed);
- mean := 1/rate;
+ mean := 1 / rate;
stddev := mean;
samples := generateExponentialSamples(nsamples, rate, seed);
//
func initNorm() (testKn []uint32, testWn, testFn []float32) {
- const m1 = 1<<31;
+ const m1 = 1 << 31;
var (
dn float64 = rn;
tn = dn;
testWn = make([]float32, 128);
testFn = make([]float32, 128);
- q := vn / math.Exp(-0.5 * dn * dn);
- testKn[0] = uint32((dn/q)*m1);
+ q := vn / math.Exp(-0.5*dn*dn);
+ testKn[0] = uint32((dn / q) * m1);
testKn[1] = 0;
- testWn[0] = float32(q/m1);
- testWn[127] = float32(dn/m1);
+ testWn[0] = float32(q / m1);
+ testWn[127] = float32(dn / m1);
testFn[0] = 1.0;
testFn[127] = float32(math.Exp(-0.5 * dn * dn));
for i := 126; i >= 1; i-- {
- dn = math.Sqrt(-2.0 * math.Log(vn/dn + math.Exp(-0.5 * dn * dn)));
- testKn[i+1] = uint32((dn/tn)*m1);
+ dn = math.Sqrt(-2.0 * math.Log(vn/dn+math.Exp(-0.5*dn*dn)));
+ testKn[i+1] = uint32((dn / tn) * m1);
tn = dn;
testFn[i] = float32(math.Exp(-0.5 * dn * dn));
- testWn[i] = float32(dn/m1);
+ testWn[i] = float32(dn / m1);
}
return;
}
func initExp() (testKe []uint32, testWe, testFe []float32) {
- const m2 = 1<<32;
+ const m2 = 1 << 32;
var (
de float64 = re;
te = de;
testFe = make([]float32, 256);
q := ve / math.Exp(-de);
- testKe[0] = uint32((de/q)*m2);
+ testKe[0] = uint32((de / q) * m2);
testKe[1] = 0;
- testWe[0] = float32(q/m2);
- testWe[255] = float32(de/m2);
+ testWe[0] = float32(q / m2);
+ testWe[255] = float32(de / m2);
testFe[0] = 1.0;
testFe[255] = float32(math.Exp(-de));
for i := 254; i >= 1; i-- {
de = -math.Log(ve/de + math.Exp(-de));
- testKe[i+1] = uint32((de/te)*m2);
+ testKe[i+1] = uint32((de / te) * m2);
te = de;
testFe[i] = float32(math.Exp(-de));
- testWe[i] = float32(de/m2);
+ testWe[i] = float32(de / m2);
}
return;
}
func compareUint32Slices(s1, s2 []uint32) int {
if len(s1) != len(s2) {
if len(s1) > len(s2) {
- return len(s2)+1
+ return len(s2) + 1
}
- return len(s1)+1;
+ return len(s1) + 1;
}
for i := range s1 {
if s1[i] != s2[i] {
func compareFloat32Slices(s1, s2 []float32) int {
if len(s1) != len(s2) {
if len(s1) > len(s2) {
- return len(s2)+1
+ return len(s2) + 1
}
- return len(s1)+1;
+ return len(s1) + 1;
}
for i := range s1 {
if !nearEqual(float64(s1[i]), float64(s2[i]), 0, 1e-7) {
const (
_LEN = 607;
_TAP = 273;
- _MAX = 1<<63;
- _MASK = _MAX-1;
+ _MAX = 1 << 63;
+ _MASK = _MAX - 1;
_A = 48271;
- _M = (1<<31)-1;
+ _M = (1 << 31) - 1;
_Q = 44488;
_R = 3399;
)
// seed rng x[n+1] = 48271 * x[n] mod (2**31 - 1)
func seedrand(x int32) int32 {
- hi := x/_Q;
- lo := x%_Q;
+ hi := x / _Q;
+ lo := x % _Q;
x = _A*lo - _R*hi;
if x < 0 {
x += _M
// Seed uses the provided seed value to initialize the generator to a deterministic state.
func (rng *rngSource) Seed(seed int64) {
rng.tap = 0;
- rng.feed = _LEN-_TAP;
+ rng.feed = _LEN - _TAP;
- seed = seed%_M;
+ seed = seed % _M;
if seed < 0 {
seed += _M
}
x = seedrand(x);
if i >= 0 {
var u int64;
- u = int64(x)<<40;
+ u = int64(x) << 40;
x = seedrand(x);
- u ^= int64(x)<<20;
+ u ^= int64(x) << 20;
x = seedrand(x);
u ^= int64(x);
u ^= rng_cooked[i];
- rng.vec[i] = u&_MASK;
+ rng.vec[i] = u & _MASK;
}
}
}
rng.feed += _LEN
}
- x := (rng.vec[rng.feed] + rng.vec[rng.tap])&_MASK;
+ x := (rng.vec[rng.feed] + rng.vec[rng.tap]) & _MASK;
rng.vec[rng.feed] = x;
return x;
}
x, y int;
}
-func (p Point) Dist(scale int) int { return p.x * p.x * scale + p.y * p.y * scale }
+func (p Point) Dist(scale int) int { return p.x*p.x*scale + p.y*p.y*scale }
func TestMethod(t *testing.T) {
// Non-curried method of type.
type ChanDir int
const (
- RecvDir ChanDir = 1<<iota;
+ RecvDir ChanDir = 1 << iota;
SendDir;
- BothDir = RecvDir|SendDir;
+ BothDir = RecvDir | SendDir;
)
// ChanType represents a channel type.
return;
}
-const inf = 1<<30 // infinity - no struct has that many nesting levels
+const inf = 1 << 30 // infinity - no struct has that many nesting levels
func (t *StructType) fieldByName(name string, mark map[*StructType]bool, depth int) (ff StructField, fd int) {
fd = inf; // field depth
// careful: i is unsigned
for i := n; i > 0; {
i--;
- *(*byte)(addr(dst+i)) = *(*byte)(addr(src+i));
+ *(*byte)(addr(dst + i)) = *(*byte)(addr(src + i));
}
case (n|src|dst)&(ptrSize-1) != 0:
// byte copy forward
for i := uintptr(0); i < n; i++ {
- *(*byte)(addr(dst+i)) = *(*byte)(addr(src+i))
+ *(*byte)(addr(dst + i)) = *(*byte)(addr(src + i))
}
default:
// word copy forward
for i := uintptr(0); i < n; i += ptrSize {
- *(*uintptr)(addr(dst+i)) = *(*uintptr)(addr(src+i))
+ *(*uintptr)(addr(dst + i)) = *(*uintptr)(addr(src + i))
}
}
}
if xn := src.Len(); n > xn {
n = xn
}
- memmove(dst.addr(), src.addr(), uintptr(n) * de.Size());
+ memmove(dst.addr(), src.addr(), uintptr(n)*de.Size());
return n;
}
if i < 0 || i >= n {
panic("index", i, "in array len", n)
}
- p := addr(uintptr(v.addr()) + uintptr(i) * typ.Size());
+ p := addr(uintptr(v.addr()) + uintptr(i)*typ.Size());
return newValue(typ, p, v.canSet);
}
}
typ := v.typ.(*SliceType);
s := new(SliceHeader);
- s.Data = uintptr(v.addr()) + uintptr(beg) * typ.Elem().Size();
- s.Len = end-beg;
- s.Cap = cap-beg;
+ s.Data = uintptr(v.addr()) + uintptr(beg)*typ.Elem().Size();
+ s.Len = end - beg;
+ s.Cap = cap - beg;
return newValue(typ, addr(s), v.canSet).(*SliceValue);
}
if i < 0 || i >= n {
panicln("index", i, "in array of length", n)
}
- p := addr(uintptr(v.addr()) + uintptr(i) * typ.Size());
+ p := addr(uintptr(v.addr()) + uintptr(i)*typ.Size());
return newValue(typ, p, v.canSet);
}
// internal send; non-blocking if b != nil
func (v *ChanValue) send(x Value, b *bool) {
t := v.Type().(*ChanType);
- if t.Dir() & SendDir == 0 {
+ if t.Dir()&SendDir == 0 {
panic("send on recv-only channel")
}
typesMustMatch(t.Elem(), x.Type());
// internal recv; non-blocking if b != nil
func (v *ChanValue) recv(b *bool) Value {
t := v.Type().(*ChanType);
- if t.Dir() & RecvDir == 0 {
+ if t.Dir()&RecvDir == 0 {
panic("recv on send-only channel")
}
ch := *(**byte)(v.addr);
for i := 0; i < nin; i++ {
tv := t.In(i);
a := uintptr(tv.Align());
- size = (size+a-1)&^(a-1);
+ size = (size + a - 1) &^ (a - 1);
size += tv.Size();
}
- size = (size + structAlign - 1)&^(structAlign - 1);
+ size = (size + structAlign - 1) &^ (structAlign - 1);
for i := 0; i < nout; i++ {
tv := t.Out(i);
a := uintptr(tv.Align());
- size = (size+a-1)&^(a-1);
+ size = (size + a - 1) &^ (a - 1);
size += tv.Size();
}
tv := v.Type();
typesMustMatch(t.In(i+delta), tv);
a := uintptr(tv.Align());
- off = (off+a-1)&^(a-1);
+ off = (off + a - 1) &^ (a - 1);
n := tv.Size();
memmove(addr(ptr+off), v.getAddr(), n);
off += n;
}
- off = (off + structAlign - 1)&^(structAlign - 1);
+ off = (off + structAlign - 1) &^ (structAlign - 1);
// Call
call(*(**byte)(fv.addr), (*byte)(addr(ptr)), uint32(size));
for i := 0; i < nout; i++ {
tv := t.Out(i);
a := uintptr(tv.Align());
- off = (off+a-1)&^(a-1);
+ off = (off + a - 1) &^ (a - 1);
v := MakeZero(tv);
n := tv.Size();
memmove(v.getAddr(), addr(ptr+off), n);
// Interface is two words: itable, data.
tab := *(**runtime.Itable)(v.addr);
- data := &value{Typeof((*byte)(nil)), addr(uintptr(v.addr)+ptrSize), true};
+ data := &value{Typeof((*byte)(nil)), addr(uintptr(v.addr) + ptrSize), true};
// Function pointer is at p.perm in the table.
fn := tab.Fn[p.perm];
return nil
}
f := t.Field(i);
- return newValue(f.Type, addr(uintptr(v.addr) + f.Offset), v.canSet && f.PkgPath == "");
+ return newValue(f.Type, addr(uintptr(v.addr)+f.Offset), v.canSet && f.PkgPath == "");
}
// FieldByIndex returns the nested field corresponding to index.
if l == 0 {
t.Log("\t<no match>")
} else {
- for i := 0; i < l; i = i+2 {
+ for i := 0; i < l; i = i + 2 {
t.Log("\t", m[i], ",", m[i+1])
}
}
if l == 0 {
t.Log("\t<no match>")
} else {
- for i := 0; i < l; i = i+2 {
+ for i := 0; i < l; i = i + 2 {
t.Logf("\t%q", m[i])
}
}
if l == 0 {
t.Log("\t<no match>")
} else {
- for i := 0; i < l; i = i+2 {
+ for i := 0; i < l; i = i + 2 {
t.Logf("\t%q", b[i])
}
}
}
for i := 0; i < cclass.ranges.Len(); i += 2 {
l := cclass.ranges.At(i);
- r := cclass.ranges.At(i+1);
+ r := cclass.ranges.At(i + 1);
if l == r {
print(" [", string(l), "]")
} else {
}
func (cclass *_CharClass) matches(c int) bool {
- for i := 0; i < cclass.ranges.Len(); i = i+2 {
+ for i := 0; i < cclass.ranges.Len(); i = i + 2 {
min := cclass.ranges.At(i);
- max := cclass.ranges.At(i+1);
+ max := cclass.ranges.At(i + 1);
if min <= c && c <= max {
return !cclass.negate
}
if p.pos >= len(p.re.expr) {
p.ch = endOfFile
} else {
- c, w := utf8.DecodeRuneInString(p.re.expr[p.pos : len(p.re.expr)]);
+ c, w := utf8.DecodeRuneInString(p.re.expr[p.pos:len(p.re.expr)]);
p.ch = c;
p.pos += w;
}
for pos <= end {
if !found {
// prime the pump if we haven't seen a match yet
- match := make([]int, 2*(re.nbra + 1));
+ match := make([]int, 2*(re.nbra+1));
for i := 0; i < len(match); i++ {
match[i] = -1 // no match seen; catches cases like "a(b)?c" on "ac"
}
s[in] = addState(s[in], st.inst.next(), st.match);
case _EBRA:
n := st.inst.(*_Ebra).n;
- st.match[2*n + 1] = pos;
+ st.match[2*n+1] = pos;
s[in] = addState(s[in], st.inst.next(), st.match);
case _ALT:
s[in] = addState(s[in], st.inst.(*_Alt).left, st.match);
// give other branch a copy of this match vector
- s1 := make([]int, 2*(re.nbra + 1));
+ s1 := make([]int, 2*(re.nbra+1));
for i := 0; i < len(s1); i++ {
s1[i] = st.match[i]
}
}
// Copy the unmatched characters before this match.
- io.WriteString(buf, src[lastMatchEnd : a[0]]);
+ io.WriteString(buf, src[lastMatchEnd:a[0]]);
// Now insert a copy of the replacement string, but not for a
// match of the empty string immediately after another match.
lastMatchEnd = a[1];
// Advance past this match; always advance at least one character.
- _, width := utf8.DecodeRuneInString(src[searchPos : len(src)]);
- if searchPos + width > a[1] {
+ _, width := utf8.DecodeRuneInString(src[searchPos:len(src)]);
+ if searchPos+width > a[1] {
searchPos += width
- } else if searchPos + 1 > a[1] {
+ } else if searchPos+1 > a[1] {
// This clause is only needed at the end of the input
// string. In that case, DecodeRuneInString returns width=0.
searchPos++
}
// Copy the unmatched characters after the last match.
- io.WriteString(buf, src[lastMatchEnd : len(src)]);
+ io.WriteString(buf, src[lastMatchEnd:len(src)]);
return buf.String();
}
}
// Copy the unmatched characters before this match.
- buf.Write(src[lastMatchEnd : a[0]]);
+ buf.Write(src[lastMatchEnd:a[0]]);
// Now insert a copy of the replacement string, but not for a
// match of the empty string immediately after another match.
lastMatchEnd = a[1];
// Advance past this match; always advance at least one character.
- _, width := utf8.DecodeRune(src[searchPos : len(src)]);
- if searchPos + width > a[1] {
+ _, width := utf8.DecodeRune(src[searchPos:len(src)]);
+ if searchPos+width > a[1] {
searchPos += width
- } else if searchPos + 1 > a[1] {
+ } else if searchPos+1 > a[1] {
// This clause is only needed at the end of the input
// string. In that case, DecodeRuneInString returns width=0.
searchPos++
}
// Copy the unmatched characters after the last match.
- buf.Write(src[lastMatchEnd : len(src)]);
+ buf.Write(src[lastMatchEnd:len(src)]);
return buf.Bytes();
}
if width > 0 {
pos += width
} else {
- pos = end+1
+ pos = end + 1
}
} else {
pos = matches[1]
// containing the matching substrings.
func (re *Regexp) AllMatches(b []byte, n int) [][]byte {
if n <= 0 {
- n = len(b)+1
+ n = len(b) + 1
}
result := make([][]byte, n);
i := 0;
// containing the matching substrings.
func (re *Regexp) AllMatchesString(s string, n int) []string {
if n <= 0 {
- n = len(s)+1
+ n = len(s) + 1
}
result := make([]string, n);
i := 0;
// channel that iterates over the matching substrings.
func (re *Regexp) AllMatchesIter(b []byte, n int) <-chan []byte {
if n <= 0 {
- n = len(b)+1
+ n = len(b) + 1
}
c := make(chan []byte, 10);
go func() {
// channel that iterates over the matching substrings.
func (re *Regexp) AllMatchesStringIter(s string, n int) <-chan string {
if n <= 0 {
- n = len(s)+1
+ n = len(s) + 1
}
c := make(chan string, 10);
go func() {
if err != nil {
return nil, err
}
- io.WriteString(conn, "CONNECT " + rpcPath + " HTTP/1.0\n\n");
+ io.WriteString(conn, "CONNECT "+rpcPath+" HTTP/1.0\n\n");
// Require successful HTTP response
// before switching to RPC protocol.
err = os.ErrorString("unexpected HTTP response: " + resp.Status)
}
conn.Close();
- return nil, &net.OpError{"dial-http", network+" "+address, nil, err};
+ return nil, &net.OpError{"dial-http", network + " " + address, nil, err};
}
// Dial connects to an RPC server at the specified network address.
if req.Method != "CONNECT" {
c.SetHeader("Content-Type", "text/plain; charset=utf-8");
c.WriteHeader(http.StatusMethodNotAllowed);
- io.WriteString(c, "405 must CONNECT to " + rpcPath + "\n");
+ io.WriteString(c, "405 must CONNECT to "+rpcPath+"\n");
return;
}
conn, _, err := c.Hijack();
log.Stderr("rpc hijacking ", c.RemoteAddr, ": ", err.String());
return;
}
- io.WriteString(conn, "HTTP/1.0 " + connected + "\n\n");
+ io.WriteString(conn, "HTTP/1.0 "+connected+"\n\n");
server.input(conn);
}
args := &Args{7, 8};
reply := new(Reply);
err = client.Call("Arith.Add", args, reply);
- if reply.C != args.A + args.B {
- t.Errorf("Add: expected %d got %d", reply.C, args.A + args.B)
+ if reply.C != args.A+args.B {
+ t.Errorf("Add: expected %d got %d", reply.C, args.A+args.B)
}
args = &Args{7, 8};
reply = new(Reply);
err = client.Call("Arith.Mul", args, reply);
- if reply.C != args.A * args.B {
- t.Errorf("Mul: expected %d got %d", reply.C, args.A * args.B)
+ if reply.C != args.A*args.B {
+ t.Errorf("Mul: expected %d got %d", reply.C, args.A*args.B)
}
// Out of order.
addCall := client.Go("Arith.Add", args, addReply, nil);
<-addCall.Done;
- if addReply.C != args.A + args.B {
- t.Errorf("Add: expected %d got %d", addReply.C, args.A + args.B)
+ if addReply.C != args.A+args.B {
+ t.Errorf("Add: expected %d got %d", addReply.C, args.A+args.B)
}
<-mulCall.Done;
- if mulReply.C != args.A * args.B {
- t.Errorf("Mul: expected %d got %d", mulReply.C, args.A * args.B)
+ if mulReply.C != args.A*args.B {
+ t.Errorf("Mul: expected %d got %d", mulReply.C, args.A*args.B)
}
// Error test
args := &Args{7, 8};
reply := new(Reply);
err = client.Call("Arith.Add", args, reply);
- if reply.C != args.A + args.B {
- t.Errorf("Add: expected %d got %d", reply.C, args.A + args.B)
+ if reply.C != args.A+args.B {
+ t.Errorf("Add: expected %d got %d", reply.C, args.A+args.B)
}
}
type ChanDir int
const (
- RecvDir ChanDir = 1<<iota; // <-chan
+ RecvDir ChanDir = 1 << iota; // <-chan
SendDir; // chan<-
- BothDir = RecvDir|SendDir; // chan
+ BothDir = RecvDir | SendDir; // chan
)
// ChanType represents a channel type.
// Insertion sort
func insertionSort(data Interface, a, b int) {
- for i := a+1; i < b; i++ {
+ for i := a + 1; i < b; i++ {
for j := i; j > a && data.Less(j, j-1); j-- {
data.Swap(j, j-1)
}
}
func doPivot(data Interface, lo, hi int) (midlo, midhi int) {
- m := (lo+hi)/2;
+ m := (lo + hi) / 2;
if hi-lo > 40 {
// Tukey's ``Ninther,'' median of three medians of three.
- s := (hi-lo)/8;
- medianOfThree(data, lo, lo+s, lo + 2*s);
+ s := (hi - lo) / 8;
+ medianOfThree(data, lo, lo+s, lo+2*s);
medianOfThree(data, m, m-s, m+s);
- medianOfThree(data, hi-1, hi-1-s, hi - 1 - 2*s);
+ medianOfThree(data, hi-1, hi-1-s, hi-1-2*s);
}
medianOfThree(data, lo, m, hi-1);
n = min(hi-d, d-c);
swapRange(data, c, hi-n, n);
- return lo+b-a, hi-(d-c);
+ return lo + b - a, hi - (d - c);
}
func quickSort(data Interface, a, b int) {
func IsSorted(data Interface) bool {
n := data.Len();
- for i := n-1; i > 0; i-- {
+ for i := n - 1; i > 0; i-- {
if data.Less(i, i-1) {
return false
}
for i := 0; i < n; i++ {
switch dist {
case _Sawtooth:
- data[i] = i%m
+ data[i] = i % m
case _Rand:
data[i] = rand.Intn(m)
case _Stagger:
- data[i] = (i*m + i)%n
+ data[i] = (i*m + i) % n
case _Plateau:
data[i] = min(i, m)
case _Shuffle:
}
case _ReverseFirstHalf:
for i := 0; i < n/2; i++ {
- mdata[i] = data[n/2 - i - 1]
+ mdata[i] = data[n/2-i-1]
}
- for i := n/2; i < n; i++ {
+ for i := n / 2; i < n; i++ {
mdata[i] = data[i]
}
case _ReverseSecondHalf:
for i := 0; i < n/2; i++ {
mdata[i] = data[i]
}
- for i := n/2; i < n; i++ {
- mdata[i] = data[n-(i - n/2)-1]
+ for i := n / 2; i < n; i++ {
+ mdata[i] = data[n-(i-n/2)-1]
}
case _Sorted:
for i := 0; i < n; i++ {
}
desc := fmt.Sprintf("n=%d m=%d dist=%s mode=%s", n, m, dists[dist], modes[mode]);
- d := &testingData{desc, t, mdata[0:n], n*lg(n)*12/10, 0};
+ d := &testingData{desc, t, mdata[0:n], n * lg(n) * 12 / 10, 0};
Sort(d);
// If we were testing C qsort, we'd have to make a copy
e = e*10 + int(s[i]) - '0'
}
}
- b.dp += e*esign;
+ b.dp += e * esign;
}
if i != len(s) {
// Minimum representable exponent is flt.bias+1.
// If the exponent is smaller, move it up and
// adjust d accordingly.
- if exp < flt.bias + 1 {
+ if exp < flt.bias+1 {
n := flt.bias + 1 - exp;
d.Shift(-n);
exp += n;
}
- if exp - flt.bias >= 1 << flt.expbits - 1 {
+ if exp-flt.bias >= 1<<flt.expbits-1 {
goto overflow
}
mant = d.Shift(int(1 + flt.mantbits)).RoundedInteger();
// Rounding might have added a bit; shift down.
- if mant == 2 << flt.mantbits {
+ if mant == 2<<flt.mantbits {
mant >>= 1;
exp++;
- if exp - flt.bias >= 1 << flt.expbits - 1 {
+ if exp-flt.bias >= 1<<flt.expbits-1 {
goto overflow
}
}
// Denormalized?
- if mant&(1 << flt.mantbits) == 0 {
+ if mant&(1<<flt.mantbits) == 0 {
exp = flt.bias
}
goto out;
overflow:
// ±Inf
mant = 0;
- exp = 1 << flt.expbits - 1 + flt.bias;
+ exp = 1<<flt.expbits - 1 + flt.bias;
overflow = true;
out:
// Assemble bits.
- bits := mant&(uint64(1) << flt.mantbits - 1);
- bits |= uint64((exp - flt.bias)&(1 << flt.expbits - 1)) << flt.mantbits;
+ bits := mant & (uint64(1)<<flt.mantbits - 1);
+ bits |= uint64((exp-flt.bias)&(1<<flt.expbits-1)) << flt.mantbits;
if neg {
bits |= 1 << flt.mantbits << flt.expbits
}
func decimalAtof64Int(neg bool, d *decimal) float64 {
f := float64(0);
for i := 0; i < d.nd; i++ {
- f = f*10 + float64(d.d[i] - '0')
+ f = f*10 + float64(d.d[i]-'0')
}
if neg {
f *= -1 // BUG work around 6g f = -f.
func decimalAtof32Int(neg bool, d *decimal) float32 {
f := float32(0);
for i := 0; i < d.nd; i++ {
- f = f*10 + float32(d.d[i] - '0')
+ f = f*10 + float32(d.d[i]-'0')
}
if neg {
f *= -1 // BUG work around 6g f = -f.
}
return f * float64pow10[k], true;
- case d.dp < d.nd && d.nd - d.dp <= 22: // int / 10^k
+ case d.dp < d.nd && d.nd-d.dp <= 22: // int / 10^k
f := decimalAtof64Int(neg, d);
- return f / float64pow10[d.nd - d.dp], true;
+ return f / float64pow10[d.nd-d.dp], true;
}
return;
}
}
return f * float32pow10[k], true;
- case d.dp < d.nd && d.nd - d.dp <= 10: // int / 10^k
+ case d.dp < d.nd && d.nd-d.dp <= 10: // int / 10^k
f := decimalAtof32Int(neg, d);
- return f / float32pow10[d.nd - d.dp], true;
+ return f / float32pow10[d.nd-d.dp], true;
}
return;
}
if base < 2 {
return 0
}
- return (1<<64 - 1)/uint64(base) + 1;
+ return (1<<64-1)/uint64(base) + 1;
}
// Btoui64 interprets a string s in an arbitrary base b (2 to 36)
var v byte;
switch {
case '0' <= s[i] && s[i] <= '9':
- v = s[i]-'0'
+ v = s[i] - '0'
case 'a' <= s[i] && s[i] <= 'z':
- v = s[i]-'a'+10
+ v = s[i] - 'a' + 10
case 'A' <= s[i] && s[i] <= 'Z':
- v = s[i]-'A'+10
+ v = s[i] - 'A' + 10
default:
n = 0;
err = os.EINVAL;
}
n *= uint64(b);
- n1 := n+uint64(v);
+ n1 := n + uint64(v);
if n1 < n {
// n+v overflows
n = 1<<64 - 1;
i = int(i1);
if int64(i) != i1 {
if i1 < 0 {
- return -1 << (IntSize-1), &NumError{s, os.ERANGE}
+ return -1 << (IntSize - 1), &NumError{s, os.ERANGE}
}
return 1<<(IntSize-1) - 1, &NumError{s, os.ERANGE};
}
atoui64Test{"01777777777777777777777", 1<<64 - 1, nil},
atoui64Test{"01777777777777777777778", 0, os.EINVAL},
atoui64Test{"02000000000000000000000", 1<<64 - 1, os.ERANGE},
- atoui64Test{"0200000000000000000000", 1<<61, nil},
+ atoui64Test{"0200000000000000000000", 1 << 61, nil},
}
type atoi64Test struct {
atoi64Test{"98765432100", 98765432100, nil},
atoi64Test{"-98765432100", -98765432100, nil},
atoi64Test{"9223372036854775807", 1<<63 - 1, nil},
- atoi64Test{"-9223372036854775807", -(1<<63 - 1), nil},
+ atoi64Test{"-9223372036854775807", -(1 << 63 - 1), nil},
atoi64Test{"9223372036854775808", 1<<63 - 1, os.ERANGE},
atoi64Test{"-9223372036854775808", -1 << 63, nil},
atoi64Test{"9223372036854775809", 1<<63 - 1, os.ERANGE},
atoi64Test{"98765432100", 98765432100, nil},
atoi64Test{"-98765432100", -98765432100, nil},
atoi64Test{"9223372036854775807", 1<<63 - 1, nil},
- atoi64Test{"-9223372036854775807", -(1<<63 - 1), nil},
+ atoi64Test{"-9223372036854775807", -(1 << 63 - 1), nil},
atoi64Test{"9223372036854775808", 1<<63 - 1, os.ERANGE},
atoi64Test{"-9223372036854775808", -1 << 63, nil},
atoi64Test{"9223372036854775809", 1<<63 - 1, os.ERANGE},
atoi32Test{"987654321", 987654321, nil},
atoi32Test{"-987654321", -987654321, nil},
atoi32Test{"2147483647", 1<<31 - 1, nil},
- atoi32Test{"-2147483647", -(1<<31 - 1), nil},
+ atoi32Test{"-2147483647", -(1 << 31 - 1), nil},
atoi32Test{"2147483648", 1<<31 - 1, os.ERANGE},
atoi32Test{"-2147483648", -1 << 31, nil},
atoi32Test{"2147483649", 1<<31 - 1, os.ERANGE},
w++;
buf[w] = '.';
w++;
- w += digitZero(buf[w : w + -a.dp]);
- w += bytes.Copy(buf[w : w + a.nd], a.d[0 : a.nd]);
+ w += digitZero(buf[w : w+-a.dp]);
+ w += bytes.Copy(buf[w:w+a.nd], a.d[0:a.nd]);
case a.dp < a.nd:
// decimal point in middle of digits
- w += bytes.Copy(buf[w : w + a.dp], a.d[0 : a.dp]);
+ w += bytes.Copy(buf[w:w+a.dp], a.d[0:a.dp]);
buf[w] = '.';
w++;
- w += bytes.Copy(buf[w : w + a.nd - a.dp], a.d[a.dp : a.nd]);
+ w += bytes.Copy(buf[w:w+a.nd-a.dp], a.d[a.dp:a.nd]);
default:
// zeros fill space between digits and decimal point
- w += bytes.Copy(buf[w : w + a.nd], a.d[0 : a.nd]);
- w += digitZero(buf[w : w + a.dp - a.nd]);
+ w += bytes.Copy(buf[w:w+a.nd], a.d[0:a.nd]);
+ w += digitZero(buf[w : w+a.dp-a.nd]);
}
return string(buf[0:w]);
}
// (They are meaningless; the decimal point is tracked
// independent of the number of digits.)
func trim(a *decimal) {
- for a.nd > 0 && a.d[a.nd - 1] == '0' {
+ for a.nd > 0 && a.d[a.nd-1] == '0' {
a.nd--
}
if a.nd == 0 {
// Write reversed decimal in buf.
n := 0;
for v > 0 {
- v1 := v/10;
- v -= 10*v1;
- buf[n] = byte(v+'0');
+ v1 := v / 10;
+ v -= 10 * v1;
+ buf[n] = byte(v + '0');
n++;
v = v1;
}
return;
}
for n>>k == 0 {
- n = n*10;
+ n = n * 10;
r++;
}
break;
c := int(a.d[r]);
n = n*10 + c - '0';
}
- a.dp -= r-1;
+ a.dp -= r - 1;
// Pick up a digit, put down a digit.
for ; r < a.nd; r++ {
c := int(a.d[r]);
- dig := n>>k;
- n -= dig<<k;
- a.d[w] = byte(dig+'0');
+ dig := n >> k;
+ n -= dig << k;
+ a.d[w] = byte(dig + '0');
w++;
n = n*10 + c - '0';
}
// Put down extra digits.
for n > 0 {
- dig := n>>k;
- n -= dig<<k;
- a.d[w] = byte(dig+'0');
+ dig := n >> k;
+ n -= dig << k;
+ a.d[w] = byte(dig + '0');
w++;
- n = n*10;
+ n = n * 10;
}
a.nd = w;
// Binary shift left (/ 2) by k bits. k <= maxShift to avoid overflow.
func leftShift(a *decimal, k uint) {
delta := leftcheats[k].delta;
- if prefixIsLessThan(a.d[0 : a.nd], leftcheats[k].cutoff) {
+ if prefixIsLessThan(a.d[0:a.nd], leftcheats[k].cutoff) {
delta--
}
// Pick up a digit, put down a digit.
for r--; r >= 0; r-- {
- n += (int(a.d[r])-'0')<<k;
- quo := n/10;
+ n += (int(a.d[r]) - '0') << k;
+ quo := n / 10;
rem := n - 10*quo;
w--;
- a.d[w] = byte(rem+'0');
+ a.d[w] = byte(rem + '0');
n = quo;
}
// Put down extra digits.
for n > 0 {
- quo := n/10;
+ quo := n / 10;
rem := n - 10*quo;
w--;
- a.d[w] = byte(rem+'0');
+ a.d[w] = byte(rem + '0');
n = quo;
}
return false
}
if a.d[nd] == '5' && nd+1 == a.nd { // exactly halfway - round to even
- return (a.d[nd-1] - '0')%2 != 0
+ return (a.d[nd-1]-'0')%2 != 0
}
// not halfway - digit tells all
return a.d[nd] >= '5';
}
// round up
- for i := nd-1; i >= 0; i-- {
+ for i := nd - 1; i >= 0; i-- {
c := a.d[i];
if c < '9' { // can stop after this digit
a.d[i]++;
- a.nd = i+1;
+ a.nd = i + 1;
return a;
}
}
var i int;
n := uint64(0);
for i = 0; i < a.dp && i < a.nd; i++ {
- n = n*10 + uint64(a.d[i] - '0')
+ n = n*10 + uint64(a.d[i]-'0')
}
for ; i < a.dp; i++ {
n *= 10
func pow2(i int) float64 {
switch {
case i < 0:
- return 1/pow2(-i)
+ return 1 / pow2(-i)
case i == 0:
return 1
case i == 1:
return 2
}
- return pow2(i/2)*pow2(i - i/2);
+ return pow2(i/2) * pow2(i-i/2);
}
// Wrapper around strconv.Atof64. Handles dddddp+ddd (binary exponent)
}
return v, true;
}
- return v*pow2(e), true;
+ return v * pow2(e), true;
}
f1, err := strconv.Atof64(s);
if err != nil {
println("bad p", a[1]);
return 0, false;
}
- return float32(float64(n)*pow2(e)), true;
+ return float32(float64(n) * pow2(e)), true;
}
f1, err1 := strconv.Atof32(s);
if err1 != nil {
}
func genericFtoa(bits uint64, fmt byte, prec int, flt *floatInfo) string {
- neg := bits >> flt.expbits >> flt.mantbits != 0;
- exp := int(bits >> flt.mantbits)&(1 << flt.expbits - 1);
- mant := bits&(uint64(1) << flt.mantbits - 1);
+ neg := bits>>flt.expbits>>flt.mantbits != 0;
+ exp := int(bits>>flt.mantbits) & (1<<flt.expbits - 1);
+ mant := bits & (uint64(1)<<flt.mantbits - 1);
switch exp {
- case 1 << flt.expbits - 1:
+ case 1<<flt.expbits - 1:
// Inf, NaN
if mant != 0 {
return "NaN"
// The shift is exp - flt.mantbits because mant is a 1-bit integer
// followed by a flt.mantbits fraction, and we are treating it as
// a 1+flt.mantbits-bit integer.
- d := newDecimal(mant).Shift(exp-int(flt.mantbits));
+ d := newDecimal(mant).Shift(exp - int(flt.mantbits));
// Round appropriately.
// Negative precision means "only as much as needed to be exact."
case 'e', 'E':
prec = d.nd - 1
case 'f':
- prec = max(d.nd - d.dp, 0)
+ prec = max(d.nd-d.dp, 0)
case 'g', 'G':
prec = d.nd
}
} else {
switch fmt {
case 'e', 'E':
- d.Round(prec+1)
+ d.Round(prec + 1)
case 'f':
d.Round(d.dp + prec)
case 'g', 'G':
if exp < -4 || exp >= eprec {
return fmtE(neg, d, prec-1, fmt+'e'-'g')
}
- return fmtF(neg, d, max(prec - d.dp, 0));
+ return fmtF(neg, d, max(prec-d.dp, 0));
}
- return "%"+string(fmt);
+ return "%" + string(fmt);
}
// Round d (= mant * 2^exp) to the shortest number of digits
// d = mant << (exp - mantbits)
// Next highest floating point number is mant+1 << exp-mantbits.
// Our upper bound is halfway inbetween, mant*2+1 << exp-mantbits-1.
- upper := newDecimal(mant*2 + 1).Shift(exp-int(flt.mantbits)-1);
+ upper := newDecimal(mant*2 + 1).Shift(exp - int(flt.mantbits) - 1);
// d = mant << (exp - mantbits)
// Next lowest floating point number is mant-1 << exp-mantbits,
minexp := flt.bias + 1; // minimum possible exponent
var mantlo uint64;
var explo int;
- if mant > 1 << flt.mantbits || exp == minexp {
- mantlo = mant-1;
+ if mant > 1<<flt.mantbits || exp == minexp {
+ mantlo = mant - 1;
explo = exp;
} else {
mantlo = mant*2 - 1;
- explo = exp-1;
+ explo = exp - 1;
}
- lower := newDecimal(mantlo*2 + 1).Shift(explo-int(flt.mantbits)-1);
+ lower := newDecimal(mantlo*2 + 1).Shift(explo - int(flt.mantbits) - 1);
// The upper and lower bounds are possible outputs only if
// the original mantissa is even, so that IEEE round-to-even
// If it's okay to do only one, do it.
switch {
case okdown && okup:
- d.Round(i+1);
+ d.Round(i + 1);
return;
case okdown:
- d.RoundDown(i+1);
+ d.RoundDown(i + 1);
return;
case okup:
- d.RoundUp(i+1);
+ d.RoundUp(i + 1);
return;
}
}
// %e: -d.ddddde±dd
func fmtE(neg bool, d *decimal, prec int, fmt byte) string {
- buf := make([]byte, 3 + max(prec, 0) + 30); // "-0." + prec digits + exp
- w := 0; // write index
+ buf := make([]byte, 3+max(prec, 0)+30); // "-0." + prec digits + exp
+ w := 0; // write index
// sign
if neg {
// %f: -ddddddd.ddddd
func fmtF(neg bool, d *decimal, prec int) string {
- buf := make([]byte, 1 + max(d.dp, 1) + 1 + max(prec, 0));
+ buf := make([]byte, 1+max(d.dp, 1)+1+max(prec, 0));
w := 0;
// sign
buf[w] = '.';
w++;
for i := 0; i < prec; i++ {
- if d.dp + i < 0 || d.dp + i >= d.nd {
+ if d.dp+i < 0 || d.dp+i >= d.nd {
buf[w] = '0'
} else {
- buf[w] = d.d[d.dp + i]
+ buf[w] = d.d[d.dp+i]
}
w++;
}
s string;
}
-func fdiv(a, b float64) float64 { return a/b } // keep compiler in the dark
+func fdiv(a, b float64) float64 { return a / b } // keep compiler in the dark
const (
below1e23 = 99999999999999974834176;
itob64Test{12345678, 10, "12345678"},
itob64Test{-987654321, 10, "-987654321"},
itob64Test{1<<31 - 1, 10, "2147483647"},
- itob64Test{-1 << 31 + 1, 10, "-2147483647"},
- itob64Test{1<<31, 10, "2147483648"},
+ itob64Test{-1<<31 + 1, 10, "-2147483647"},
+ itob64Test{1 << 31, 10, "2147483648"},
itob64Test{-1 << 31, 10, "-2147483648"},
itob64Test{1<<31 + 1, 10, "2147483649"},
- itob64Test{-1 << 31 - 1, 10, "-2147483649"},
+ itob64Test{-1<<31 - 1, 10, "-2147483649"},
itob64Test{1<<32 - 1, 10, "4294967295"},
- itob64Test{-1 << 32 + 1, 10, "-4294967295"},
- itob64Test{1<<32, 10, "4294967296"},
+ itob64Test{-1<<32 + 1, 10, "-4294967295"},
+ itob64Test{1 << 32, 10, "4294967296"},
itob64Test{-1 << 32, 10, "-4294967296"},
itob64Test{1<<32 + 1, 10, "4294967297"},
- itob64Test{-1 << 32 - 1, 10, "-4294967297"},
- itob64Test{1<<50, 10, "1125899906842624"},
+ itob64Test{-1<<32 - 1, 10, "-4294967297"},
+ itob64Test{1 << 50, 10, "1125899906842624"},
itob64Test{1<<63 - 1, 10, "9223372036854775807"},
- itob64Test{-1 << 63 + 1, 10, "-9223372036854775807"},
+ itob64Test{-1<<63 + 1, 10, "-9223372036854775807"},
itob64Test{-1 << 63, 10, "-9223372036854775808"},
itob64Test{0, 2, "0"},
itob64Test{10, 2, "1010"},
itob64Test{-1, 2, "-1"},
- itob64Test{1<<15, 2, "1000000000000000"},
+ itob64Test{1 << 15, 2, "1000000000000000"},
itob64Test{-8, 8, "-10"},
itob64Test{057635436545, 8, "57635436545"},
- itob64Test{1<<24, 8, "100000000"},
+ itob64Test{1 << 24, 8, "100000000"},
itob64Test{16, 16, "10"},
itob64Test{-0x123456789abcdef, 16, "-123456789abcdef"},
itob64Test{16, 17, "g"},
itob64Test{25, 25, "10"},
- itob64Test{(((((17*35 + 24)*35 + 21)*35 + 34)*35 + 12)*35 + 24)*35 + 32, 35, "holycow"},
- itob64Test{(((((17*36 + 24)*36 + 21)*36 + 34)*36 + 12)*36 + 24)*36 + 32, 36, "holycow"},
+ itob64Test{(((((17*35+24)*35+21)*35+34)*35+12)*35+24)*35 + 32, 35, "holycow"},
+ itob64Test{(((((17*36+24)*36+21)*36+34)*36+12)*36+24)*36 + 32, 36, "holycow"},
}
func TestItoa(t *testing.T) {
var uitob64tests = []uitob64Test{
uitob64Test{1<<63 - 1, 10, "9223372036854775807"},
- uitob64Test{1<<63, 10, "9223372036854775808"},
+ uitob64Test{1 << 63, 10, "9223372036854775808"},
uitob64Test{1<<63 + 1, 10, "9223372036854775809"},
uitob64Test{1<<64 - 2, 10, "18446744073709551614"},
uitob64Test{1<<64 - 1, 10, "18446744073709551615"},
if r < 0x10000 {
buf.WriteString(`\u`);
for j := uint(0); j < 4; j++ {
- buf.WriteByte(lowerhex[(r>>(12 - 4*j))&0xF])
+ buf.WriteByte(lowerhex[(r>>(12-4*j))&0xF])
}
} else {
buf.WriteString(`\U`);
for j := uint(0); j < 8; j++ {
- buf.WriteByte(lowerhex[(r>>(28 - 4*j))&0xF])
+ buf.WriteByte(lowerhex[(r>>(28-4*j))&0xF])
}
}
c := int(b);
switch {
case '0' <= c && c <= '9':
- return c-'0', true
+ return c - '0', true
case 'a' <= c && c <= 'f':
- return c-'a'+10, true
+ return c - 'a' + 10, true
case 'A' <= c && c <= 'F':
- return c-'A'+10, true
+ return c - 'A' + 10, true
}
return;
}
value = v;
multibyte = true;
case '0', '1', '2', '3', '4', '5', '6', '7':
- v := int(c)-'0';
+ v := int(c) - '0';
if len(s) < 2 {
err = os.EINVAL;
return;
}
for j := 0; j < 2; j++ { // one digit already; two more
- x := int(s[j])-'0';
+ x := int(s[j]) - '0';
if x < 0 || x > 7 {
return
}
- v = (v<<3)|x;
+ v = (v << 3) | x;
}
s = s[2:len(s)];
if v > 255 {
c := sep[0];
n := 0;
for i := 0; i+len(sep) <= len(s); i++ {
- if s[i] == c && (len(sep) == 1 || s[i : i+len(sep)] == sep) {
+ if s[i] == c && (len(sep) == 1 || s[i:i+len(sep)] == sep) {
n++;
- i += len(sep)-1;
+ i += len(sep) - 1;
}
}
return n;
}
c := sep[0];
for i := 0; i+n <= len(s); i++ {
- if s[i] == c && (n == 1 || s[i : i+n] == sep) {
+ if s[i] == c && (n == 1 || s[i:i+n] == sep) {
return i
}
}
return len(s)
}
c := sep[0];
- for i := len(s)-n; i >= 0; i-- {
- if s[i] == c && (n == 1 || s[i : i+n] == sep) {
+ for i := len(s) - n; i >= 0; i-- {
+ if s[i] == c && (n == 1 || s[i:i+n] == sep) {
return i
}
}
a := make([]string, n);
na := 0;
for i := 0; i+len(sep) <= len(s) && na+1 < n; i++ {
- if s[i] == c && (len(sep) == 1 || s[i : i+len(sep)] == sep) {
+ if s[i] == c && (len(sep) == 1 || s[i:i+len(sep)] == sep) {
a[na] = s[start : i+sepSave];
na++;
- start = i+len(sep);
- i += len(sep)-1;
+ start = i + len(sep);
+ i += len(sep) - 1;
}
}
a[na] = s[start:len(s)];
if len(a) == 1 {
return a[0]
}
- n := len(sep)*(len(a)-1);
+ n := len(sep) * (len(a) - 1);
for i := 0; i < len(a); i++ {
n += len(a[i])
}
// HasSuffix tests whether the string s ends with suffix.
func HasSuffix(s, suffix string) bool {
- return len(s) >= len(suffix) && s[len(s)-len(suffix) : len(s)] == suffix
+ return len(s) >= len(suffix) && s[len(s)-len(suffix):len(s)] == suffix
}
// Map returns a copy of the string s with all its characters modified
var trimSpaceTests = []StringTest{
StringTest{"", ""},
StringTest{"abc", "abc"},
- StringTest{space+"abc"+space, "abc"},
+ StringTest{space + "abc" + space, "abc"},
StringTest{" ", ""},
StringTest{" \t\r\n \t\t\r\r\n\n ", ""},
StringTest{" \t\r\n x\t\t\r\r\n\n ", "x"},
func TestCaseConsistency(t *testing.T) {
// Make a string of all the runes.
- a := make([]int, unicode.MaxRune + 1);
+ a := make([]int, unicode.MaxRune+1);
for i := range a {
a[i] = i
}
lower := ToLower(s);
// Consistency checks
- if n := utf8.RuneCountInString(upper); n != unicode.MaxRune + 1 {
+ if n := utf8.RuneCountInString(upper); n != unicode.MaxRune+1 {
t.Error("rune count wrong in upper:", n)
}
- if n := utf8.RuneCountInString(lower); n != unicode.MaxRune + 1 {
+ if n := utf8.RuneCountInString(lower); n != unicode.MaxRune+1 {
t.Error("rune count wrong in lower:", n)
}
if !equal("ToUpper(upper)", ToUpper(upper), upper, t) {
func xadd(val *uint32, delta int32) (new uint32) {
for {
v := *val;
- nv := v+uint32(delta);
+ nv := v + uint32(delta);
if cas(val, v, nv) {
return nv
}
func str(val int) string { // do it here rather than with fmt to avoid dependency
if val < 0 {
- return "-"+str(-val)
+ return "-" + str(-val)
}
var buf [32]byte; // big enough for int64
- i := len(buf)-1;
+ i := len(buf) - 1;
for val >= 10 {
buf[i] = byte(val%10 + '0');
i--;
val /= 10;
}
- buf[i] = byte(val+'0');
+ buf[i] = byte(val + '0');
return string(buf[i:len(buf)]);
}
func Errstr(errno int) string {
if errno < 0 || errno >= int(len(errors)) {
- return "error "+str(errno)
+ return "error " + str(errno)
}
return errors[errno];
}
if w&mask != exited {
return -1
}
- return int(w>>shift);
+ return int(w >> shift);
}
func (w WaitStatus) Signaled() bool { return w&mask != stopped && w&mask != 0 }
func (w WaitStatus) Signal() int {
- sig := int(w&mask);
+ sig := int(w & mask);
if sig == stopped || sig == 0 {
return -1
}
if !w.Stopped() {
return -1
}
- return int(w>>shift)&0xFF;
+ return int(w>>shift) & 0xFF;
}
func (w WaitStatus) TrapCause() int {
if n >= len(sa.raw.Path) || n == 0 {
return 0, 0, EINVAL
}
- sa.raw.Len = byte(3+n); // 2 for Family, Len; 1 for NUL
+ sa.raw.Len = byte(3 + n); // 2 for Family, Len; 1 for NUL
sa.raw.Family = AF_UNIX;
for i := 0; i < n; i++ {
sa.raw.Path[i] = int8(name[i])
return nil, EINVAL
}
sa := new(SockaddrUnix);
- n := int(pp.Len)-3; // subtract leading Family, Len, terminating NUL
+ n := int(pp.Len) - 3; // subtract leading Family, Len, terminating NUL
for i := 0; i < n; i++ {
if pp.Path[i] == 0 {
// found early NUL; assume Len is overestimating
// will silently write 2 words farther than we specify
// and we'll get memory corruption.
var buf [CTL_MAXNAME + 2]_C_int;
- n := uintptr(CTL_MAXNAME)*siz;
+ n := uintptr(CTL_MAXNAME) * siz;
p := (*byte)(unsafe.Pointer(&buf[0]));
bytes := StringByteSlice(name);
func TimespecToNsec(ts Timespec) int64 { return int64(ts.Sec)*1e9 + int64(ts.Nsec) }
func NsecToTimespec(nsec int64) (ts Timespec) {
- ts.Sec = int32(nsec/1e9);
- ts.Nsec = int32(nsec%1e9);
+ ts.Sec = int32(nsec / 1e9);
+ ts.Nsec = int32(nsec % 1e9);
return;
}
func NsecToTimeval(nsec int64) (tv Timeval) {
nsec += 999; // round up to microsecond
- tv.Usec = int32(nsec%1e9/1e3);
- tv.Sec = int32(nsec/1e9);
+ tv.Usec = int32(nsec % 1e9 / 1e3);
+ tv.Sec = int32(nsec / 1e9);
return;
}
func TimespecToNsec(ts Timespec) int64 { return int64(ts.Sec)*1e9 + int64(ts.Nsec) }
func NsecToTimespec(nsec int64) (ts Timespec) {
- ts.Sec = nsec/1e9;
- ts.Nsec = nsec%1e9;
+ ts.Sec = nsec / 1e9;
+ ts.Nsec = nsec % 1e9;
return;
}
func NsecToTimeval(nsec int64) (tv Timeval) {
nsec += 999; // round up to microsecond
- tv.Usec = int32(nsec%1e9/1e3);
- tv.Sec = int64(nsec/1e9);
+ tv.Usec = int32(nsec % 1e9 / 1e3);
+ tv.Sec = int64(nsec / 1e9);
return;
}
if !w.Exited() {
return -1
}
- return int(w>>shift)&0xFF;
+ return int(w>>shift) & 0xFF;
}
func (w WaitStatus) Signal() int {
if !w.Signaled() {
return -1
}
- return int(w&mask);
+ return int(w & mask);
}
func (w WaitStatus) StopSignal() int {
if !w.Stopped() {
return -1
}
- return int(w>>shift)&0xFF;
+ return int(w>>shift) & 0xFF;
}
func (w WaitStatus) TrapCause() int {
if w.StopSignal() != SIGTRAP {
return -1
}
- return int(w>>shift)>>8;
+ return int(w>>shift) >> 8;
}
//sys wait4(pid int, wstatus *_C_int, options int, rusage *Rusage) (wpid int, errno int)
}
// length is family, name, NUL.
- return uintptr(unsafe.Pointer(&sa.raw)), 1+_Socklen(n)+1, 0;
+ return uintptr(unsafe.Pointer(&sa.raw)), 1 + _Socklen(n) + 1, 0;
}
func anyToSockaddr(rsa *RawSockaddrAny) (Sockaddr, int) {
// boundary and not get the bytes leading up to the page
// boundary.
n := 0;
- if addr % sizeofPtr != 0 {
- errno = ptrace(req, pid, addr - addr % sizeofPtr, uintptr(unsafe.Pointer(&buf[0])));
+ if addr%sizeofPtr != 0 {
+ errno = ptrace(req, pid, addr-addr%sizeofPtr, uintptr(unsafe.Pointer(&buf[0])));
if errno != 0 {
return 0, errno
}
- n += bytesCopy(out, buf[addr % sizeofPtr : len(buf)]);
+ n += bytesCopy(out, buf[addr%sizeofPtr:len(buf)]);
out = out[n:len(out)];
}
// Leading edge.
n := 0;
- if addr % sizeofPtr != 0 {
+ if addr%sizeofPtr != 0 {
var buf [sizeofPtr]byte;
- errno = ptrace(peekReq, pid, addr - addr % sizeofPtr, uintptr(unsafe.Pointer(&buf[0])));
+ errno = ptrace(peekReq, pid, addr-addr%sizeofPtr, uintptr(unsafe.Pointer(&buf[0])));
if errno != 0 {
return 0, errno
}
- n += bytesCopy(buf[addr % sizeofPtr : len(buf)], data);
+ n += bytesCopy(buf[addr%sizeofPtr:len(buf)], data);
word := *((*uintptr)(unsafe.Pointer(&buf[0])));
- errno = ptrace(pokeReq, pid, addr - addr % sizeofPtr, word);
+ errno = ptrace(pokeReq, pid, addr-addr%sizeofPtr, word);
if errno != 0 {
return 0, errno
}
return n, errno
}
n += sizeofPtr;
- data = data[sizeofPtr : len(data)];
+ data = data[sizeofPtr:len(data)];
}
// Trailing edge.
func TimespecToNsec(ts Timespec) int64 { return int64(ts.Sec)*1e9 + int64(ts.Nsec) }
func NsecToTimespec(nsec int64) (ts Timespec) {
- ts.Sec = int32(nsec/1e9);
- ts.Nsec = int32(nsec%1e9);
+ ts.Sec = int32(nsec / 1e9);
+ ts.Nsec = int32(nsec % 1e9);
return;
}
func NsecToTimeval(nsec int64) (tv Timeval) {
nsec += 999; // round up to microsecond
- tv.Sec = int32(nsec/1e9);
- tv.Usec = int32(nsec%1e9/1e3);
+ tv.Sec = int32(nsec / 1e9);
+ tv.Usec = int32(nsec % 1e9 / 1e3);
return;
}
func TimespecToNsec(ts Timespec) int64 { return int64(ts.Sec)*1e9 + int64(ts.Nsec) }
func NsecToTimespec(nsec int64) (ts Timespec) {
- ts.Sec = nsec/1e9;
- ts.Nsec = nsec%1e9;
+ ts.Sec = nsec / 1e9;
+ ts.Nsec = nsec % 1e9;
return;
}
func NsecToTimeval(nsec int64) (tv Timeval) {
nsec += 999; // round up to microsecond
- tv.Sec = nsec/1e9;
- tv.Usec = nsec%1e9/1e3;
+ tv.Sec = nsec / 1e9;
+ tv.Usec = nsec % 1e9 / 1e3;
return;
}
func TimespecToNsec(ts Timespec) int64 { return int64(ts.Sec)*1e9 + int64(ts.Nsec) }
func NsecToTimespec(nsec int64) (ts Timespec) {
- ts.Sec = int32(nsec/1e9);
- ts.Nsec = int32(nsec%1e9);
+ ts.Sec = int32(nsec / 1e9);
+ ts.Nsec = int32(nsec % 1e9);
return;
}
func NsecToTimeval(nsec int64) (tv Timeval) {
nsec += 999; // round up to microsecond
- tv.Sec = int32(nsec/1e9);
- tv.Usec = int32(nsec%1e9/1e3);
+ tv.Sec = int32(nsec / 1e9);
+ tv.Usec = int32(nsec % 1e9 / 1e3);
return;
}
func (*SockaddrUnix) sockaddr() {}
const (
- AF_INET = 1+iota;
+ AF_INET = 1 + iota;
AF_INET6;
AF_UNIX;
IPPROTO_TCP;
func Getpagesize() int { return 4096 }
func NsecToTimeval(nsec int64) (tv Timeval) {
- tv.Sec = int32(nsec/1e9);
- tv.Usec = int32(nsec%1e9/1e3);
+ tv.Sec = int32(nsec / 1e9);
+ tv.Usec = int32(nsec % 1e9 / 1e3);
return;
}
func NsecToTimespec(nsec int64) (ts Timespec) {
- ts.Sec = int32(nsec/1e9);
- ts.Nsec = int32(nsec%1e9);
+ ts.Sec = int32(nsec / 1e9);
+ ts.Nsec = int32(nsec % 1e9);
return;
}
const (
// Ignore html tags and treat entities (starting with '&'
// and ending in ';') as single characters (width = 1).
- FilterHTML uint = 1<<iota;
+ FilterHTML uint = 1 << iota;
// Force right-alignment of cell content.
// Default is left-alignment.
b.output = output;
b.cellwidth = cellwidth;
b.padding = padding;
- for i := len(b.padbytes)-1; i >= 0; i-- {
+ for i := len(b.padbytes) - 1; i >= 0; i-- {
b.padbytes[i] = padchar
}
if padchar == '\t' {
cellw = ((cellw + b.cellwidth - 1) / b.cellwidth) * b.cellwidth
}
- n := cellw-textw;
+ n := cellw - textw;
if n < 0 {
panic("internal error")
}
for j := 0; j < line.Len(); j++ {
c := line.At(j).(cell);
- if j > 0 && b.flags & Debug != 0 {
+ if j > 0 && b.flags&Debug != 0 {
if err = b.write0(vbar); err != nil {
return
}
switch {
default: // align left
- if err = b.write0(b.buf.Bytes()[pos : pos + c.size]); err != nil {
+ if err = b.write0(b.buf.Bytes()[pos : pos+c.size]); err != nil {
return
}
pos += c.size;
}
}
- case b.flags & AlignRight != 0: // align right
+ case b.flags&AlignRight != 0: // align right
if j < b.widths.Len() {
if err = b.writePadding(c.width, b.widths.At(j)); err != nil {
return
}
}
- if err = b.write0(b.buf.Bytes()[pos : pos + c.size]); err != nil {
+ if err = b.write0(b.buf.Bytes()[pos : pos+c.size]); err != nil {
return
}
pos += c.size;
if i+1 == b.lines.Len() {
// last buffered line - we don't have a newline, so just write
// any outstanding buffered data
- if err = b.write0(b.buf.Bytes()[pos : pos + b.cell.size]); err != nil {
+ if err = b.write0(b.buf.Bytes()[pos : pos+b.cell.size]); err != nil {
return
}
pos += b.cell.size;
for this := line0; this < line1; this++ {
line := b.line(this);
- if column < line.Len() - 1 {
+ if column < line.Len()-1 {
// cell exists in this column => this line
// has more cells than the previous line
// (the last cell per line is ignored because cells are
discardable := true; // true if all cells in this column are empty and "soft"
for ; this < line1; this++ {
line = b.line(this);
- if column < line.Len() - 1 {
+ if column < line.Len()-1 {
// cell exists in this column
c := line.At(column).(cell);
// update width
// column block end
// discard empty columns if necessary
- if discardable && b.flags & DiscardEmptyColumns != 0 {
+ if discardable && b.flags&DiscardEmptyColumns != 0 {
width = 0
}
// Update the cell width.
func (b *Writer) updateWidth() {
- b.cell.width += utf8.RuneCount(b.buf.Bytes()[b.pos : b.buf.Len()]);
+ b.cell.width += utf8.RuneCount(b.buf.Bytes()[b.pos:b.buf.Len()]);
b.pos = b.buf.Len();
}
// end of cell
b.append(buf[n:i]);
b.updateWidth();
- n = i+1; // ch consumed
+ n = i + 1; // ch consumed
ncells := b.terminateCell(ch == '\t');
if ch == '\n' || ch == '\f' {
// terminate line
// start of escaped sequence
b.append(buf[n:i]);
b.updateWidth();
- n = i+1; // exclude Escape
+ n = i + 1; // exclude Escape
b.startEscape(Escape);
case '<', '&':
// possibly an html tag/entity
- if b.flags & FilterHTML != 0 {
+ if b.flags&FilterHTML != 0 {
// begin of tag/entity
b.append(buf[n:i]);
b.updateWidth();
// inside escape
if ch == b.endChar {
// end of tag/entity
- j := i+1;
+ j := i + 1;
if ch == Escape {
j = i // exclude Escape
}
b.append(buf[n:j]);
- n = i+1; // ch consumed
+ n = i + 1; // ch consumed
b.endEscape();
}
}
// write byte-by-byte
b.clear();
for i := 0; i < len(src); i++ {
- write(t, testname, &w, src[i : i+1])
+ write(t, testname, &w, src[i:i+1])
}
verify(t, testname, &w, &b, src, expected);
// write using Fibonacci slice sizes
b.clear();
for i, d := 0, 0; i < len(src); {
- write(t, testname, &w, src[i : i+d]);
+ write(t, testname, &w, src[i:i+d]);
i, d = i+d, d+1;
if i+d > len(src) {
- d = len(src)-i
+ d = len(src) - i
}
}
verify(t, testname, &w, &b, src, expected);
}
w.Write(s[last:i]);
w.Write(esc);
- last = i+1;
+ last = i + 1;
}
w.Write(s[last:len(s)]);
}
sawLeft := false; // are we waiting for an opening delimiter?
special := false; // is this a {.foo} directive, which means trim white space?
// Delete surrounding white space if this {.foo} is the only thing on the line.
- trim_white := t.p == 0 || t.buf[t.p - 1] == '\n';
+ trim_white := t.p == 0 || t.buf[t.p-1] == '\n';
only_white := true; // we have seen only white space so far
var i int;
start := t.p;
break Loop
}
// is it a directive or comment?
- j := i+len(t.ldelim); // position after delimiter
+ j := i + len(t.ldelim); // position after delimiter
if j+1 < len(t.buf) && (t.buf[j] == '.' || t.buf[j] == '#') {
special = true;
if trim_white && only_white {
break Loop
}
sawLeft = true;
- i = j-1;
+ i = j - 1;
case equal(t.buf, i, t.rdelim):
if !sawLeft {
t.parseError("unmatched closing delimiter");
switch elem := t.elems.At(i).(type) {
case *textElement:
st.wr.Write(elem.text);
- return i+1;
+ return i + 1;
case *literalElement:
st.wr.Write(elem.text);
- return i+1;
+ return i + 1;
case *variableElement:
t.writeVariable(elem, st);
- return i+1;
+ return i + 1;
case *sectionElement:
t.executeSection(elem, st);
return elem.end;
continue
}
ct, ok := ft.Out(0).(*reflect.ChanType);
- if !ok || ct.Dir() & reflect.RecvDir == 0 {
+ if !ok || ct.Dir()&reflect.RecvDir == 0 {
continue
}
return fv.Call(nil)[0].(*reflect.ChanValue);
for i := 0; i < len(s); i++ {
c := s[i];
if 'a' <= c && c <= 'z' {
- c = c+'A'-'a'
+ c = c + 'A' - 'a'
}
t += string(c);
}
func plus1(v interface{}) string {
i := v.(int);
- return fmt.Sprint(i+1);
+ return fmt.Sprint(i + 1);
}
func writer(f func(interface{}) string) (func(io.Writer, interface{}, string)) {
var b bytes.Buffer;
err = tmpl.Execute("hello", &b);
s := b.String();
- if s != "template: hello" + ldelim + rdelim {
+ if s != "template: hello"+ldelim+rdelim {
t.Errorf("failed delim check(%q %q) %q got %q", ldelim, rdelim, text, s)
}
}
// randFloat32 generates a random float taking the full range of a float32.
func randFloat32(rand *rand.Rand) float32 {
f := rand.Float64() * math.MaxFloat32;
- if rand.Int() & 1 == 1 {
+ if rand.Int()&1 == 1 {
f = -f
}
return float32(f);
// randFloat64 generates a random float taking the full range of a float64.
func randFloat64(rand *rand.Rand) float64 {
f := rand.Float64();
- if rand.Int() & 1 == 1 {
+ if rand.Int()&1 == 1 {
f = -f
}
return f;
switch concrete := t.(type) {
case *reflect.BoolType:
- return reflect.NewValue(rand.Int() & 1 == 0), true
+ return reflect.NewValue(rand.Int()&1 == 0), true
case *reflect.Float32Type:
return reflect.NewValue(randFloat32(rand)), true
case *reflect.Float64Type:
}
if !f.Call(arguments)[0].(*reflect.BoolValue).Get() {
- err = &CheckError{i+1, toInterfaces(arguments)};
+ err = &CheckError{i + 1, toInterfaces(arguments)};
return;
}
}
yOut := toInterfaces(y.Call(arguments));
if !reflect.DeepEqual(xOut, yOut) {
- err = &CheckEqualError{CheckError{i+1, toInterfaces(arguments)}, xOut, yOut};
+ err = &CheckEqualError{CheckError{i + 1, toInterfaces(arguments)}, xOut, yOut};
return;
}
}
}
func (cclass *_CharClass) matches(c int) bool {
- for i := 0; i < len(cclass.ranges); i = i+2 {
+ for i := 0; i < len(cclass.ranges); i = i + 2 {
min := cclass.ranges[i];
max := cclass.ranges[i+1];
if min <= c && c <= max {
if p.pos >= len(p.re.expr) {
p.ch = endOfFile
} else {
- c, w := utf8.DecodeRuneInString(p.re.expr[p.pos : len(p.re.expr)]);
+ c, w := utf8.DecodeRuneInString(p.re.expr[p.pos:len(p.re.expr)]);
p.ch = c;
p.pos += w;
}
for pos <= end {
if !found {
// prime the pump if we haven't seen a match yet
- match := make([]int, 2*(re.nbra + 1));
+ match := make([]int, 2*(re.nbra+1));
for i := 0; i < len(match); i++ {
match[i] = -1 // no match seen; catches cases like "a(b)?c" on "ac"
}
s[in] = addState(s[in], st.inst.next(), st.match);
case _EBRA:
n := st.inst.(*_Ebra).n;
- st.match[2*n + 1] = pos;
+ st.match[2*n+1] = pos;
s[in] = addState(s[in], st.inst.next(), st.match);
case _ALT:
s[in] = addState(s[in], st.inst.(*_Alt).left, st.match);
// give other branch a copy of this match vector
- s1 := make([]int, 2*(re.nbra + 1));
+ s1 := make([]int, 2*(re.nbra+1));
for i := 0; i < len(s1); i++ {
s1[i] = st.match[i]
}
if l == 0 {
t.Log("\t<no match>")
} else {
- for i := 0; i < l; i = i+2 {
+ for i := 0; i < l; i = i + 2 {
t.Log("\t", m[i], ",", m[i+1])
}
}
if l == 0 {
t.Log("\t<no match>")
} else {
- for i := 0; i < l; i = i+2 {
+ for i := 0; i < l; i = i + 2 {
t.Logf("\t%q", m[i])
}
}
if l == 0 {
t.Log("\t<no match>")
} else {
- for i := 0; i < l; i = i+2 {
+ for i := 0; i < l; i = i + 2 {
t.Logf("\t%q", b[i])
}
}
}
for i := 0; i < n-1; i++ { // -1 to avoid final newline
if s[i] == '\n' {
- return s[0 : i+1]+"\t"+tabify(s[i+1 : n])
+ return s[0:i+1] + "\t" + tabify(s[i+1:n])
}
}
return s;
// Log formats its arguments using default formatting, analogous to Print(),
// and records the text in the error log.
-func (t *T) Log(args ...) { t.errors += "\t"+tabify(fmt.Sprintln(args)) }
+func (t *T) Log(args ...) { t.errors += "\t" + tabify(fmt.Sprintln(args)) }
// Log formats its arguments according to the format, analogous to Printf(),
// and records the text in the error log.
func (t *T) Logf(format string, args ...) {
- t.errors += "\t"+tabify(fmt.Sprintf(format, args))
+ t.errors += "\t" + tabify(fmt.Sprintf(format, args))
}
// Error is equivalent to Log() followed by Fail().
// if c <- now took too long, skip ahead
if when < now {
// one big step
- when += (now-when) / t.ns * t.ns
+ when += (now - when) / t.ns * t.ns
}
for when <= now {
// little steps until when > now
when += t.ns
}
- Sleep(when-now);
+ Sleep(when - now);
now = Nanoseconds();
if t.shutdown {
return
func TestTicker(t *testing.T) {
const (
- Delta = 100*1e6;
+ Delta = 100 * 1e6;
Count = 10;
)
ticker := NewTicker(Delta);
}
ticker.Stop();
t1 := Nanoseconds();
- ns := t1-t0;
- target := int64(Delta*Count);
- slop := target*2/10;
+ ns := t1 - t0;
+ target := int64(Delta * Count);
+ slop := target * 2 / 10;
if ns < target-slop || ns > target+slop {
t.Fatalf("%d ticks of %g ns took %g ns, expected %g", Count, float64(Delta), float64(ns), float64(target))
}
// Now test that the ticker stopped
- Sleep(2*Delta);
+ Sleep(2 * Delta);
_, received := <-ticker.C;
if received {
t.Fatalf("Ticker did not shut down")
}
const (
- secondsPerDay = 24*60*60;
+ secondsPerDay = 24 * 60 * 60;
daysPer400Years = 365*400 + 97;
daysPer100Years = 365*100 + 24;
daysPer4Years = 365*4 + 1;
}
// Time
- t.Hour = int(sec/3600);
- t.Minute = int((sec/60)%60);
- t.Second = int(sec%60);
+ t.Hour = int(sec / 3600);
+ t.Minute = int((sec / 60) % 60);
+ t.Second = int(sec % 60);
// Day 0 = January 1, 1970 was a Thursday
- t.Weekday = int((day+Thursday)%7);
+ t.Weekday = int((day + Thursday) % 7);
if t.Weekday < 0 {
t.Weekday += 7
}
year := int64(2001);
if day < 0 {
// Go back enough 400 year cycles to make day positive.
- n := -day / daysPer400Years + 1;
- year -= 400*n;
+ n := -day/daysPer400Years + 1;
+ year -= 400 * n;
day += daysPer400Years * n;
} else {
// Cut off 400 year cycles.
n := day / daysPer400Years;
- year += 400*n;
+ year += 400 * n;
day -= daysPer400Years * n;
}
// Cut off 100-year cycles
n := day / daysPer100Years;
- year += 100*n;
+ year += 100 * n;
day -= daysPer100Years * n;
// Cut off 4-year cycles
n = day / daysPer4Years;
- year += 4*n;
+ year += 4 * n;
day -= daysPer4Years * n;
// Cut off non-leap years.
- n = day/365;
+ n = day / 365;
year += n;
- day -= 365*n;
+ day -= 365 * n;
t.Year = year;
for m = 0; m < 12 && yday >= months[m]; m++ {
yday -= months[m]
}
- t.Month = m+1;
- t.Day = yday+1;
+ t.Month = m + 1;
+ t.Day = yday + 1;
t.Zone = "UTC";
return t;
// into a parsed Time value in the local time zone.
func SecondsToLocalTime(sec int64) *Time {
z, offset := lookupTimezone(sec);
- t := SecondsToUTC(sec+int64(offset));
+ t := SecondsToUTC(sec + int64(offset));
t.Zone = z;
t.ZoneOffset = offset;
return t;
year := t.Year;
if year < 2001 {
n := (2001-year)/400 + 1;
- year += 400*n;
+ year += 400 * n;
day -= daysPer400Years * n;
}
// Add in days from 400-year cycles.
- n := (year-2001)/400;
- year -= 400*n;
+ n := (year - 2001) / 400;
+ year -= 400 * n;
day += daysPer400Years * n;
// Add in 100-year cycles.
- n = (year-2001)/100;
- year -= 100*n;
+ n = (year - 2001) / 100;
+ year -= 100 * n;
day += daysPer100Years * n;
// Add in 4-year cycles.
- n = (year-2001)/4;
- year -= 4*n;
+ n = (year - 2001) / 4;
+ year -= 4 * n;
day += daysPer4Years * n;
// Add in non-leap years.
- n = year-2001;
- day += 365*n;
+ n = year - 2001;
+ day += 365 * n;
// Add in days this year.
months := months(t.Year);
- for m := 0; m < t.Month - 1; m++ {
+ for m := 0; m < t.Month-1; m++ {
day += int64(months[m])
}
day += int64(t.Day - 1);
sec := day * secondsPerDay;
// Add in time elapsed today.
- sec += int64(t.Hour)*3600;
- sec += int64(t.Minute)*60;
+ sec += int64(t.Hour) * 3600;
+ sec += int64(t.Minute) * 60;
sec += int64(t.Second);
// Convert from seconds since 2001 to seconds since 1970.
if n < 0 {
n = 0
}
- for i := len(dst)-1; i >= 0; i-- {
+ for i := len(dst) - 1; i >= 0; i-- {
dst[i] = byte(n%10 + '0');
n /= 10;
}
func addString(buf []byte, bp int, s string) int {
n := len(s);
- copy(buf[bp : bp+n], s);
- return bp+n;
+ copy(buf[bp:bp+n], s);
+ return bp + n;
}
// Just enough of strftime to implement the date formats below.
case 'b': // %b abbreviated month name
bp = addString(buf, bp, shortMonthNames[t.Month])
case 'd': // %d day of month (01-31)
- decimal(buf[bp : bp+2], t.Day);
+ decimal(buf[bp:bp+2], t.Day);
bp += 2;
case 'e': // %e day of month ( 1-31)
if t.Day >= 10 {
- decimal(buf[bp : bp+2], t.Day)
+ decimal(buf[bp:bp+2], t.Day)
} else {
buf[bp] = ' ';
buf[bp+1] = byte(t.Day + '0');
}
bp += 2;
case 'H': // %H hour 00-23
- decimal(buf[bp : bp+2], t.Hour);
+ decimal(buf[bp:bp+2], t.Hour);
bp += 2;
case 'M': // %M minute 00-59
- decimal(buf[bp : bp+2], t.Minute);
+ decimal(buf[bp:bp+2], t.Minute);
bp += 2;
case 'S': // %S second 00-59
- decimal(buf[bp : bp+2], t.Second);
+ decimal(buf[bp:bp+2], t.Second);
bp += 2;
case 'Y': // %Y year 2008
- decimal(buf[bp : bp+4], int(t.Year));
+ decimal(buf[bp:bp+4], int(t.Year));
bp += 4;
case 'y': // %y year 08
- decimal(buf[bp : bp+2], int(t.Year % 100));
+ decimal(buf[bp:bp+2], int(t.Year%100));
bp += 2;
case 'Z':
bp = addString(buf, bp, t.Zone)
}
// Transition times.
- txtimes := data{d.read(n[NTime]*4), false};
+ txtimes := data{d.read(n[NTime] * 4), false};
// Time zone indices for transition times.
txzones := d.read(n[NTime]);
// Zone info structures
- zonedata := data{d.read(n[NZone]*6), false};
+ zonedata := data{d.read(n[NZone] * 6), false};
// Time zone abbreviations.
abbrev := d.read(n[NChar]);
// Leap-second time pairs
- d.read(n[NLeap]*8);
+ d.read(n[NLeap] * 8);
// Whether tx times associated with local time types
// are specified as standard time or wall time.
case err == os.ENOENV:
zones, _ = readinfofile("/etc/localtime")
case len(tz) > 0:
- zones, _ = readinfofile(zoneDir+tz)
+ zones, _ = readinfofile(zoneDir + tz)
case len(tz) == 0:
// do nothing: use UTC
}
// Binary search for entry with largest time <= sec
tz := zones;
for len(tz) > 1 {
- m := len(tz)/2;
+ m := len(tz) / 2;
if sec < int64(tz[m].time) {
tz = tz[0:m]
} else {
// this CaseRange represents a sequence of the form (say)
// Upper Lower Upper Lower.
const (
- UpperLower = MaxRune+1; // (Cannot be a valid delta.)
+ UpperLower = MaxRune + 1; // (Cannot be a valid delta.)
)
// Is tests whether rune is in the specified table of ranges.
if rune < r.Lo {
return false
}
- return (rune - r.Lo) % r.Stride == 0;
+ return (rune-r.Lo)%r.Stride == 0;
}
return false;
}
m := lo + (hi-lo)/2;
r := ranges[m];
if r.Lo <= rune && rune <= r.Hi {
- return (rune - r.Lo) % r.Stride == 0
+ return (rune-r.Lo)%r.Stride == 0
}
if rune < r.Lo {
hi = m
} else {
- lo = m+1
+ lo = m + 1
}
}
return false;
// IsLetter reports whether the rune is a letter.
func IsLetter(rune int) bool {
if rune < 0x80 { // quick ASCII check
- rune &^= 'a'-'A';
+ rune &^= 'a' - 'A';
return 'A' <= rune && rune <= 'Z';
}
return Is(Letter, rune);
// bit in the sequence offset.
// The constants UpperCase and TitleCase are even while LowerCase
// is odd so we take the low bit from _case.
- return r.Lo + ((rune - r.Lo)&^1 | _case&1)
+ return r.Lo + ((rune-r.Lo)&^1 | _case&1)
}
- return rune+delta;
+ return rune + delta;
}
if rune < r.Lo {
hi = m
} else {
- lo = m+1
+ lo = m + 1
}
}
return rune;
func ToUpper(rune int) int {
if rune < 0x80 { // quick ASCII check
if 'a' <= rune && rune <= 'z' {
- rune -= 'a'-'A'
+ rune -= 'a' - 'A'
}
return rune;
}
func ToLower(rune int) int {
if rune < 0x80 { // quick ASCII check
if 'A' <= rune && rune <= 'Z' {
- rune += 'a'-'A'
+ rune += 'a' - 'A'
}
return rune;
}
func ToTitle(rune int) int {
if rune < 0x80 { // quick ASCII check
if 'a' <= rune && rune <= 'z' { // title case is upper case for ASCII
- rune -= 'a'-'A'
+ rune -= 'a' - 'A'
}
return rune;
}
// errors
caseT{-1, '\n', 0xFFFD},
caseT{UpperCase, -1, -1},
- caseT{UpperCase, 1<<30, 1<<30},
+ caseT{UpperCase, 1 << 30, 1 << 30},
// ASCII (special-cased so test carefully)
caseT{UpperCase, '\n', '\n'},
"test existing tables; can be used to compare web data with package data")
var scriptRe = regexp.MustCompile(`([0-9A-F]+)(\.\.[0-9A-F]+)? *; ([A-Za-z_]+)`)
-var die = log.New(os.Stderr, nil, "", log.Lexit | log.Lshortfile)
+var die = log.New(os.Stderr, nil, "", log.Lexit|log.Lshortfile)
var category = map[string]bool{"letter": true} // Nd Lu etc. letter is a special case
func loadChars() {
if *dataURL == "" {
- flag.Set("data", *url + "UnicodeData.txt")
+ flag.Set("data", *url+"UnicodeData.txt")
}
resp, _, err := http.Get(*dataURL);
if err != nil {
if first == 0 {
die.Logf("bad state last at U+%04X", lastChar)
}
- for i := first+1; i <= lastChar; i++ {
+ for i := first + 1; i <= lastChar; i++ {
chars[i] = chars[first];
chars[i].codePoint = i;
}
break;
}
// set stride
- stride = next-lo;
+ stride = next - lo;
// check for length of run. next points to first jump in stride
for i := next; i < len(chars); i++ {
- if inCategory(i) == (((i-lo)%stride) == 0) {
+ if inCategory(i) == (((i - lo) % stride) == 0) {
// accept
if inCategory(i) {
hi = i
}
fmt.Printf(format, lo, hi, stride);
// next range: start looking where this range ends
- next = hi+1;
+ next = hi + 1;
}
fmt.Print("}\n\n");
}
s := make([]unicode.Range, 0, len(r));
j := 0;
for i := 0; i < len(r); i++ {
- if j > 0 && int(r[i].lo) == s[j-1].Hi + 1 {
+ if j > 0 && int(r[i].lo) == s[j-1].Hi+1 {
s[j-1].Hi = int(r[i].hi)
} else {
s = s[0 : j+1];
}
die.Log(err);
}
- parseScript(line[0 : len(line)-1], table);
+ parseScript(line[0:len(line)-1], table);
}
resp.Body.Close();
}
const (
- CaseUpper = 1<<iota;
+ CaseUpper = 1 << iota;
CaseLower;
CaseTitle;
CaseNone = 0; // must be zero
c, d = d, c
}
switch {
- case d.point != c.point + 1: // code points not adjacent (shouldn't happen)
+ case d.point != c.point+1: // code points not adjacent (shouldn't happen)
return false
case d._case != c._case: // different cases
return c.upperLowerAdjacent(d)
}
if rune <= _Rune2Max {
- p[0] = _T2|byte(rune>>6);
+ p[0] = _T2 | byte(rune>>6);
p[1] = _Tx | byte(rune)&_Maskx;
return 2;
}
}
if rune <= _Rune3Max {
- p[0] = _T3|byte(rune>>12);
+ p[0] = _T3 | byte(rune>>12);
p[1] = _Tx | byte(rune>>6)&_Maskx;
p[2] = _Tx | byte(rune)&_Maskx;
return 3;
}
- p[0] = _T4|byte(rune>>18);
+ p[0] = _T4 | byte(rune>>18);
p[1] = _Tx | byte(rune>>12)&_Maskx;
p[2] = _Tx | byte(rune>>6)&_Maskx;
p[3] = _Tx | byte(rune)&_Maskx;
}
rune, size = DecodeRune(b[0 : len(b)-1]);
if rune != RuneError || size != wantsize {
- t.Errorf("DecodeRune(%q) = 0x%04x, %d want 0x%04x, %d", b[0 : len(b)-1], rune, size, RuneError, wantsize)
+ t.Errorf("DecodeRune(%q) = 0x%04x, %d want 0x%04x, %d", b[0:len(b)-1], rune, size, RuneError, wantsize)
}
s = m.str[0 : len(m.str)-1];
rune, size = DecodeRuneInString(s);
// Grow slice.
n := v.Len();
if n >= v.Cap() {
- ncap := 2*n;
+ ncap := 2 * n;
if ncap < 4 {
ncap = 4
}
reflect.ArrayCopy(new, v);
v.Set(new);
}
- v.SetLen(n+1);
+ v.SetLen(n + 1);
// Recur to read element into slice.
if err := p.unmarshal(v.Elem(n), start); err != nil {
ns := "";
i := strings.LastIndex(tag, " ");
if i >= 0 {
- ns, tag = tag[0:i], tag[i+1 : len(tag)]
+ ns, tag = tag[0:i], tag[i+1:len(tag)]
}
if tag != start.Name.Local {
return UnmarshalError("expected element type <" + tag + "> but have <" + start.Name.Local + ">")
unicode.Range{0x1163, 0x1169, 2},
unicode.Range{0x116D, 0x116E, 1},
unicode.Range{0x1172, 0x1173, 1},
- unicode.Range{0x1175, 0x119E, 0x119E-0x1175},
- unicode.Range{0x11A8, 0x11AB, 0x11AB-0x11A8},
+ unicode.Range{0x1175, 0x119E, 0x119E - 0x1175},
+ unicode.Range{0x11A8, 0x11AB, 0x11AB - 0x11A8},
unicode.Range{0x11AE, 0x11AF, 1},
unicode.Range{0x11B7, 0x11B8, 1},
unicode.Range{0x11BA, 0x11BA, 1},
unicode.Range{0x11BC, 0x11C2, 1},
- unicode.Range{0x11EB, 0x11F0, 0x11F0-0x11EB},
+ unicode.Range{0x11EB, 0x11F0, 0x11F0 - 0x11EB},
unicode.Range{0x11F9, 0x11F9, 1},
unicode.Range{0x1E00, 0x1E9B, 1},
unicode.Range{0x1EA0, 0x1EF9, 1},
unicode.Range{0x1F20, 0x1F45, 1},
unicode.Range{0x1F48, 0x1F4D, 1},
unicode.Range{0x1F50, 0x1F57, 1},
- unicode.Range{0x1F59, 0x1F5B, 0x1F5B-0x1F59},
+ unicode.Range{0x1F59, 0x1F5B, 0x1F5B - 0x1F59},
unicode.Range{0x1F5D, 0x1F5D, 1},
unicode.Range{0x1F5F, 0x1F7D, 1},
unicode.Range{0x1F80, 0x1FB4, 1},
unicode.Range{0x05BB, 0x05BD, 1},
unicode.Range{0x05BF, 0x05BF, 1},
unicode.Range{0x05C1, 0x05C2, 1},
- unicode.Range{0x05C4, 0x0640, 0x0640-0x05C4},
+ unicode.Range{0x05C4, 0x0640, 0x0640 - 0x05C4},
unicode.Range{0x064B, 0x0652, 1},
unicode.Range{0x0660, 0x0669, 1},
unicode.Range{0x0670, 0x0670, 1},
unicode.Range{0x0FB1, 0x0FB7, 1},
unicode.Range{0x0FB9, 0x0FB9, 1},
unicode.Range{0x20D0, 0x20DC, 1},
- unicode.Range{0x20E1, 0x3005, 0x3005-0x20E1},
+ unicode.Range{0x20E1, 0x3005, 0x3005 - 0x20E1},
unicode.Range{0x302A, 0x302F, 1},
unicode.Range{0x3031, 0x3035, 1},
unicode.Range{0x3099, 0x309A, 1},