Merge pull request #116 from named-data/codegen-reuse

codegen: reuse nat functions
named-data · Jan 26, 2025 · 5ada0e9 · 5ada0e9
2 parents e71cf8f + 5fd44f9
commit 5ada0e9
Show file tree

Hide file tree

Showing 16 changed files with 1,009 additions and 9,002 deletions.
diff --git a/dv/tlv/zz_generated.go b/dv/tlv/zz_generated.go
diff --git a/std/encoding/codegen/fields_name.go b/std/encoding/codegen/fields_name.go
@@ -64,29 +64,9 @@ func (f *NameField) GenEncodeInto() (string, error) {
 }
 
 func (f *NameField) GenReadFrom() (string, error) {
-	var g strErrBuf
-	const Temp = `value.{{.Name}} = make(enc.Name, l/2+1)
-	startName := reader.Pos()
-	endName := startName + int(l)
-	for j := range value.{{.Name}} {
-		if reader.Pos() >= endName {
-			value.{{.Name}} = value.{{.Name}}[:j]
-			break
-		}
-		var err1, err3 error
-		value.{{.Name}}[j].Typ, err1 = enc.ReadTLNum(reader)
-		l, err2 := enc.ReadTLNum(reader)
-		value.{{.Name}}[j].Val, err3 = reader.ReadBuf(int(l))
-		if err1 != nil || err2 != nil || err3 != nil {
-			err = io.ErrUnexpectedEOF
-			break
-		}
-	}
-	if err == nil && reader.Pos() != endName {
-		err = enc.ErrBufferOverflow
-	}
-	`
+	const Temp = `value.{{.Name}}, err = enc.ReadName(reader.Delegate(int(l)))`
 	t := template.Must(template.New("NameEncodeInto").Parse(Temp))
+	var g strErrBuf
 	g.executeTemplate(t, f)
 	return g.output()
 }

diff --git a/std/encoding/codegen/utils.go b/std/encoding/codegen/utils.go
@@ -44,69 +44,31 @@ func GenEncodeTypeNum(typeNum uint64) (string, error) {
 }
 
 func GenNaturalNumberLen(code string, isTlv bool) (string, error) {
-	const Temp = `switch x := {{.Code}}; {
-	{{- if .IsTlv}}
-	case x <= 0xfc:
-		l += 1
-	{{- else}}
-	case x <= 0xff:
-		l += 2
-	{{- end}}
-	case x <= 0xffff:
-		l += 3
-	case x <= 0xffffffff:
-		l += 5
-	default:
-		l += 9
-	}`
-	t := template.Must(template.New("NaturalNumberLen").Parse(Temp))
-	data := struct {
-		IsTlv bool
-		Code  string
-	}{
-		IsTlv: isTlv,
-		Code:  code,
+	var temp string
+	if isTlv {
+		temp = `l += uint(enc.TLNum({{.}}).EncodingLength())`
+	} else {
+		temp = `l += uint(1 + enc.Nat({{.}}).EncodingLength())`
 	}
+	t := template.Must(template.New("NaturalNumberLen").Parse(temp))
 	b := strings.Builder{}
-	err := t.Execute(&b, data)
+	err := t.Execute(&b, code)
 	return b.String(), err
 }
 
 func GenNaturalNumberEncode(code string, isTlv bool) (string, error) {
-	const Temp = `switch x := {{.Code}}; {
-	{{- if .IsTlv}}
-	case x <= 0xfc:
-		buf[pos] = byte(x)
-		pos += 1
-	{{- else}}
-	case x <= 0xff:
-		buf[pos] = 1
-		buf[pos+1] = byte(x)
-		pos += 2
-	{{- end}}
-	case x <= 0xffff:
-		buf[pos] = {{if .IsTlv -}} 0xfd {{- else -}} 2 {{- end}}
-		binary.BigEndian.PutUint16(buf[pos+1:], uint16(x))
-		pos += 3
-	case x <= 0xffffffff:
-		buf[pos] = {{if .IsTlv -}} 0xfe {{- else -}} 4 {{- end}}
-		binary.BigEndian.PutUint32(buf[pos+1:], uint32(x))
-		pos += 5
-	default:
-		buf[pos] = {{if .IsTlv -}} 0xff {{- else -}} 8 {{- end}}
-		binary.BigEndian.PutUint64(buf[pos+1:], uint64(x))
-		pos += 9
-	}`
-	t := template.Must(template.New("NaturalNumberEncode").Parse(Temp))
-	data := struct {
-		IsTlv bool
-		Code  string
-	}{
-		IsTlv: isTlv,
-		Code:  code,
+	var temp string
+	if isTlv {
+		temp = `pos += uint(enc.TLNum({{.}}).EncodeInto(buf[pos:]))`
+	} else {
+		temp = `
+			buf[pos] = byte(enc.Nat({{.}}).EncodeInto(buf[pos+1:]))
+			pos += uint(1 + buf[pos])
+		`
 	}
+	t := template.Must(template.New("NaturalNumberEncode").Parse(temp))
 	b := strings.Builder{}
-	err := t.Execute(&b, data)
+	err := t.Execute(&b, code)
 	return b.String(), err
 }
 

diff --git a/std/encoding/primitives.go b/std/encoding/primitives.go
@@ -109,22 +109,20 @@ func (v Nat) EncodingLength() int {
 }
 
 func (v Nat) EncodeInto(buf Buffer) int {
-	pos := 0
 	switch x := uint64(v); {
 	case x <= 0xff:
-		buf[pos] = byte(x)
-		pos += 1
+		buf[0] = byte(x)
+		return 1
 	case x <= 0xffff:
 		binary.BigEndian.PutUint16(buf, uint16(x))
-		pos += 2
+		return 2
 	case x <= 0xffffffff:
 		binary.BigEndian.PutUint32(buf, uint32(x))
-		pos += 4
+		return 4
 	default:
 		binary.BigEndian.PutUint64(buf, uint64(x))
-		pos += 8
+		return 8
 	}
-	return pos
 }
 
 func (v Nat) Bytes() []byte {