src/dma/vendor/golang.org/x/text/internal/gen/code.go

   1 // Copyright 2015 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 package gen
   6
   7 import (
   8         "bytes"
   9         "encoding/gob"
  10         "fmt"
  11         "hash"
  12         "hash/fnv"
  13         "io"
  14         "log"
  15         "os"
  16         "reflect"
  17         "strings"
  18         "unicode"
  19         "unicode/utf8"
  20 )
  21
  22 // This file contains utilities for generating code.
  23
  24 // TODO: other write methods like:
  25 // - slices, maps, types, etc.
  26
  27 // CodeWriter is a utility for writing structured code. It computes the content
  28 // hash and size of written content. It ensures there are newlines between
  29 // written code blocks.
  30 type CodeWriter struct {
  31         buf  bytes.Buffer
  32         Size int
  33         Hash hash.Hash32 // content hash
  34         gob  *gob.Encoder
  35         // For comments we skip the usual one-line separator if they are followed by
  36         // a code block.
  37         skipSep bool
  38 }
  39
  40 func (w *CodeWriter) Write(p []byte) (n int, err error) {
  41         return w.buf.Write(p)
  42 }
  43
  44 // NewCodeWriter returns a new CodeWriter.
  45 func NewCodeWriter() *CodeWriter {
  46         h := fnv.New32()
  47         return &CodeWriter{Hash: h, gob: gob.NewEncoder(h)}
  48 }
  49
  50 // WriteGoFile appends the buffer with the total size of all created structures
  51 // and writes it as a Go file to the given file with the given package name.
  52 func (w *CodeWriter) WriteGoFile(filename, pkg string) {
  53         f, err := os.Create(filename)
  54         if err != nil {
  55                 log.Fatalf("Could not create file %s: %v", filename, err)
  56         }
  57         defer f.Close()
  58         if _, err = w.WriteGo(f, pkg, ""); err != nil {
  59                 log.Fatalf("Error writing file %s: %v", filename, err)
  60         }
  61 }
  62
  63 // WriteVersionedGoFile appends the buffer with the total size of all created
  64 // structures and writes it as a Go file to the given file with the given
  65 // package name and build tags for the current Unicode version,
  66 func (w *CodeWriter) WriteVersionedGoFile(filename, pkg string) {
  67         tags := buildTags()
  68         if tags != "" {
  69                 pattern := fileToPattern(filename)
  70                 updateBuildTags(pattern)
  71                 filename = fmt.Sprintf(pattern, UnicodeVersion())
  72         }
  73         f, err := os.Create(filename)
  74         if err != nil {
  75                 log.Fatalf("Could not create file %s: %v", filename, err)
  76         }
  77         defer f.Close()
  78         if _, err = w.WriteGo(f, pkg, tags); err != nil {
  79                 log.Fatalf("Error writing file %s: %v", filename, err)
  80         }
  81 }
  82
  83 // WriteGo appends the buffer with the total size of all created structures and
  84 // writes it as a Go file to the given writer with the given package name.
  85 func (w *CodeWriter) WriteGo(out io.Writer, pkg, tags string) (n int, err error) {
  86         sz := w.Size
  87         if sz > 0 {
  88                 w.WriteComment("Total table size %d bytes (%dKiB); checksum: %X\n", sz, sz/1024, w.Hash.Sum32())
  89         }
  90         defer w.buf.Reset()
  91         return WriteGo(out, pkg, tags, w.buf.Bytes())
  92 }
  93
  94 func (w *CodeWriter) printf(f string, x ...interface{}) {
  95         fmt.Fprintf(w, f, x...)
  96 }
  97
  98 func (w *CodeWriter) insertSep() {
  99         if w.skipSep {
 100                 w.skipSep = false
 101                 return
 102         }
 103         // Use at least two newlines to ensure a blank space between the previous
 104         // block. WriteGoFile will remove extraneous newlines.
 105         w.printf("\n\n")
 106 }
 107
 108 // WriteComment writes a comment block. All line starts are prefixed with "//".
 109 // Initial empty lines are gobbled. The indentation for the first line is
 110 // stripped from consecutive lines.
 111 func (w *CodeWriter) WriteComment(comment string, args ...interface{}) {
 112         s := fmt.Sprintf(comment, args...)
 113         s = strings.Trim(s, "\n")
 114
 115         // Use at least two newlines to ensure a blank space between the previous
 116         // block. WriteGoFile will remove extraneous newlines.
 117         w.printf("\n\n// ")
 118         w.skipSep = true
 119
 120         // strip first indent level.
 121         sep := "\n"
 122         for ; len(s) > 0 && (s[0] == '\t' || s[0] == ' '); s = s[1:] {
 123                 sep += s[:1]
 124         }
 125
 126         strings.NewReplacer(sep, "\n// ", "\n", "\n// ").WriteString(w, s)
 127
 128         w.printf("\n")
 129 }
 130
 131 func (w *CodeWriter) writeSizeInfo(size int) {
 132         w.printf("// Size: %d bytes\n", size)
 133 }
 134
 135 // WriteConst writes a constant of the given name and value.
 136 func (w *CodeWriter) WriteConst(name string, x interface{}) {
 137         w.insertSep()
 138         v := reflect.ValueOf(x)
 139
 140         switch v.Type().Kind() {
 141         case reflect.String:
 142                 w.printf("const %s %s = ", name, typeName(x))
 143                 w.WriteString(v.String())
 144                 w.printf("\n")
 145         default:
 146                 w.printf("const %s = %#v\n", name, x)
 147         }
 148 }
 149
 150 // WriteVar writes a variable of the given name and value.
 151 func (w *CodeWriter) WriteVar(name string, x interface{}) {
 152         w.insertSep()
 153         v := reflect.ValueOf(x)
 154         oldSize := w.Size
 155         sz := int(v.Type().Size())
 156         w.Size += sz
 157
 158         switch v.Type().Kind() {
 159         case reflect.String:
 160                 w.printf("var %s %s = ", name, typeName(x))
 161                 w.WriteString(v.String())
 162         case reflect.Struct:
 163                 w.gob.Encode(x)
 164                 fallthrough
 165         case reflect.Slice, reflect.Array:
 166                 w.printf("var %s = ", name)
 167                 w.writeValue(v)
 168                 w.writeSizeInfo(w.Size - oldSize)
 169         default:
 170                 w.printf("var %s %s = ", name, typeName(x))
 171                 w.gob.Encode(x)
 172                 w.writeValue(v)
 173                 w.writeSizeInfo(w.Size - oldSize)
 174         }
 175         w.printf("\n")
 176 }
 177
 178 func (w *CodeWriter) writeValue(v reflect.Value) {
 179         x := v.Interface()
 180         switch v.Kind() {
 181         case reflect.String:
 182                 w.WriteString(v.String())
 183         case reflect.Array:
 184                 // Don't double count: callers of WriteArray count on the size being
 185                 // added, so we need to discount it here.
 186                 w.Size -= int(v.Type().Size())
 187                 w.writeSlice(x, true)
 188         case reflect.Slice:
 189                 w.writeSlice(x, false)
 190         case reflect.Struct:
 191                 w.printf("%s{\n", typeName(v.Interface()))
 192                 t := v.Type()
 193                 for i := 0; i < v.NumField(); i++ {
 194                         w.printf("%s: ", t.Field(i).Name)
 195                         w.writeValue(v.Field(i))
 196                         w.printf(",\n")
 197                 }
 198                 w.printf("}")
 199         default:
 200                 w.printf("%#v", x)
 201         }
 202 }
 203
 204 // WriteString writes a string literal.
 205 func (w *CodeWriter) WriteString(s string) {
 206         io.WriteString(w.Hash, s) // content hash
 207         w.Size += len(s)
 208
 209         const maxInline = 40
 210         if len(s) <= maxInline {
 211                 w.printf("%q", s)
 212                 return
 213         }
 214
 215         // We will render the string as a multi-line string.
 216         const maxWidth = 80 - 4 - len(`"`) - len(`" +`)
 217
 218         // When starting on its own line, go fmt indents line 2+ an extra level.
 219         n, max := maxWidth, maxWidth-4
 220
 221         // As per https://golang.org/issue/18078, the compiler has trouble
 222         // compiling the concatenation of many strings, s0 + s1 + s2 + ... + sN,
 223         // for large N. We insert redundant, explicit parentheses to work around
 224         // that, lowering the N at any given step: (s0 + s1 + ... + s63) + (s64 +
 225         // ... + s127) + etc + (etc + ... + sN).
 226         explicitParens, extraComment := len(s) > 128*1024, ""
 227         if explicitParens {
 228                 w.printf(`(`)
 229                 extraComment = "; the redundant, explicit parens are for https://golang.org/issue/18078"
 230         }
 231
 232         // Print "" +\n, if a string does not start on its own line.
 233         b := w.buf.Bytes()
 234         if p := len(bytes.TrimRight(b, " \t")); p > 0 && b[p-1] != '\n' {
 235                 w.printf("\"\" + // Size: %d bytes%s\n", len(s), extraComment)
 236                 n, max = maxWidth, maxWidth
 237         }
 238
 239         w.printf(`"`)
 240
 241         for sz, p, nLines := 0, 0, 0; p < len(s); {
 242                 var r rune
 243                 r, sz = utf8.DecodeRuneInString(s[p:])
 244                 out := s[p : p+sz]
 245                 chars := 1
 246                 if !unicode.IsPrint(r) || r == utf8.RuneError || r == '"' {
 247                         switch sz {
 248                         case 1:
 249                                 out = fmt.Sprintf("\\x%02x", s[p])
 250                         case 2, 3:
 251                                 out = fmt.Sprintf("\\u%04x", r)
 252                         case 4:
 253                                 out = fmt.Sprintf("\\U%08x", r)
 254                         }
 255                         chars = len(out)
 256                 } else if r == '\\' {
 257                         out = "\\" + string(r)
 258                         chars = 2
 259                 }
 260                 if n -= chars; n < 0 {
 261                         nLines++
 262                         if explicitParens && nLines&63 == 63 {
 263                                 w.printf("\") + (\"")
 264                         }
 265                         w.printf("\" +\n\"")
 266                         n = max - len(out)
 267                 }
 268                 w.printf("%s", out)
 269                 p += sz
 270         }
 271         w.printf(`"`)
 272         if explicitParens {
 273                 w.printf(`)`)
 274         }
 275 }
 276
 277 // WriteSlice writes a slice value.
 278 func (w *CodeWriter) WriteSlice(x interface{}) {
 279         w.writeSlice(x, false)
 280 }
 281
 282 // WriteArray writes an array value.
 283 func (w *CodeWriter) WriteArray(x interface{}) {
 284         w.writeSlice(x, true)
 285 }
 286
 287 func (w *CodeWriter) writeSlice(x interface{}, isArray bool) {
 288         v := reflect.ValueOf(x)
 289         w.gob.Encode(v.Len())
 290         w.Size += v.Len() * int(v.Type().Elem().Size())
 291         name := typeName(x)
 292         if isArray {
 293                 name = fmt.Sprintf("[%d]%s", v.Len(), name[strings.Index(name, "]")+1:])
 294         }
 295         if isArray {
 296                 w.printf("%s{\n", name)
 297         } else {
 298                 w.printf("%s{ // %d elements\n", name, v.Len())
 299         }
 300
 301         switch kind := v.Type().Elem().Kind(); kind {
 302         case reflect.String:
 303                 for _, s := range x.([]string) {
 304                         w.WriteString(s)
 305                         w.printf(",\n")
 306                 }
 307         case reflect.Int, reflect.Int8, reflect.Int16, reflect.Int32, reflect.Int64,
 308                 reflect.Uint, reflect.Uint8, reflect.Uint16, reflect.Uint32, reflect.Uint64:
 309                 // nLine and nBlock are the number of elements per line and block.
 310                 nLine, nBlock, format := 8, 64, "%d,"
 311                 switch kind {
 312                 case reflect.Uint8:
 313                         format = "%#02x,"
 314                 case reflect.Uint16:
 315                         format = "%#04x,"
 316                 case reflect.Uint32:
 317                         nLine, nBlock, format = 4, 32, "%#08x,"
 318                 case reflect.Uint, reflect.Uint64:
 319                         nLine, nBlock, format = 4, 32, "%#016x,"
 320                 case reflect.Int8:
 321                         nLine = 16
 322                 }
 323                 n := nLine
 324                 for i := 0; i < v.Len(); i++ {
 325                         if i%nBlock == 0 && v.Len() > nBlock {
 326                                 w.printf("// Entry %X - %X\n", i, i+nBlock-1)
 327                         }
 328                         x := v.Index(i).Interface()
 329                         w.gob.Encode(x)
 330                         w.printf(format, x)
 331                         if n--; n == 0 {
 332                                 n = nLine
 333                                 w.printf("\n")
 334                         }
 335                 }
 336                 w.printf("\n")
 337         case reflect.Struct:
 338                 zero := reflect.Zero(v.Type().Elem()).Interface()
 339                 for i := 0; i < v.Len(); i++ {
 340                         x := v.Index(i).Interface()
 341                         w.gob.EncodeValue(v)
 342                         if !reflect.DeepEqual(zero, x) {
 343                                 line := fmt.Sprintf("%#v,\n", x)
 344                                 line = line[strings.IndexByte(line, '{'):]
 345                                 w.printf("%d: ", i)
 346                                 w.printf(line)
 347                         }
 348                 }
 349         case reflect.Array:
 350                 for i := 0; i < v.Len(); i++ {
 351                         w.printf("%d: %#v,\n", i, v.Index(i).Interface())
 352                 }
 353         default:
 354                 panic("gen: slice elem type not supported")
 355         }
 356         w.printf("}")
 357 }
 358
 359 // WriteType writes a definition of the type of the given value and returns the
 360 // type name.
 361 func (w *CodeWriter) WriteType(x interface{}) string {
 362         t := reflect.TypeOf(x)
 363         w.printf("type %s struct {\n", t.Name())
 364         for i := 0; i < t.NumField(); i++ {
 365                 w.printf("\t%s %s\n", t.Field(i).Name, t.Field(i).Type)
 366         }
 367         w.printf("}\n")
 368         return t.Name()
 369 }
 370
 371 // typeName returns the name of the go type of x.
 372 func typeName(x interface{}) string {
 373         t := reflect.ValueOf(x).Type()
 374         return strings.Replace(fmt.Sprint(t), "main.", "", 1)
 375 }