github.com/hlts2/go@v0.0.0-20170904000733-812b34efaed8/src/math/bits/make_examples.go (about)

     1  // Copyright 2017 The Go Authors. All rights reserved.
     2  // Use of this source code is governed by a BSD-style
     3  // license that can be found in the LICENSE file.
     4  
     5  // +build ignore
     6  
     7  // This program generates example_test.go.
     8  
     9  package main
    10  
    11  import (
    12  	"bytes"
    13  	"fmt"
    14  	"go/format"
    15  	"io"
    16  	"io/ioutil"
    17  	"log"
    18  	"math/bits"
    19  	"sort"
    20  )
    21  
    22  var (
    23  	header = []byte(`// Copyright 2017 The Go Authors. All rights reserved.
    24  // Use of this source code is governed by a BSD-style
    25  // license that can be found in the LICENSE file.
    26  
    27  // Code generated by go run make_examples.go. DO NOT EDIT.
    28  
    29  package bits_test
    30  
    31  import (
    32  	"fmt"
    33  	"math/bits"
    34  )
    35  
    36  `)
    37  
    38  	exampleRegF = `
    39  func Example%s() {
    40  	fmt.Printf("%s\n", %d, bits.%s(%d))
    41  	// Output:
    42  	// %s
    43  }
    44  `
    45  	exampleRevF = `
    46  func Example%s() {
    47  	fmt.Printf("%s\n", %d)
    48  	fmt.Printf("%s\n", bits.%s(%d))
    49  	// Output:
    50  	// %s
    51  	// %s
    52  }
    53  `
    54  )
    55  
    56  func main() {
    57  	buf := bytes.NewBuffer(header)
    58  
    59  	genReg(buf)
    60  	genRev(buf)
    61  
    62  	out, err := format.Source(buf.Bytes())
    63  	if err != nil {
    64  		log.Fatal(err)
    65  	}
    66  
    67  	err = ioutil.WriteFile("example_test.go", out, 0666)
    68  	if err != nil {
    69  		log.Fatal(err)
    70  	}
    71  }
    72  
    73  func genReg(w io.Writer) {
    74  	examples := []struct {
    75  		name string
    76  		in   int
    77  		out  map[uint]interface{}
    78  	}{
    79  		{
    80  			name: "LeadingZeros",
    81  			in:   1,
    82  			out: map[uint]interface{}{
    83  				8:  bits.LeadingZeros8(1),
    84  				16: bits.LeadingZeros16(1),
    85  				32: bits.LeadingZeros32(1),
    86  				64: bits.LeadingZeros64(1),
    87  			},
    88  		}, {
    89  			name: "TrailingZeros",
    90  			in:   14,
    91  			out: map[uint]interface{}{
    92  				8:  bits.TrailingZeros8(14),
    93  				16: bits.TrailingZeros16(14),
    94  				32: bits.TrailingZeros32(14),
    95  				64: bits.TrailingZeros64(14),
    96  			},
    97  		}, {
    98  			name: "OnesCount",
    99  			in:   14,
   100  			out: map[uint]interface{}{
   101  				8:  bits.OnesCount8(14),
   102  				16: bits.OnesCount16(14),
   103  				32: bits.OnesCount32(14),
   104  				64: bits.OnesCount64(14),
   105  			},
   106  		}, {
   107  			name: "Len",
   108  			in:   8,
   109  			out: map[uint]interface{}{
   110  				8:  bits.Len8(8),
   111  				16: bits.Len16(8),
   112  				32: bits.Len32(8),
   113  				64: bits.Len64(8),
   114  			},
   115  		},
   116  	}
   117  
   118  	for _, e := range examples {
   119  		sizes := sortedSizes(e.out)
   120  
   121  		for _, size := range sizes {
   122  			fnName := fmt.Sprintf("%s%d", e.name, size)
   123  			outF := fmt.Sprintf("%s(%%0%db) = %%d", fnName, size)
   124  			out := fmt.Sprintf(outF, e.in, e.out[size])
   125  
   126  			fmt.Fprintf(w, exampleRegF, fnName, outF, e.in, fnName, e.in, out)
   127  		}
   128  	}
   129  }
   130  
   131  func genRev(w io.Writer) {
   132  	examples := []struct {
   133  		name string
   134  		in   int
   135  		out  map[uint]interface{}
   136  	}{
   137  		{
   138  			name: "Reverse",
   139  			in:   19,
   140  			out: map[uint]interface{}{
   141  				8:  bits.Reverse8(19),
   142  				16: bits.Reverse16(19),
   143  				32: bits.Reverse32(19),
   144  				64: bits.Reverse64(19),
   145  			},
   146  		},
   147  	}
   148  
   149  	for _, e := range examples {
   150  		sizes := sortedSizes(e.out)
   151  
   152  		for _, size := range sizes {
   153  			fnName := fmt.Sprintf("%s%d", e.name, size)
   154  			outF := fmt.Sprintf("%%0%db", size)
   155  			out := fmt.Sprintf(outF, e.in)
   156  			secOut := fmt.Sprintf(outF, e.out[size])
   157  
   158  			fmt.Fprintf(w, exampleRevF, fnName, outF, e.in, outF, fnName, e.in, out, secOut)
   159  		}
   160  	}
   161  }
   162  
   163  func sortedSizes(out map[uint]interface{}) []uint {
   164  	sizes := make([]uint, 0, len(out))
   165  	for size := range out {
   166  		sizes = append(sizes, size)
   167  	}
   168  
   169  	sort.Slice(sizes, func(i, j int) bool {
   170  		return sizes[i] < sizes[j]
   171  	})
   172  
   173  	return sizes
   174  }