sashakoshka/hopp
sashakoshka/hopp
1
0
Fork 0
Code Issues 4 Pull Requests 1 Actions Packages Projects Releases Wiki Activity

generate: Fix more nonsense surrounding named types

Browse Source
This commit is contained in:
Sasha Koshka 2025-07-11 20:08:43 -04:00
parent 2305814e10
commit af7669c783
2 changed files with 27 additions and 54 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

57
generate/generate.go
View File

@ -193,7 +193,18 @@ func (this *Generator) generateMessage(method uint16, message Message) (n int, e
nn, err = this.iprintf("}\n")
n += nn; if err != nil { return n, err }
// TODO decode method
// Decode method
nn, err = this.iprintf("\n// Decode decodes this message's tag and value.\n")
n += nn; if err != nil { return n, err }
nn, err = this.iprintf(
"func(this *%s) Decode(encoder *tape.Decoder) (n int, err error) {\n",
this.resolveMessageName(message.Name))
n += nn; if err != nil { return n, err }
this.push()
// TODO
this.pop()
nn, err = this.iprintf("}\n")
n += nn; if err != nil { return n, err }
return n, nil
}
@ -351,11 +362,6 @@ func (this *Generator) generateEncodeValue(typ Type, valueSource, tagSource stri
n += nn; if err != nil { return n, err }
case TypeNamed:
// WHATEVER: [WHATEVER]
if builtin := this.resolveBuiltinType(typ.Name); builtin != nil {
nn, err := this.generateEncodeValue(builtin, valueSource, tagSource)
n += nn; if err != nil { return n, err }
return n, nil
}
nn, err := this.iprintf("nn, err = %s.EncodeValue(encoder, %s)\n", valueSource, tagSource)
n += nn; if err != nil { return n, err }
nn, err = this.generateErrorCheck()
@ -376,7 +382,9 @@ func (this *Generator) generateEncodeValue(typ Type, valueSource, tagSource stri
// - err error
// - nn int
func (this *Generator) generateDecodeValue(typ Type, valueSource, tagSource string) (n int, err error) {
// TODO
// TODO generate stub so the code runs and we can test encoding at least+
return 0, nil
}
@ -508,11 +516,6 @@ func (this *Generator) generateType(typ Type) (n int, err error) {
nn, err := this.generateTypeTableDefined(typ)
n += nn; if err != nil { return n, err }
case TypeNamed:
if builtin := this.resolveBuiltinType(typ.Name); builtin != nil {
nn, err := this.generateType(builtin)
n += nn; if err != nil { return n, err }
return n, nil
}
nn, err := this.print(typ.Name)
n += nn; if err != nil { return n, err }
}
@ -598,10 +601,6 @@ func (this *Generator) resolveMessageName(message string) string {
}
func (this *Generator) resolveTypeName(name string) (Type, error) {
if typ := this.resolveBuiltinType(name); typ != nil {
return typ, nil
}
if typ, ok := this.protocol.Types[name]; ok {
if typ, ok := typ.(TypeNamed); ok {
return this.resolveTypeName(typ.Name)
@ -612,32 +611,6 @@ func (this *Generator) resolveTypeName(name string) (Type, error) {
return nil, fmt.Errorf("no type exists called %s", name)
}
func (this *Generator) resolveBuiltinType(name string) Type {
switch name {
case "U8": return TypeInt { Bits: 8 }
case "U16": return TypeInt { Bits: 16 }
case "U32": return TypeInt { Bits: 32 }
case "U64": return TypeInt { Bits: 64 }
case "U128": return TypeInt { Bits: 128 }
case "U256": return TypeInt { Bits: 256 }
case "I8": return TypeInt { Bits: 8, Signed: true }
case "I16": return TypeInt { Bits: 16, Signed: true }
case "I32": return TypeInt { Bits: 32, Signed: true }
case "I64": return TypeInt { Bits: 64, Signed: true }
case "I128": return TypeInt { Bits: 128, Signed: true }
case "I256": return TypeInt { Bits: 256, Signed: true }
case "F16": return TypeFloat { Bits: 16 }
case "F32": return TypeFloat { Bits: 32 }
case "F64": return TypeFloat { Bits: 64 }
case "F128": return TypeFloat { Bits: 128 }
case "F256": return TypeFloat { Bits: 256 }
case "String": return TypeString { }
case "Buffer": return TypeBuffer { }
case "Table": return TypeTable { }
}
return nil
}
func bitsToBytes(bits int) int {
return int(math.Ceil(float64(bits) / 8.0))
}

22
generate/generate_test.go
View File

@ -149,8 +149,8 @@ func TestGenerate(test *testing.T) {
Name: "Connect",
Type: TypeTableDefined {
Fields: map[uint16] Field {
0x0000: Field { Name: "Name", Type: TypeNamed { Name: "String" } },
0x0001: Field { Name: "Password", Type: TypeNamed { Name: "String" } },
0x0000: Field { Name: "Name", Type: TypeString { } },
0x0001: Field { Name: "Password", Type: TypeString { } },
},
},
}
@ -164,9 +164,9 @@ func TestGenerate(test *testing.T) {
}
protocol.Types["User"] = TypeTableDefined {
Fields: map[uint16] Field {
0x0000: Field { Name: "Name", Type: TypeNamed { Name: "String" } },
0x0001: Field { Name: "Bio", Type: TypeNamed { Name: "String" } },
0x0002: Field { Name: "Followers", Type: TypeNamed { Name: "U32" } },
0x0000: Field { Name: "Name", Type: TypeString { } },
0x0001: Field { Name: "Bio", Type: TypeString { } },
0x0002: Field { Name: "Followers", Type: TypeInt { Bits: 32 } },
},
}
@ -201,8 +201,8 @@ func TestGenerateRun(test *testing.T) {
Name: "Connect",
Type: TypeTableDefined {
Fields: map[uint16] Field {
0x0000: Field { Name: "Name", Type: TypeNamed { Name: "String" } },
0x0001: Field { Name: "Password", Type: TypeNamed { Name: "String" } },
0x0000: Field { Name: "Name", Type: TypeString { } },
0x0001: Field { Name: "Password", Type: TypeString { } },
},
},
}
@ -216,9 +216,9 @@ func TestGenerateRun(test *testing.T) {
}
protocol.Types["User"] = TypeTableDefined {
Fields: map[uint16] Field {
0x0000: Field { Name: "Name", Type: TypeNamed { Name: "String" } },
0x0001: Field { Name: "Bio", Type: TypeNamed { Name: "String" } },
0x0002: Field { Name: "Followers", Type: TypeNamed { Name: "U32" } },
0x0000: Field { Name: "Name", Type: TypeString { } },
0x0001: Field { Name: "Bio", Type: TypeString { } },
0x0002: Field { Name: "Followers", Type: TypeInt { Bits: 32 } },
},
}
testGenerateRun(test, &protocol, `
@ -230,7 +230,7 @@ func TestGenerateRun(test *testing.T) {
Password: "gems",
}
testEncode(
messageConnect,
&messageConnect,
0x0) // TODO
`)
}