mirror of
https://github.com/autc04/Retro68.git
synced 2024-09-08 05:54:40 +00:00
219 lines
3.7 KiB
Go
219 lines
3.7 KiB
Go
// Copyright 2009 The Go Authors. All rights reserved.
|
|
// Use of this source code is governed by a BSD-style
|
|
// license that can be found in the LICENSE file.
|
|
|
|
// +build ignore
|
|
|
|
// encgen writes the helper functions for encoding. Intended to be
|
|
// used with go generate; see the invocation in encode.go.
|
|
|
|
// TODO: We could do more by being unsafe. Add a -unsafe flag?
|
|
|
|
package main
|
|
|
|
import (
|
|
"bytes"
|
|
"flag"
|
|
"fmt"
|
|
"go/format"
|
|
"log"
|
|
"os"
|
|
)
|
|
|
|
var output = flag.String("output", "enc_helpers.go", "file name to write")
|
|
|
|
type Type struct {
|
|
lower string
|
|
upper string
|
|
zero string
|
|
encoder string
|
|
}
|
|
|
|
var types = []Type{
|
|
{
|
|
"bool",
|
|
"Bool",
|
|
"false",
|
|
`if x {
|
|
state.encodeUint(1)
|
|
} else {
|
|
state.encodeUint(0)
|
|
}`,
|
|
},
|
|
{
|
|
"complex64",
|
|
"Complex64",
|
|
"0+0i",
|
|
`rpart := floatBits(float64(real(x)))
|
|
ipart := floatBits(float64(imag(x)))
|
|
state.encodeUint(rpart)
|
|
state.encodeUint(ipart)`,
|
|
},
|
|
{
|
|
"complex128",
|
|
"Complex128",
|
|
"0+0i",
|
|
`rpart := floatBits(real(x))
|
|
ipart := floatBits(imag(x))
|
|
state.encodeUint(rpart)
|
|
state.encodeUint(ipart)`,
|
|
},
|
|
{
|
|
"float32",
|
|
"Float32",
|
|
"0",
|
|
`bits := floatBits(float64(x))
|
|
state.encodeUint(bits)`,
|
|
},
|
|
{
|
|
"float64",
|
|
"Float64",
|
|
"0",
|
|
`bits := floatBits(x)
|
|
state.encodeUint(bits)`,
|
|
},
|
|
{
|
|
"int",
|
|
"Int",
|
|
"0",
|
|
`state.encodeInt(int64(x))`,
|
|
},
|
|
{
|
|
"int16",
|
|
"Int16",
|
|
"0",
|
|
`state.encodeInt(int64(x))`,
|
|
},
|
|
{
|
|
"int32",
|
|
"Int32",
|
|
"0",
|
|
`state.encodeInt(int64(x))`,
|
|
},
|
|
{
|
|
"int64",
|
|
"Int64",
|
|
"0",
|
|
`state.encodeInt(x)`,
|
|
},
|
|
{
|
|
"int8",
|
|
"Int8",
|
|
"0",
|
|
`state.encodeInt(int64(x))`,
|
|
},
|
|
{
|
|
"string",
|
|
"String",
|
|
`""`,
|
|
`state.encodeUint(uint64(len(x)))
|
|
state.b.WriteString(x)`,
|
|
},
|
|
{
|
|
"uint",
|
|
"Uint",
|
|
"0",
|
|
`state.encodeUint(uint64(x))`,
|
|
},
|
|
{
|
|
"uint16",
|
|
"Uint16",
|
|
"0",
|
|
`state.encodeUint(uint64(x))`,
|
|
},
|
|
{
|
|
"uint32",
|
|
"Uint32",
|
|
"0",
|
|
`state.encodeUint(uint64(x))`,
|
|
},
|
|
{
|
|
"uint64",
|
|
"Uint64",
|
|
"0",
|
|
`state.encodeUint(x)`,
|
|
},
|
|
{
|
|
"uintptr",
|
|
"Uintptr",
|
|
"0",
|
|
`state.encodeUint(uint64(x))`,
|
|
},
|
|
// uint8 Handled separately.
|
|
}
|
|
|
|
func main() {
|
|
log.SetFlags(0)
|
|
log.SetPrefix("encgen: ")
|
|
flag.Parse()
|
|
if flag.NArg() != 0 {
|
|
log.Fatal("usage: encgen [--output filename]")
|
|
}
|
|
var b bytes.Buffer
|
|
fmt.Fprintf(&b, "// Created by encgen --output %s; DO NOT EDIT\n", *output)
|
|
fmt.Fprint(&b, header)
|
|
printMaps(&b, "Array")
|
|
fmt.Fprint(&b, "\n")
|
|
printMaps(&b, "Slice")
|
|
for _, t := range types {
|
|
fmt.Fprintf(&b, arrayHelper, t.lower, t.upper)
|
|
fmt.Fprintf(&b, sliceHelper, t.lower, t.upper, t.zero, t.encoder)
|
|
}
|
|
source, err := format.Source(b.Bytes())
|
|
if err != nil {
|
|
log.Fatal("source format error:", err)
|
|
}
|
|
fd, err := os.Create(*output)
|
|
_, err = fd.Write(source)
|
|
if err != nil {
|
|
log.Fatal(err)
|
|
}
|
|
}
|
|
|
|
func printMaps(b *bytes.Buffer, upperClass string) {
|
|
fmt.Fprintf(b, "var enc%sHelper = map[reflect.Kind]encHelper{\n", upperClass)
|
|
for _, t := range types {
|
|
fmt.Fprintf(b, "reflect.%s: enc%s%s,\n", t.upper, t.upper, upperClass)
|
|
}
|
|
fmt.Fprintf(b, "}\n")
|
|
}
|
|
|
|
const header = `
|
|
// Copyright 2014 The Go Authors. All rights reserved.
|
|
// Use of this source code is governed by a BSD-style
|
|
// license that can be found in the LICENSE file.
|
|
|
|
package gob
|
|
|
|
import (
|
|
"reflect"
|
|
)
|
|
|
|
`
|
|
|
|
const arrayHelper = `
|
|
func enc%[2]sArray(state *encoderState, v reflect.Value) bool {
|
|
// Can only slice if it is addressable.
|
|
if !v.CanAddr() {
|
|
return false
|
|
}
|
|
return enc%[2]sSlice(state, v.Slice(0, v.Len()))
|
|
}
|
|
`
|
|
|
|
const sliceHelper = `
|
|
func enc%[2]sSlice(state *encoderState, v reflect.Value) bool {
|
|
slice, ok := v.Interface().([]%[1]s)
|
|
if !ok {
|
|
// It is kind %[1]s but not type %[1]s. TODO: We can handle this unsafely.
|
|
return false
|
|
}
|
|
for _, x := range slice {
|
|
if x != %[3]s || state.sendZero {
|
|
%[4]s
|
|
}
|
|
}
|
|
return true
|
|
}
|
|
`
|