mc root source folder cleanup
This commit is contained in:
adman
@@ -0,0 +1,659 @@
|
||||
package main
|
||||
|
||||
import (
|
||||
"go/ast"
|
||||
"go/token"
|
||||
"slices"
|
||||
"strconv"
|
||||
|
||||
"github.com/admin-else/strom/mc/proto_generator/protodef"
|
||||
util2 "github.com/admin-else/strom/mc/util"
|
||||
"github.com/go-viper/mapstructure/v2"
|
||||
)
|
||||
|
||||
func DefaultDecoder(_ *Generator, varToSet ast.Expr, _ any, _ string) (s []ast.Stmt, err error) {
|
||||
s = Stmts(
|
||||
Assign(
|
||||
Exprs(Ident("err")),
|
||||
Exprs(Call(SelectorExprAndStr(varToSet, "Decode"), Ident("r"))),
|
||||
),
|
||||
IfErrNil(),
|
||||
)
|
||||
|
||||
return
|
||||
}
|
||||
|
||||
func UUIDDecoder(_ *Generator, varToSet ast.Expr, _ any, _ string) (s []ast.Stmt, err error) {
|
||||
//_, err = io.ReadFull(r, U[:])
|
||||
s = Stmts(
|
||||
Assign(Exprs(Ident("_"), Ident("err")), Exprs(Call(Selector("io", "ReadFull"), Ident("r"), MultiIndex(varToSet, nil, nil, nil)))),
|
||||
IfErrNil(),
|
||||
)
|
||||
return
|
||||
}
|
||||
|
||||
func ContainerDecoder(g *Generator, varToSet ast.Expr, dataRaw any, name string) (s []ast.Stmt, err error) {
|
||||
var data protodef.Container
|
||||
err = mapstructure.Decode(dataRaw, &data)
|
||||
if err != nil {
|
||||
return
|
||||
}
|
||||
|
||||
g.ContainerStack = append(g.ContainerStack, ContainerStackEntry{
|
||||
Data: data,
|
||||
VarToSet: varToSet,
|
||||
})
|
||||
defer func() { g.ContainerStack = g.ContainerStack[:len(g.ContainerStack)-1] }()
|
||||
|
||||
for _, field := range data {
|
||||
var statements []ast.Stmt
|
||||
cName := util2.CamelCase(field.Name)
|
||||
if field.Anon {
|
||||
cName = "Anon"
|
||||
}
|
||||
statements, err = g.VisitDecoder(SelectorExprAndStr(varToSet, cName), field.Type, name+cName)
|
||||
if err != nil {
|
||||
return
|
||||
}
|
||||
s = append(s, statements...)
|
||||
}
|
||||
return
|
||||
}
|
||||
|
||||
func SimpleTypeDecoder(_ *Generator, varToSet ast.Expr, _ any, _ string) (s []ast.Stmt, err error) {
|
||||
s = Stmts(
|
||||
Assign(
|
||||
Exprs(Ident("err")),
|
||||
Exprs(Call(Selector("binary", "Read"), Ident("r"), Selector("binary", "BigEndian"), AddrOf(varToSet))),
|
||||
),
|
||||
IfErrNil(),
|
||||
)
|
||||
return
|
||||
}
|
||||
|
||||
func StringDecoder(_ *Generator, varToSet ast.Expr, _ any, _ string) (s []ast.Stmt, err error) {
|
||||
s = Stmts(
|
||||
Assign(Exprs(varToSet, Ident("err")), Exprs(Call(Selector("proto_base", "DecodeString"), Ident("r")))),
|
||||
IfErrNil(),
|
||||
)
|
||||
return
|
||||
}
|
||||
|
||||
func OptionDecoder(g *Generator, varToSet ast.Expr, dataRaw any, name string) (s []ast.Stmt, err error) {
|
||||
pVarName := name + "Present"
|
||||
tVarName := name + "PresentValue"
|
||||
boolStmts, err := g.VisitDecoder(Ident(pVarName), "bool", name)
|
||||
if err != nil {
|
||||
return
|
||||
}
|
||||
t, err := g.VisitType(dataRaw)
|
||||
if err != nil {
|
||||
return
|
||||
}
|
||||
tStmts1 := Stmts(VarStmt(tVarName, t))
|
||||
tStmts2, err := g.VisitDecoder(Ident(tVarName), dataRaw, name)
|
||||
if err != nil {
|
||||
return
|
||||
}
|
||||
|
||||
// This looks so shit
|
||||
tStmts := append(tStmts1, tStmts2...)
|
||||
tStmts = append(tStmts, Assign121(varToSet, AddrOf(Ident(tVarName))))
|
||||
s = append(s, VarStmt(pVarName, Ident("bool")))
|
||||
s = append(s, boolStmts...)
|
||||
s = append(s, If(Ident(pVarName), NewBlock(tStmts)))
|
||||
return
|
||||
}
|
||||
|
||||
func ArrayDecoder(g *Generator, varToSet ast.Expr, dataRaw any, name string) (s []ast.Stmt, err error) {
|
||||
var data protodef.Array
|
||||
lName := "l" + util2.CamelCase(name)
|
||||
err = mapstructure.Decode(dataRaw, &data)
|
||||
if err != nil {
|
||||
return
|
||||
}
|
||||
var s2 []ast.Stmt
|
||||
countType, err := g.VisitNameAndData("varint", nil)
|
||||
if data.CountType != nil {
|
||||
countType, err = g.VisitType(data.CountType)
|
||||
if err != nil {
|
||||
return
|
||||
}
|
||||
s2, err = g.VisitDecoder(Ident(lName), data.CountType, name)
|
||||
if err != nil {
|
||||
return
|
||||
}
|
||||
} else {
|
||||
var n int
|
||||
n, err = strconv.Atoi(data.Count)
|
||||
var e ast.Expr
|
||||
if err == nil {
|
||||
e = NumLit(n)
|
||||
} else {
|
||||
e, _, err = g.ParseCompareTo(data.Count)
|
||||
}
|
||||
s2 = append(s2, Assign121(Ident(lName), e))
|
||||
}
|
||||
|
||||
normalType, err := g.VisitType(data.Type)
|
||||
if err != nil {
|
||||
return
|
||||
}
|
||||
|
||||
arrayType, err := g.VisitNameAndData("array", dataRaw)
|
||||
if err != nil {
|
||||
return
|
||||
}
|
||||
|
||||
tName := name + "Element"
|
||||
rangeStatements := Stmts(VarStmt(tName, normalType))
|
||||
s5, err := g.VisitDecoder(Ident(tName), data.Type, tName)
|
||||
rangeStatements = append(rangeStatements, s5...)
|
||||
rangeStatements = append(rangeStatements, Assign121(varToSet, Call(Ident("append"), varToSet, Ident(tName))))
|
||||
|
||||
if err != nil {
|
||||
return
|
||||
}
|
||||
s1 := VarStmt(lName, countType)
|
||||
s3 := Assign121(varToSet, CompLit(arrayType, Exprs()))
|
||||
s4 := ForRange(nil, Ident(lName), NewBlock(rangeStatements))
|
||||
s = append(s, s1)
|
||||
s = append(s, s2...)
|
||||
s = append(s, s3)
|
||||
s = append(s, s4)
|
||||
return
|
||||
}
|
||||
|
||||
func TypeForwardDecoder(g *Generator, varToSet ast.Expr, dataRaw any, name string) (s []ast.Stmt, err error) {
|
||||
var data protodef.TypeForward
|
||||
if err = mapstructure.Decode(dataRaw, &data); err != nil {
|
||||
return
|
||||
}
|
||||
return g.VisitDecoder(varToSet, data.Type, name)
|
||||
}
|
||||
|
||||
var BooleanValues = []string{"true", "false"}
|
||||
|
||||
// CaseExprType This exists to fix this
|
||||
// "switch",
|
||||
//
|
||||
// {
|
||||
// "compareTo": "itemCount",
|
||||
// "fields": {
|
||||
// "0": "void",
|
||||
// "false": "void"
|
||||
// },
|
||||
// "default": [
|
||||
//
|
||||
// Protodef is best!!!
|
||||
// they are also inconsistent with bool compare to sometimes they use false sometimes they use numbers
|
||||
// that's why this bullshit exists
|
||||
type CaseExprType int
|
||||
|
||||
const (
|
||||
CaseExprTypeUnset CaseExprType = iota
|
||||
CaseExprTypeNumber
|
||||
CaseExprTypeBool
|
||||
CaseExprTypeString
|
||||
|
||||
// CaseExprTypeOnlyNumber CaseExprTypeOnlyBool CaseExprTypeStringOnly These are special overwrite values retuned by
|
||||
// the compare to for the case of being certain that it's the right type.
|
||||
|
||||
CaseExprTypeOnlyNumber
|
||||
CaseExprTypeOnlyBool
|
||||
CaseExprTypeStringOnly
|
||||
)
|
||||
|
||||
func MultiTypeFix(s string, t *CaseExprType) (e ast.Expr) {
|
||||
n, err := strconv.Atoi(s)
|
||||
ct := CaseExprTypeUnset
|
||||
if err == nil {
|
||||
err = nil
|
||||
e = NumLit(n)
|
||||
ct = CaseExprTypeNumber
|
||||
} else if slices.Contains(BooleanValues, s) {
|
||||
e = Ident(s)
|
||||
ct = CaseExprTypeBool
|
||||
} else {
|
||||
e = StrLit(s)
|
||||
ct = CaseExprTypeString
|
||||
}
|
||||
|
||||
if *t == CaseExprTypeUnset {
|
||||
*t = ct
|
||||
return
|
||||
}
|
||||
if *t == ct {
|
||||
return
|
||||
}
|
||||
|
||||
if ct == CaseExprTypeNumber && *t == CaseExprTypeOnlyBool {
|
||||
if s == "0" {
|
||||
e = Ident("false")
|
||||
} else {
|
||||
e = Ident("true")
|
||||
}
|
||||
return
|
||||
}
|
||||
e = nil
|
||||
return
|
||||
}
|
||||
|
||||
func SwitchDecoder(g *Generator, varToSet ast.Expr, dataRaw any, name string) (s []ast.Stmt, err error) {
|
||||
var data protodef.Switch
|
||||
err = mapstructure.Decode(dataRaw, &data)
|
||||
if err != nil {
|
||||
return
|
||||
}
|
||||
compareToExpr, cet, err := g.ParseCompareTo(data.CompareTo)
|
||||
if err != nil {
|
||||
return
|
||||
}
|
||||
for _, fName := range util2.OrderedKeys(data.Fields) {
|
||||
fType := data.Fields[fName]
|
||||
e := MultiTypeFix(fName, &cet)
|
||||
if e == nil {
|
||||
continue
|
||||
}
|
||||
var tType ast.Expr
|
||||
tType, err = g.VisitType(fType)
|
||||
if err != nil {
|
||||
return
|
||||
}
|
||||
tName := name + util2.CamelCase(fName) + "Tmp"
|
||||
s1 := VarStmt(tName, tType)
|
||||
s3 := Assign121(varToSet, Ident(tName))
|
||||
var caseDecodeValueStmts []ast.Stmt
|
||||
caseDecodeValueStmts, err = g.VisitDecoder(Ident(tName), fType, tName)
|
||||
if err != nil {
|
||||
return
|
||||
}
|
||||
var caseStmts []ast.Stmt
|
||||
caseStmts = append(caseStmts, s1)
|
||||
caseStmts = append(caseStmts, caseDecodeValueStmts...)
|
||||
caseStmts = append(caseStmts, s3)
|
||||
s = append(s, Case(Exprs(e), caseStmts))
|
||||
}
|
||||
if data.Default != nil {
|
||||
var tType ast.Expr
|
||||
tType, err = g.VisitType(data.Default)
|
||||
tName := name + "Tmp"
|
||||
s1 := VarStmt(tName, tType)
|
||||
s3 := Assign121(varToSet, Ident(tName))
|
||||
var caseDecodeValueStmts []ast.Stmt
|
||||
caseDecodeValueStmts, err = g.VisitDecoder(Ident(tName), data.Default, name)
|
||||
if err != nil {
|
||||
return
|
||||
}
|
||||
var caseStmts []ast.Stmt
|
||||
caseStmts = append(caseStmts, s1)
|
||||
caseStmts = append(caseStmts, caseDecodeValueStmts...)
|
||||
caseStmts = append(caseStmts, s3)
|
||||
s = append(s, Case(nil, caseStmts))
|
||||
}
|
||||
if len(s) != 0 {
|
||||
s = Stmts(SwitchStmt(compareToExpr, NewBlock(s)))
|
||||
}
|
||||
return
|
||||
}
|
||||
|
||||
var ToDoStmts = Stmts(Assign121(Ident("err"), Selector("proto_base", "ToDoError")))
|
||||
|
||||
func ToDoDecoder(_ *Generator, _ ast.Expr, _ any, _ string) (s []ast.Stmt, err error) {
|
||||
err = ToDoError
|
||||
return
|
||||
}
|
||||
|
||||
func MapperDecoder(g *Generator, varToSet ast.Expr, dataRaw any, name string) (s []ast.Stmt, err error) {
|
||||
var data protodef.Mapper
|
||||
err = mapstructure.Decode(dataRaw, &data)
|
||||
if err != nil {
|
||||
return
|
||||
}
|
||||
kName := util2.CamelCase(name) + "Key"
|
||||
kType, err := g.VisitType(data.Type)
|
||||
if err != nil {
|
||||
return
|
||||
}
|
||||
s1 := VarStmt(kName, kType)
|
||||
s2, err := g.VisitDecoder(Ident(kName), data.Type, name)
|
||||
if err != nil {
|
||||
return
|
||||
}
|
||||
|
||||
mName := name + "Map"
|
||||
|
||||
expressions := Exprs()
|
||||
for _, k := range util2.OrderedKeys(data.Mappings) {
|
||||
v := data.Mappings[k]
|
||||
expressions = append(expressions, KeyValueExpr(NumLitStr(k), StrLit(v)))
|
||||
}
|
||||
g.Decl(mName, token.VAR, CompLit(MapType(kType, Ident("string")), expressions))
|
||||
s3 := Assign(Exprs(varToSet, Ident("err")), Exprs(Call(Selector("proto_base", "ErroringIndex"), Ident(mName), Ident(kName))))
|
||||
s = append(s, s1)
|
||||
s = append(s, s2...)
|
||||
s = append(s, s3)
|
||||
s = append(s, IfErrNil())
|
||||
return
|
||||
}
|
||||
|
||||
func BufferDecoder(g *Generator, varToSet ast.Expr, dataRaw any, name string) (s []ast.Stmt, err error) {
|
||||
var data protodef.Buffer
|
||||
err = mapstructure.Decode(dataRaw, &data)
|
||||
if err != nil {
|
||||
return
|
||||
}
|
||||
|
||||
// rawString, err := io.ReadAll(io.LimitReader(r, int64(l)))
|
||||
|
||||
if data.CountType != nil {
|
||||
lName := "l" + util2.CamelCase(name)
|
||||
var countType ast.Expr
|
||||
countType, err = g.VisitType(data.CountType)
|
||||
if err != nil {
|
||||
return
|
||||
}
|
||||
var s2 []ast.Stmt
|
||||
s2, err = g.VisitDecoder(Ident(lName), data.CountType, name)
|
||||
if err != nil {
|
||||
return
|
||||
}
|
||||
s1 := VarStmt(lName, countType)
|
||||
s3 := Assign(Exprs(varToSet, Ident("err")), Exprs(Call(Selector("io", "ReadAll"), Call(Selector("io", "LimitReader"), Ident("r"), Call(Ident("int64"), Ident(lName))))))
|
||||
|
||||
s = append(s, s1)
|
||||
s = append(s, s2...)
|
||||
s = append(s, s3)
|
||||
} else {
|
||||
s = Stmts(Assign(Exprs(Ident("_"), Ident("err")), Exprs(Call(Selector("r", "Read"), MultiIndex(varToSet, nil, nil, nil)))))
|
||||
}
|
||||
|
||||
s = append(s, IfErrNil())
|
||||
return
|
||||
}
|
||||
|
||||
func BitFieldDecoder(g *Generator, varToSet ast.Expr, dataRaw any, name string) (s []ast.Stmt, err error) {
|
||||
var data protodef.BitField
|
||||
err = mapstructure.Decode(dataRaw, &data)
|
||||
if err != nil {
|
||||
return
|
||||
}
|
||||
totalSize := 0
|
||||
for _, field := range data {
|
||||
totalSize += field.Size
|
||||
}
|
||||
packedTypeProtodef, err := BitSizeToProtodef(totalSize, false)
|
||||
if err != nil {
|
||||
return
|
||||
}
|
||||
t, err := g.VisitType(packedTypeProtodef)
|
||||
if err != nil {
|
||||
return
|
||||
}
|
||||
packed := name + "Packed"
|
||||
packedVarStmt := VarStmt(packed, t)
|
||||
stmts, err := g.VisitDecoder(Ident(packed), packedTypeProtodef, name)
|
||||
if err != nil {
|
||||
return
|
||||
}
|
||||
s = append(s, packedVarStmt)
|
||||
s = append(s, stmts...)
|
||||
lShiftBy := 0
|
||||
for _, field := range data {
|
||||
var fieldTypeProtodef string
|
||||
fieldTypeProtodef, err = BitSizeToProtodef(field.Size, field.Signed)
|
||||
if err != nil {
|
||||
return
|
||||
}
|
||||
var fieldType ast.Expr
|
||||
fieldType, err = g.VisitType(fieldTypeProtodef)
|
||||
if err != nil {
|
||||
return
|
||||
}
|
||||
|
||||
rShiftBy := totalSize - field.Size
|
||||
fieldToSet := SelectorExprAndStr(varToSet, util2.CamelCase(field.Name))
|
||||
|
||||
var getDataExpr ast.Expr
|
||||
getDataExpr = RightShift(
|
||||
LeftShift(
|
||||
Ident(packed),
|
||||
NumLit(lShiftBy)),
|
||||
NumLit(rShiftBy),
|
||||
)
|
||||
if fieldTypeProtodef == "bool" {
|
||||
getDataExpr = Equals(getDataExpr, NumLit(1))
|
||||
} else if fieldTypeProtodef != packedTypeProtodef {
|
||||
getDataExpr = Call(fieldType, getDataExpr)
|
||||
}
|
||||
|
||||
s = append(s, Assign121(fieldToSet, getDataExpr))
|
||||
if field.Signed {
|
||||
s = append(s, If(
|
||||
GreaterThanOrEqual(
|
||||
fieldToSet,
|
||||
LeftShift(NumLit(1), NumLit(field.Size-1)),
|
||||
),
|
||||
NewBlockEllipsis(
|
||||
SubAssign(
|
||||
fieldToSet,
|
||||
LeftShift(NumLit(1), NumLit(field.Size)),
|
||||
),
|
||||
),
|
||||
))
|
||||
}
|
||||
|
||||
lShiftBy += field.Size
|
||||
}
|
||||
return
|
||||
}
|
||||
|
||||
func RegistryEntryHolderSetDecoder(g *Generator, varToSet ast.Expr, dataRaw any, name string) (s []ast.Stmt, err error) {
|
||||
var data protodef.RegistryEntryHolderSet
|
||||
err = mapstructure.Decode(dataRaw, &data)
|
||||
if err != nil {
|
||||
return
|
||||
}
|
||||
var countType ast.Expr
|
||||
countType, err = g.VisitType("varint")
|
||||
if err != nil {
|
||||
return
|
||||
}
|
||||
baseType, err := g.VisitType(data.Base.Type)
|
||||
if err != nil {
|
||||
return
|
||||
}
|
||||
otherwiseArrayType, err := g.VisitNameAndData("array", map[string]any{"type": data.Otherwise.Type})
|
||||
if err != nil {
|
||||
return
|
||||
}
|
||||
otherwiseType, err := g.VisitType(data.Otherwise.Type)
|
||||
if err != nil {
|
||||
return
|
||||
}
|
||||
lName := "l" + util2.CamelCase(name)
|
||||
s1 := VarStmt(lName, countType)
|
||||
s2, err := g.VisitDecoder(Ident(lName), "varint", name)
|
||||
if err != nil {
|
||||
return
|
||||
}
|
||||
s3 := Assign121(Ident(lName), Sub(Ident(lName), NumLit(1)))
|
||||
resultName := name + "Result"
|
||||
b1s1 := VarStmt(resultName, baseType)
|
||||
b1s2, err := g.VisitDecoder(Ident(resultName), data.Base.Type, resultName)
|
||||
b1s3 := Assign121(varToSet, Ident(resultName))
|
||||
b1s4 := Return()
|
||||
var b1 []ast.Stmt
|
||||
b1 = append(b1, b1s1)
|
||||
b1 = append(b1, b1s2...)
|
||||
b1 = append(b1, b1s3)
|
||||
b1 = append(b1, b1s4)
|
||||
|
||||
tName := name + "Element"
|
||||
rangeStatements := Stmts(VarStmt(tName, otherwiseType))
|
||||
rangeStatementsDecode, err := g.VisitDecoder(Ident(tName), data.Otherwise.Type, tName)
|
||||
rangeStatements = append(rangeStatements, rangeStatementsDecode...)
|
||||
rangeStatements = append(rangeStatements, Assign121(Ident(resultName), Call(Ident("append"), Ident(resultName), Ident(tName))))
|
||||
|
||||
s5 := If(Equals(Ident(lName), NumLit(-1)), NewBlock(b1))
|
||||
s6 := VarStmt(resultName, otherwiseArrayType)
|
||||
s7 := ForRange(nil, Ident(lName), NewBlock(rangeStatements))
|
||||
s = append(s, s1)
|
||||
s = append(s, s2...)
|
||||
s = append(s, s3)
|
||||
s = append(s, s5)
|
||||
s = append(s, s6)
|
||||
s = append(s, s7)
|
||||
return
|
||||
}
|
||||
|
||||
func RegistryEntryHolderDecoder(g *Generator, varToSet ast.Expr, dataRaw any, name string) (s []ast.Stmt, err error) {
|
||||
var data protodef.EntryHolderSet
|
||||
err = mapstructure.Decode(dataRaw, &data)
|
||||
if err != nil {
|
||||
return
|
||||
}
|
||||
idName := name + "Id"
|
||||
varIntType, err := g.VisitNameAndData("varint", nil)
|
||||
if err != nil {
|
||||
return
|
||||
}
|
||||
IdVar := VarStmt(idName, varIntType)
|
||||
idDecodeStatements, err := g.VisitDecoder(Ident(idName), "varint", name)
|
||||
if err != nil {
|
||||
return
|
||||
}
|
||||
|
||||
otherwiseType, err := g.VisitType(data.Otherwise.Type)
|
||||
if err != nil {
|
||||
return
|
||||
}
|
||||
resName := name + "Result"
|
||||
resNameIdent := Ident(resName)
|
||||
var otherwisePath []ast.Stmt
|
||||
otherwisePath = append(otherwisePath, VarStmt(resName, otherwiseType))
|
||||
|
||||
otherwiseDecodeStatements, err := g.VisitDecoder(resNameIdent, data.Otherwise.Type, name+"Otherwise")
|
||||
if err != nil {
|
||||
return
|
||||
}
|
||||
otherwisePath = append(otherwisePath, otherwiseDecodeStatements...)
|
||||
otherwisePath = append(otherwisePath, Assign121(varToSet, resNameIdent))
|
||||
idPath := IfElse(NotEquals(Ident(idName), NumLit(0)), NewBlockEllipsis(Assign121(varToSet, Ident(idName))), NewBlock(otherwisePath))
|
||||
|
||||
s = append(s, IdVar)
|
||||
s = append(s, idDecodeStatements...)
|
||||
s = append(s, idPath)
|
||||
return
|
||||
}
|
||||
|
||||
func VarIntDecoder(g *Generator, varToSet ast.Expr, dataRaw any, name string) (s []ast.Stmt, err error) {
|
||||
s = Stmts(Assign(Exprs(varToSet, Ident("err")), Exprs(Call(Selector("proto_base", "DecodeVarInt"), Ident("r")))), IfErrNil())
|
||||
return
|
||||
}
|
||||
|
||||
func VarLongDecoder(g *Generator, varToSet ast.Expr, dataRaw any, name string) (s []ast.Stmt, err error) {
|
||||
s = Stmts(Assign(Exprs(varToSet, Ident("err")), Exprs(Call(Selector("proto_base", "DecodeVarLong"), Ident("r")))), IfErrNil())
|
||||
return
|
||||
}
|
||||
|
||||
func VoidDecoder(g *Generator, varToSet ast.Expr, dataRaw any, name string) (s []ast.Stmt, err error) {
|
||||
return
|
||||
}
|
||||
|
||||
func EntityMetadataLoopDecoder(g *Generator, varToSet ast.Expr, dataRaw any, name string) (s []ast.Stmt, err error) {
|
||||
var data protodef.EntityMetadataLoop
|
||||
err = mapstructure.Decode(dataRaw, &data)
|
||||
if err != nil {
|
||||
return
|
||||
}
|
||||
|
||||
innerType, err := g.VisitType(data.Type)
|
||||
if err != nil {
|
||||
return
|
||||
}
|
||||
|
||||
assignVts := Assign121(varToSet, Call(Ident("make"), MapType(Ident("uint8"), innerType)))
|
||||
idVar := VarStmt("id", Ident("uint8"))
|
||||
|
||||
decodeIdStatements, err := g.VisitDecoder(Ident("id"), "u8", name)
|
||||
endCheck := If(Equals(Ident("id"), NumLit(data.EndVal)), NewBlockEllipsis(Break()))
|
||||
// r.Seek(-1, io.SeekCurrent)
|
||||
seekBack := Assign(Exprs(Ident("_"), Ident("err")), Exprs(Call(Selector("r", "Seek"), NumLit(-1), Selector("io", "SeekCurrent"))))
|
||||
|
||||
declEntry := VarStmt("entry", innerType)
|
||||
decodingEntryStmts, err := g.VisitDecoder(Ident("entry"), data.Type, name+"Inner")
|
||||
if err != nil {
|
||||
return
|
||||
}
|
||||
assignEntry := Assign121(Index(varToSet, Ident("id")), Ident("entry"))
|
||||
|
||||
var loopStmts []ast.Stmt
|
||||
loopStmts = append(loopStmts, decodeIdStatements...)
|
||||
loopStmts = append(loopStmts, endCheck)
|
||||
loopStmts = append(loopStmts, seekBack)
|
||||
loopStmts = append(loopStmts, IfErrNil())
|
||||
loopStmts = append(loopStmts, declEntry)
|
||||
loopStmts = append(loopStmts, decodingEntryStmts...)
|
||||
loopStmts = append(loopStmts, assignEntry)
|
||||
|
||||
s = Stmts(assignVts, idVar, ForStmt(nil, nil, nil, NewBlock(loopStmts)))
|
||||
/*
|
||||
vts = make(map[uint8]{{data.type}})
|
||||
var id uint8
|
||||
for {
|
||||
err = binary.Read(r, binary.BigEndian, &id)
|
||||
if err != nil {
|
||||
return
|
||||
}
|
||||
if id == {{data.EndId}} {
|
||||
return
|
||||
}
|
||||
var data {{type(data.type)}}
|
||||
{{unpack(data.type)}}
|
||||
vts[id] = data
|
||||
}
|
||||
*/
|
||||
return
|
||||
}
|
||||
|
||||
func (g *Generator) RegisterDecoderNatives() {
|
||||
g.DecoderNatives = map[string]FunctionGeneratorFunc{
|
||||
"container": ContainerDecoder,
|
||||
"array": ArrayDecoder,
|
||||
"option": OptionDecoder,
|
||||
"bitflags": TypeForwardDecoder,
|
||||
"switch": SwitchDecoder,
|
||||
"mapper": MapperDecoder,
|
||||
"buffer": BufferDecoder,
|
||||
"bitfield": BitFieldDecoder,
|
||||
"string": StringDecoder,
|
||||
|
||||
"void": VoidDecoder,
|
||||
"varint": VarIntDecoder,
|
||||
"varlong": VarLongDecoder,
|
||||
"anonymousNbt": DefaultDecoder,
|
||||
"anonOptionalNbt": DefaultDecoder, // I have no idea what the difference is between these two
|
||||
"lpVec3": DefaultDecoder,
|
||||
"UUID": UUIDDecoder,
|
||||
"restBuffer": DefaultDecoder,
|
||||
|
||||
"f32": SimpleTypeDecoder,
|
||||
"f64": SimpleTypeDecoder,
|
||||
"i8": SimpleTypeDecoder,
|
||||
"i16": SimpleTypeDecoder,
|
||||
"i32": SimpleTypeDecoder,
|
||||
"i64": SimpleTypeDecoder,
|
||||
"u8": SimpleTypeDecoder,
|
||||
"u16": SimpleTypeDecoder,
|
||||
"u32": SimpleTypeDecoder,
|
||||
"u64": SimpleTypeDecoder,
|
||||
"bool": SimpleTypeDecoder,
|
||||
|
||||
"registryEntryHolder": RegistryEntryHolderDecoder,
|
||||
"registryEntryHolderSet": ToDoDecoder, // RegistryEntryHolderSetDecoder
|
||||
"entityMetadataLoop": EntityMetadataLoopDecoder,
|
||||
"topBitSetTerminatedArray": ToDoDecoder,
|
||||
"todo": ToDoDecoder,
|
||||
}
|
||||
}
|
||||
Reference in New Issue
Block a user