| Server IP : 185.124.137.175 / Your IP : 216.73.216.254 Web Server : LiteSpeed System : Linux id-dci-web1986.main-hosting.eu 5.14.0-611.26.1.el9_7.x86_64 #1 SMP PREEMPT_DYNAMIC Thu Jan 29 05:24:47 EST 2026 x86_64 User : u686484674 ( 686484674) PHP Version : 8.0.30 Disable Function : system, exec, shell_exec, passthru, mysql_list_dbs, ini_alter, dl, symlink, link, chgrp, leak, popen, apache_child_terminate, virtual, mb_send_mail MySQL : OFF | cURL : ON | WGET : ON | Perl : OFF | Python : OFF | Sudo : OFF | Pkexec : OFF Directory : /opt/golang/1.22.0/src/encoding/gob/ |
Upload File : |
// 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.
//go: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", "dec_helpers.go", "file name to write")
type Type struct {
lower string
upper string
decoder string
}
var types = []Type{
{
"bool",
"Bool",
`slice[i] = state.decodeUint() != 0`,
},
{
"complex64",
"Complex64",
`real := float32FromBits(state.decodeUint(), ovfl)
imag := float32FromBits(state.decodeUint(), ovfl)
slice[i] = complex(float32(real), float32(imag))`,
},
{
"complex128",
"Complex128",
`real := float64FromBits(state.decodeUint())
imag := float64FromBits(state.decodeUint())
slice[i] = complex(real, imag)`,
},
{
"float32",
"Float32",
`slice[i] = float32(float32FromBits(state.decodeUint(), ovfl))`,
},
{
"float64",
"Float64",
`slice[i] = float64FromBits(state.decodeUint())`,
},
{
"int",
"Int",
`x := state.decodeInt()
// MinInt and MaxInt
if x < ^int64(^uint(0)>>1) || int64(^uint(0)>>1) < x {
error_(ovfl)
}
slice[i] = int(x)`,
},
{
"int16",
"Int16",
`x := state.decodeInt()
if x < math.MinInt16 || math.MaxInt16 < x {
error_(ovfl)
}
slice[i] = int16(x)`,
},
{
"int32",
"Int32",
`x := state.decodeInt()
if x < math.MinInt32 || math.MaxInt32 < x {
error_(ovfl)
}
slice[i] = int32(x)`,
},
{
"int64",
"Int64",
`slice[i] = state.decodeInt()`,
},
{
"int8",
"Int8",
`x := state.decodeInt()
if x < math.MinInt8 || math.MaxInt8 < x {
error_(ovfl)
}
slice[i] = int8(x)`,
},
{
"string",
"String",
`u := state.decodeUint()
n := int(u)
if n < 0 || uint64(n) != u || n > state.b.Len() {
errorf("length of string exceeds input size (%d bytes)", u)
}
if n > state.b.Len() {
errorf("string data too long for buffer: %d", n)
}
// Read the data.
data := state.b.Bytes()
if len(data) < n {
errorf("invalid string length %d: exceeds input size %d", n, len(data))
}
slice[i] = string(data[:n])
state.b.Drop(n)`,
},
{
"uint",
"Uint",
`x := state.decodeUint()
/*TODO if math.MaxUint32 < x {
error_(ovfl)
}*/
slice[i] = uint(x)`,
},
{
"uint16",
"Uint16",
`x := state.decodeUint()
if math.MaxUint16 < x {
error_(ovfl)
}
slice[i] = uint16(x)`,
},
{
"uint32",
"Uint32",
`x := state.decodeUint()
if math.MaxUint32 < x {
error_(ovfl)
}
slice[i] = uint32(x)`,
},
{
"uint64",
"Uint64",
`slice[i] = state.decodeUint()`,
},
{
"uintptr",
"Uintptr",
`x := state.decodeUint()
if uint64(^uintptr(0)) < x {
error_(ovfl)
}
slice[i] = uintptr(x)`,
},
// uint8 Handled separately.
}
func main() {
log.SetFlags(0)
log.SetPrefix("decgen: ")
flag.Parse()
if flag.NArg() != 0 {
log.Fatal("usage: decgen [--output filename]")
}
var b bytes.Buffer
fmt.Fprintf(&b, "// Code generated by go run decgen.go -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.decoder)
}
fmt.Fprintf(&b, trailer)
source, err := format.Source(b.Bytes())
if err != nil {
log.Fatal("source format error:", err)
}
fd, err := os.Create(*output)
if err != nil {
log.Fatal(err)
}
if _, err := fd.Write(source); err != nil {
log.Fatal(err)
}
}
func printMaps(b *bytes.Buffer, upperClass string) {
fmt.Fprintf(b, "var dec%sHelper = map[reflect.Kind]decHelper{\n", upperClass)
for _, t := range types {
fmt.Fprintf(b, "reflect.%s: dec%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 (
"math"
"reflect"
)
`
const arrayHelper = `
func dec%[2]sArray(state *decoderState, v reflect.Value, length int, ovfl error) bool {
// Can only slice if it is addressable.
if !v.CanAddr() {
return false
}
return dec%[2]sSlice(state, v.Slice(0, v.Len()), length, ovfl)
}
`
const sliceHelper = `
func dec%[2]sSlice(state *decoderState, v reflect.Value, length int, ovfl error) 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 i := 0; i < length; i++ {
if state.b.Len() == 0 {
errorf("decoding %[1]s array or slice: length exceeds input size (%%d elements)", length)
}
if i >= len(slice) {
// This is a slice that we only partially allocated.
growSlice(v, &slice, length)
}
%[3]s
}
return true
}
`
const trailer = `
// growSlice is called for a slice that we only partially allocated,
// to grow it up to length.
func growSlice[E any](v reflect.Value, ps *[]E, length int) {
var zero E
s := *ps
s = append(s, zero)
cp := cap(s)
if cp > length {
cp = length
}
s = s[:cp]
v.Set(reflect.ValueOf(s))
*ps = s
}
`