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
5package gen
6
7import (
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.
30type 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
40func (w *CodeWriter) Write(p []byte) (n int, err error) {
41	return w.buf.Write(p)
42}
43
44// NewCodeWriter returns a new CodeWriter.
45func 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.
52func (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,
66func (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.
85func (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
94func (w *CodeWriter) printf(f string, x ...interface{}) {
95	fmt.Fprintf(w, f, x...)
96}
97
98func (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.
111func (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
131func (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.
136func (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.
151func (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
178func (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.
205func (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.
278func (w *CodeWriter) WriteSlice(x interface{}) {
279	w.writeSlice(x, false)
280}
281
282// WriteArray writes an array value.
283func (w *CodeWriter) WriteArray(x interface{}) {
284	w.writeSlice(x, true)
285}
286
287func (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.
361func (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.
372func typeName(x interface{}) string {
373	t := reflect.ValueOf(x).Type()
374	return strings.Replace(fmt.Sprint(t), "main.", "", 1)
375}
376