Přemysl Eric Janouch
aacf1b1d47
All checks were successful
Alpine 3.20 Success
Turning union tags into read-only methods of actual types: - eliminates duplicated JSON unmarshalling of tags, - makes AppendTo/ConsumeFrom symmetrical in nature, - eliminates duplicated AppendTo code, - eliminates trivial AppendTo methods for subtypes without fields, - gives us an opportunity to use a more specific interface than "any" (the type being anonymous is an acknowledged inconvenience). Implementing our own json.Marshalers some time ago (for performance reasons) has made this easier to implement. Also rename "Interface" fields to more suitable "Variant".
549 lines
16 KiB
Awk
549 lines
16 KiB
Awk
# lxdrgen-go.awk: Go backend for lxdrgen.awk.
|
|
#
|
|
# Copyright (c) 2022 - 2024, Přemysl Eric Janouch <p@janouch.name>
|
|
# SPDX-License-Identifier: 0BSD
|
|
#
|
|
# This backend also enables proxying to other endpoints using JSON.
|
|
|
|
function define_internal(name, gotype) {
|
|
Types[name] = "internal"
|
|
CodegenGoType[name] = gotype
|
|
}
|
|
|
|
function define_sint(size, shortname, gotype) {
|
|
shortname = "i" size
|
|
gotype = "int" size
|
|
define_internal(shortname, gotype)
|
|
|
|
CodegenAppendJSON[shortname] = \
|
|
"\tb = strconv.AppendInt(b, int64(%s), 10)\n"
|
|
if (size == 8) {
|
|
CodegenSerialize[shortname] = "\tdata = append(data, uint8(%s))\n"
|
|
CodegenDeserialize[shortname] = \
|
|
"\tif len(data) >= 1 {\n" \
|
|
"\t\t%s, data = int8(data[0]), data[1:]\n" \
|
|
"\t} else {\n" \
|
|
"\t\treturn nil, false\n" \
|
|
"\t}\n"
|
|
return
|
|
}
|
|
|
|
CodegenSerialize[shortname] = \
|
|
"\tdata = binary.BigEndian.AppendUint" size "(data, uint" size "(%s))\n"
|
|
CodegenDeserialize[shortname] = \
|
|
"\tif len(data) >= " (size / 8) " {\n" \
|
|
"\t\t%s = " gotype "(binary.BigEndian.Uint" size "(data))\n" \
|
|
"\t\tdata = data[" (size / 8) ":]\n" \
|
|
"\t} else {\n" \
|
|
"\t\treturn nil, false\n" \
|
|
"\t}\n"
|
|
}
|
|
|
|
function define_uint(size, shortname, gotype) {
|
|
# Both []byte and []uint8 luckily marshal as base64-encoded JSON strings,
|
|
# so there's no need to rename the type as an exception.
|
|
shortname = "u" size
|
|
gotype = "uint" size
|
|
define_internal(shortname, gotype)
|
|
|
|
CodegenAppendJSON[shortname] = \
|
|
"\tb = strconv.AppendUint(b, uint64(%s), 10)\n"
|
|
if (size == 8) {
|
|
CodegenSerialize[shortname] = "\tdata = append(data, %s)\n"
|
|
CodegenDeserialize[shortname] = \
|
|
"\tif len(data) >= 1 {\n" \
|
|
"\t\t%s, data = data[0], data[1:]\n" \
|
|
"\t} else {\n" \
|
|
"\t\treturn nil, false\n" \
|
|
"\t}\n"
|
|
return
|
|
}
|
|
|
|
CodegenSerialize[shortname] = \
|
|
"\tdata = binary.BigEndian.AppendUint" size "(data, %s)\n"
|
|
CodegenDeserialize[shortname] = \
|
|
"\tif len(data) >= " (size / 8) " {\n" \
|
|
"\t\t%s = binary.BigEndian.Uint" size "(data)\n" \
|
|
"\t\tdata = data[" (size / 8) ":]\n" \
|
|
"\t} else {\n" \
|
|
"\t\treturn nil, false\n" \
|
|
"\t}\n"
|
|
}
|
|
|
|
# Currently two outputs cannot coexist within the same package.
|
|
function codegen_private(name) {
|
|
return "proto" name
|
|
}
|
|
|
|
function codegen_begin( funcname) {
|
|
define_sint("8")
|
|
define_sint("16")
|
|
define_sint("32")
|
|
define_sint("64")
|
|
define_uint("8")
|
|
define_uint("16")
|
|
define_uint("32")
|
|
define_uint("64")
|
|
define_internal("bool", "bool")
|
|
define_internal("string", "string")
|
|
|
|
# Cater to "go generate", for what it's worth.
|
|
CodegenPackage = ENV["GOPACKAGE"]
|
|
if (!CodegenPackage)
|
|
CodegenPackage = "main"
|
|
|
|
print "// Code generated from " FILENAME ". DO NOT EDIT."
|
|
print ""
|
|
print "package " CodegenPackage
|
|
print ""
|
|
print "import ("
|
|
print "\t`encoding/base64`"
|
|
print "\t`encoding/binary`"
|
|
print "\t`encoding/json`"
|
|
print "\t`errors`"
|
|
print "\t`math`"
|
|
print "\t`strconv`"
|
|
print "\t`unicode/utf8`"
|
|
print ")"
|
|
print ""
|
|
print "// This is a hack to always use the base64 import."
|
|
print "var _ = base64.StdEncoding"
|
|
print ""
|
|
|
|
CodegenAppendJSON["bool"] = \
|
|
"\tb = strconv.AppendBool(b, %s)\n"
|
|
CodegenSerialize["bool"] = \
|
|
"\tif %s {\n" \
|
|
"\t\tdata = append(data, 1)\n" \
|
|
"\t} else {\n" \
|
|
"\t\tdata = append(data, 0)\n" \
|
|
"\t}\n"
|
|
|
|
funcname = codegen_private("ConsumeBoolFrom")
|
|
print "// " funcname " tries to deserialize a boolean value"
|
|
print "// from the beginning of a byte stream. When successful,"
|
|
print "// it returns a subslice with any data that might follow."
|
|
print "func " funcname "(data []byte, b *bool) ([]byte, bool) {"
|
|
print "\tif len(data) < 1 {"
|
|
print "\t\treturn nil, false"
|
|
print "\t}"
|
|
print "\tif data[0] != 0 {"
|
|
print "\t\t*b = true"
|
|
print "\t} else {"
|
|
print "\t\t*b = false"
|
|
print "\t}"
|
|
print "\treturn data[1:], true"
|
|
print "}"
|
|
print ""
|
|
|
|
CodegenDeserialize["bool"] = \
|
|
"\tif data, ok = " funcname "(data, &%s); !ok {\n" \
|
|
"\t\treturn nil, ok\n" \
|
|
"\t}\n"
|
|
|
|
funcname = codegen_private("AppendStringTo")
|
|
print "// " funcname " tries to serialize a string value,"
|
|
print "// appending it to the end of a byte stream."
|
|
print "func " funcname "(data []byte, s string) ([]byte, bool) {"
|
|
print "\tif len(s) > math.MaxUint32 {"
|
|
print "\t\treturn nil, false"
|
|
print "\t}"
|
|
print "\tdata = binary.BigEndian.AppendUint32(data, uint32(len(s)))"
|
|
print "\treturn append(data, s...), true"
|
|
print "}"
|
|
print ""
|
|
|
|
CodegenSerialize["string"] = \
|
|
"\tif data, ok = " funcname "(data, %s); !ok {\n" \
|
|
"\t\treturn nil, ok\n" \
|
|
"\t}\n"
|
|
|
|
funcname = codegen_private("ConsumeStringFrom")
|
|
print "// " funcname " tries to deserialize a string value"
|
|
print "// from the beginning of a byte stream. When successful,"
|
|
print "// it returns a subslice with any data that might follow."
|
|
print "func " funcname "(data []byte, s *string) ([]byte, bool) {"
|
|
print "\tif len(data) < 4 {"
|
|
print "\t\treturn nil, false"
|
|
print "\t}"
|
|
print "\tlength := binary.BigEndian.Uint32(data)"
|
|
print "\tif data = data[4:]; uint64(len(data)) < uint64(length) {"
|
|
print "\t\treturn nil, false"
|
|
print "\t}"
|
|
print "\t*s = string(data[:length])"
|
|
print "\tif !utf8.ValidString(*s) {"
|
|
print "\t\treturn nil, false"
|
|
print "\t}"
|
|
print "\treturn data[length:], true"
|
|
print "}"
|
|
print ""
|
|
|
|
CodegenDeserialize["string"] = \
|
|
"\tif data, ok = " funcname "(data, &%s); !ok {\n" \
|
|
"\t\treturn nil, ok\n" \
|
|
"\t}\n"
|
|
|
|
funcname = codegen_private("UnmarshalEnumJSON")
|
|
print "// " funcname " converts a JSON fragment to an integer,"
|
|
print "// ensuring that it's within the expected range of enum values."
|
|
print "func " funcname "(data []byte) (int64, error) {"
|
|
print "\tvar n int64"
|
|
print "\tif err := json.Unmarshal(data, &n); err != nil {"
|
|
print "\t\treturn 0, err"
|
|
print "\t} else if n > math.MaxInt8 || n < math.MinInt8 {"
|
|
print "\t\treturn 0, errors.New(`integer out of range`)"
|
|
print "\t} else {"
|
|
print "\t\treturn n, nil"
|
|
print "\t}"
|
|
print "}"
|
|
print ""
|
|
}
|
|
|
|
function codegen_constant(name, value) {
|
|
print "const " PrefixCamel snaketocamel(name) " = " value
|
|
print ""
|
|
}
|
|
|
|
function codegen_enum_value(name, subname, value, cg, goname) {
|
|
goname = PrefixCamel name snaketocamel(subname)
|
|
append(cg, "fields",
|
|
"\t" goname " = " value "\n")
|
|
append(cg, "stringer",
|
|
"\tcase " goname ":\n" \
|
|
"\t\treturn `" snaketocamel(subname) "`\n")
|
|
append(cg, "marshal",
|
|
goname ",\n")
|
|
append(cg, "unmarshal",
|
|
"\tcase `" snaketocamel(subname) "`:\n" \
|
|
"\t\t*v = " goname "\n")
|
|
}
|
|
|
|
function codegen_enum(name, cg, gotype, fields, funcname) {
|
|
gotype = PrefixCamel name
|
|
print "type " gotype " int8"
|
|
print ""
|
|
|
|
print "const ("
|
|
print cg["fields"] ")"
|
|
print ""
|
|
|
|
print "func (v " gotype ") String() string {"
|
|
print "\tswitch v {"
|
|
print cg["stringer"] "\tdefault:"
|
|
print "\t\treturn strconv.Itoa(int(v))"
|
|
print "\t}"
|
|
print "}"
|
|
print ""
|
|
|
|
CodegenIsMarshaler[name] = 1
|
|
fields = cg["marshal"]
|
|
sub(/,\n$/, ":", fields)
|
|
gsub(/\n/, "\n\t", fields)
|
|
print "func (v " gotype ") MarshalJSON() ([]byte, error) {"
|
|
print "\tswitch v {"
|
|
print indent("case " fields)
|
|
print "\t\treturn []byte(`\"` + v.String() + `\"`), nil"
|
|
print "\t}"
|
|
print "\treturn json.Marshal(int(v))"
|
|
print "}"
|
|
print ""
|
|
|
|
funcname = codegen_private("UnmarshalEnumJSON")
|
|
print "func (v *" gotype ") UnmarshalJSON(data []byte) error {"
|
|
print "\tvar s string"
|
|
print "\tif json.Unmarshal(data, &s) == nil {"
|
|
print "\t\t// Handled below."
|
|
print "\t} else if n, err := " funcname "(data); err != nil {"
|
|
print "\t\treturn err"
|
|
print "\t} else {"
|
|
print "\t\t*v = " gotype "(n)"
|
|
print "\t\treturn nil"
|
|
print "\t}"
|
|
print ""
|
|
print "\tswitch s {"
|
|
print cg["unmarshal"] "\tdefault:"
|
|
print "\t\treturn errors.New(`unrecognized value: ` + s)"
|
|
print "\t}"
|
|
print "\treturn nil"
|
|
print "}"
|
|
print ""
|
|
|
|
# XXX: This should also check if it isn't out-of-range for any reason,
|
|
# but our usage of sprintf() stands in the way a bit.
|
|
CodegenSerialize[name] = "\tdata = append(data, uint8(%s))\n"
|
|
CodegenDeserialize[name] = \
|
|
"\tif len(data) >= 1 {\n" \
|
|
"\t\t%s, data = " gotype "(data[0]), data[1:]\n" \
|
|
"\t} else {\n" \
|
|
"\t\treturn nil, false\n" \
|
|
"\t}\n"
|
|
|
|
CodegenGoType[name] = gotype
|
|
for (i in cg)
|
|
delete cg[i]
|
|
}
|
|
|
|
function codegen_marshal(type, f, marshal) {
|
|
if (CodegenAppendJSON[type])
|
|
return sprintf(CodegenAppendJSON[type], f)
|
|
|
|
# Complex types are json.Marshalers, there's no need to json.Marshal(&f).
|
|
if (CodegenIsMarshaler[type])
|
|
marshal = f ".MarshalJSON()"
|
|
else
|
|
marshal = "json.Marshal(" f ")"
|
|
|
|
return \
|
|
"\tif j, err := " marshal "; err != nil {\n" \
|
|
"\t\treturn nil, err\n" \
|
|
"\t} else {\n" \
|
|
"\t\tb = append(b, j...)\n" \
|
|
"\t}\n"
|
|
}
|
|
|
|
function codegen_struct_field_marshal(d, cg, isaccessor, camel, f, marshal) {
|
|
camel = snaketocamel(d["name"])
|
|
f = "s." camel
|
|
if (isaccessor)
|
|
f = f "()"
|
|
if (!d["isarray"]) {
|
|
append(cg, "marshal",
|
|
"\tb = append(b, `,\"" decapitalize(camel) "\":`...)\n" \
|
|
codegen_marshal(d["type"], f))
|
|
return
|
|
}
|
|
|
|
# Note that we do not produce `null` for nil slices, unlike encoding/json.
|
|
# And arrays never get deserialized as such.
|
|
if (d["type"] == "u8") {
|
|
append(cg, "marshal",
|
|
"\tb = append(b, `,\"" decapitalize(camel) "\":\"`...)\n" \
|
|
"\tb = append(b, base64.StdEncoding.EncodeToString(" f ")...)\n" \
|
|
"\tb = append(b, '\"')\n")
|
|
return
|
|
}
|
|
|
|
append(cg, "marshal",
|
|
"\tb = append(b, `,\"" decapitalize(camel) "\":[`...)\n" \
|
|
"\tfor i := 0; i < len(" f "); i++ {\n" \
|
|
"\t\tif i > 0 {\n" \
|
|
"\t\t\tb = append(b, ',')\n" \
|
|
"\t\t}\n" \
|
|
indent(codegen_marshal(d["type"], f "[i]")) \
|
|
"\t}\n" \
|
|
"\tb = append(b, ']')\n")
|
|
}
|
|
|
|
function codegen_struct_field(d, cg, camel, f, serialize, deserialize) {
|
|
codegen_struct_field_marshal(d, cg, 0)
|
|
|
|
camel = snaketocamel(d["name"])
|
|
f = "s." camel
|
|
serialize = CodegenSerialize[d["type"]]
|
|
deserialize = CodegenDeserialize[d["type"]]
|
|
if (!d["isarray"]) {
|
|
append(cg, "fields", "\t" camel " " CodegenGoType[d["type"]] \
|
|
" `json:\"" decapitalize(camel) "\"`\n")
|
|
append(cg, "serialize", sprintf(serialize, f))
|
|
append(cg, "deserialize", sprintf(deserialize, f))
|
|
return
|
|
}
|
|
|
|
append(cg, "fields", "\t" camel " []" CodegenGoType[d["type"]] \
|
|
" `json:\"" decapitalize(camel) "\"`\n")
|
|
|
|
# XXX: This should also check if it isn't out-of-range for any reason.
|
|
append(cg, "serialize",
|
|
sprintf(CodegenSerialize["u32"], "uint32(len(" f "))"))
|
|
if (d["type"] == "u8") {
|
|
append(cg, "serialize",
|
|
"\tdata = append(data, " f "...)\n")
|
|
} else {
|
|
append(cg, "serialize",
|
|
"\tfor i := 0; i < len(" f "); i++ {\n" \
|
|
indent(sprintf(serialize, f "[i]")) \
|
|
"\t}\n")
|
|
}
|
|
|
|
append(cg, "deserialize",
|
|
"\t{\n" \
|
|
"\t\tvar length uint32\n" \
|
|
indent(sprintf(CodegenDeserialize["u32"], "length")))
|
|
if (d["type"] == "u8") {
|
|
append(cg, "deserialize",
|
|
"\t\tif uint64(len(data)) < uint64(length) {\n" \
|
|
"\t\t\treturn nil, false\n" \
|
|
"\t\t}\n" \
|
|
"\t\t" f ", data = data[:length], data[length:]\n" \
|
|
"\t}\n")
|
|
} else {
|
|
append(cg, "deserialize",
|
|
"\t\t" f " = make([]" CodegenGoType[d["type"]] ", length)\n" \
|
|
"\t}\n" \
|
|
"\tfor i := 0; i < len(" f "); i++ {\n" \
|
|
indent(sprintf(deserialize, f "[i]")) \
|
|
"\t}\n")
|
|
}
|
|
}
|
|
|
|
function codegen_struct_tag(d, cg) {
|
|
codegen_struct_field_marshal(d, cg, 1)
|
|
|
|
# Do not serialize or deserialize here,
|
|
# that is already done by the containing union.
|
|
}
|
|
|
|
function codegen_struct(name, cg, gotype) {
|
|
gotype = PrefixCamel name
|
|
print "type " gotype " struct {\n" cg["fields"] "}\n"
|
|
|
|
if (cg["marshal"]) {
|
|
CodegenIsMarshaler[name] = 1
|
|
print "func (s *" gotype ") MarshalJSON() ([]byte, error) {"
|
|
print "\tb := []byte{}"
|
|
print cg["marshal"] "\tb[0] = '{'"
|
|
print "\treturn append(b, '}'), nil"
|
|
print "}"
|
|
print ""
|
|
}
|
|
|
|
if (cg["serialize"]) {
|
|
print "func (s *" gotype ") AppendTo(data []byte) ([]byte, bool) {"
|
|
print "\tok := true"
|
|
print cg["serialize"] "\treturn data, ok"
|
|
print "}"
|
|
print ""
|
|
|
|
CodegenSerialize[name] = \
|
|
"\tif data, ok = %s.AppendTo(data); !ok {\n" \
|
|
"\t\treturn nil, ok\n" \
|
|
"\t}\n"
|
|
}
|
|
if (cg["deserialize"]) {
|
|
print "func (s *" gotype ") ConsumeFrom(data []byte) ([]byte, bool) {"
|
|
print "\tok := true"
|
|
print cg["deserialize"] "\treturn data, ok"
|
|
print "}"
|
|
print ""
|
|
|
|
CodegenDeserialize[name] = \
|
|
"\tif data, ok = %s.ConsumeFrom(data); !ok {\n" \
|
|
"\t\treturn nil, ok\n" \
|
|
"\t}\n"
|
|
}
|
|
|
|
CodegenGoType[name] = gotype
|
|
for (i in cg)
|
|
delete cg[i]
|
|
}
|
|
|
|
function codegen_union_tag(name, d, cg) {
|
|
cg["tagtype"] = d["type"]
|
|
cg["tagname"] = snaketocamel(d["name"])
|
|
# The tag is implied from the type of struct stored in the interface.
|
|
}
|
|
|
|
function codegen_union_struct(name, casename, cg, scg, structname, init) {
|
|
# And thus not all generated structs are present in Types.
|
|
structname = name snaketocamel(casename)
|
|
codegen_struct(structname, scg)
|
|
|
|
print "func (u *" CodegenGoType[structname] ") " cg["tagname"] "() " \
|
|
CodegenGoType[cg["tagtype"]] " {"
|
|
print "\treturn " CodegenGoType[cg["tagtype"]] snaketocamel(casename)
|
|
print "}"
|
|
print ""
|
|
|
|
init = CodegenGoType[structname] "{}"
|
|
append(cg, "unmarshal",
|
|
"\tcase " CodegenGoType[cg["tagtype"]] snaketocamel(casename) ":\n" \
|
|
"\t\ts := " init "\n" \
|
|
"\t\terr = json.Unmarshal(data, &s)\n" \
|
|
"\t\tu.Variant = &s\n")
|
|
append(cg, "serialize",
|
|
"\tcase *" CodegenGoType[structname] ":\n" \
|
|
indent(sprintf(CodegenSerialize[structname], "union")))
|
|
append(cg, "deserialize",
|
|
"\tcase " CodegenGoType[cg["tagtype"]] snaketocamel(casename) ":\n" \
|
|
"\t\ts := " init "\n" \
|
|
indent(sprintf(CodegenDeserialize[structname], "s")) \
|
|
"\t\tu.Variant = &s\n")
|
|
}
|
|
|
|
function codegen_union(name, cg, exhaustive, gotype, tagvar) {
|
|
gotype = PrefixCamel name
|
|
# This must be a struct, so that UnmarshalJSON can create concrete types.
|
|
print "type " gotype " struct {"
|
|
print "\tVariant interface {"
|
|
print "\t\t" cg["tagname"] "() " CodegenGoType[cg["tagtype"]]
|
|
print "\t}"
|
|
print "}"
|
|
print ""
|
|
|
|
# This cannot be a pointer method, it wouldn't work recursively.
|
|
CodegenIsMarshaler[name] = 1
|
|
print "func (u " gotype ") MarshalJSON() ([]byte, error) {"
|
|
print "\treturn u.Variant.(json.Marshaler).MarshalJSON()"
|
|
print "}"
|
|
print ""
|
|
|
|
tagvar = decapitalize(cg["tagname"])
|
|
print "func (u *" gotype ") UnmarshalJSON(data []byte) (err error) {"
|
|
print "\tvar t struct {"
|
|
print "\t\t" cg["tagname"] " " CodegenGoType[cg["tagtype"]] \
|
|
" `json:\"" tagvar "\"`"
|
|
print "\t}"
|
|
print "\tif err := json.Unmarshal(data, &t); err != nil {"
|
|
print "\t\treturn err"
|
|
print "\t}"
|
|
print ""
|
|
print "\tswitch " tagvar " := t." cg["tagname"] "; " tagvar " {"
|
|
print cg["unmarshal"] "\tdefault:"
|
|
print "\t\terr = errors.New(`unsupported value: ` + " tagvar ".String())"
|
|
print "\t}"
|
|
print "\treturn err"
|
|
print "}"
|
|
print ""
|
|
|
|
# XXX: Consider rather testing the type for having an AppendTo method,
|
|
# which would eliminate this type case switch entirely.
|
|
print "func (u *" gotype ") AppendTo(data []byte) ([]byte, bool) {"
|
|
print "\tok := true"
|
|
print sprintf(CodegenSerialize[cg["tagtype"]],
|
|
"u.Variant." cg["tagname"] "()") \
|
|
"\tswitch union := u.Variant.(type) {"
|
|
print cg["serialize"] "\tdefault:"
|
|
print "\t\t_ = union"
|
|
print "\t\treturn nil, false"
|
|
print "\t}"
|
|
print "\treturn data, ok"
|
|
print "}"
|
|
print ""
|
|
|
|
CodegenSerialize[name] = \
|
|
"\tif data, ok = %s.AppendTo(data); !ok {\n" \
|
|
"\t\treturn nil, ok\n" \
|
|
"\t}\n"
|
|
|
|
print "func (u *" gotype ") ConsumeFrom(data []byte) ([]byte, bool) {"
|
|
print "\tok := true"
|
|
print "\tvar " tagvar " " CodegenGoType[cg["tagtype"]]
|
|
print sprintf(CodegenDeserialize[cg["tagtype"]], tagvar)
|
|
print "\tswitch " tagvar " {"
|
|
print cg["deserialize"] "\tdefault:"
|
|
print "\t\treturn nil, false"
|
|
print "\t}"
|
|
print "\treturn data, ok"
|
|
print "}"
|
|
print ""
|
|
|
|
CodegenDeserialize[name] = \
|
|
"\tif data, ok = %s.ConsumeFrom(data); !ok {\n" \
|
|
"\t\treturn nil, ok\n" \
|
|
"\t}\n"
|
|
|
|
CodegenGoType[name] = gotype
|
|
for (i in cg)
|
|
delete cg[i]
|
|
}
|