diff --git a/generate/generate.go b/generate/generate.go index 5e33bdf..34f86ba 100644 --- a/generate/generate.go +++ b/generate/generate.go @@ -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 } } @@ -597,11 +600,7 @@ func (this *Generator) resolveMessageName(message string) string { return "Message" + message } -func (this *Generator) resolveTypeName(name string) (Type, error) { - if typ := this.resolveBuiltinType(name); typ != nil { - return typ, nil - } - +func (this *Generator) resolveTypeName(name string) (Type, error) { 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)) } diff --git a/generate/generate_test.go b/generate/generate_test.go index ceb2ac9..a25b807 100644 --- a/generate/generate_test.go +++ b/generate/generate_test.go @@ -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 `) }