generate/generate.go

@@ -34,19 +34,6 @@ type Message interface {
 	// Method returns the method code of the message.
 	Method() uint16
 }
-
-// canAssign determines if data from the given source tag can be assigned to
-// a Go type represented by destination. It is designed to receive destination
-// values from [generate.Generator.generateCanAssign]. The eventual Go type and
-// the destination tag must come from the same (or hash-equivalent) PDL type.
-func canAssign(destination, source tape.Tag) bool {
-	if destination.Is(source) { return true }
-	if (destination == tape.SBA || destination == tape.LBA) &&
-		(source == tape.SBA || source == tape.LBA) {
-		return true
-	}
-	return false
-}
 `
 
 // Generator converts protocols into Go code.
@@ -175,24 +162,6 @@ func (this *Generator) generateTypedef(name string, typ Type) (n int, err error)
 	this.push()
 		nn, err = this.iprintf("var nn int\n")
 		n += nn; if err != nil { return n, err }
-
-		nn, err = this.iprintf("if !(")
-		n += nn; if err != nil { return n, err }
-		nn, err = this.generateCanAssign(typ, "tag")
-		n += nn; if err != nil { return n, err }
-		nn, err = this.printf(") {\n")
-		n += nn; if err != nil { return n, err }
-		this.push()
-			nn, err = this.iprintf("nn, err = tape.Skim(decoder, tag)\n")
-			n += nn; if err != nil { return n, err }
-			nn, err = this.generateErrorCheck()
-			n += nn; if err != nil { return n, err }
-			nn, err = this.iprintf("return n, nil\n")
-			n += nn; if err != nil { return n, err }
-		this.pop()
-		nn, err = this.iprintf("}\n")
-		n += nn; if err != nil { return n, err }
-		
 		nn, err = this.generateDecodeValue(typ, "this", "tag")
 		n += nn; if err != nil { return n, err }
 		nn, err = this.iprintf("return n, nil\n")
@@ -264,24 +233,15 @@ func (this *Generator) generateMessage(method uint16, message Message) (n int, e
 		n += nn; if err != nil { return n, err }
 		nn, err = this.generateErrorCheck()
 		n += nn; if err != nil { return n, err }
-
+		nn, err = this.iprintf("if !tag.Is(")
-		nn, err = this.iprintf("if !(")
 		n += nn; if err != nil { return n, err }
-		nn, err = this.generateCanAssign(message.Type, "tag")
+		nn, err = this.generateTN(message.Type)
 		n += nn; if err != nil { return n, err }
 		nn, err = this.printf(") {\n")
 		n += nn; if err != nil { return n, err }
-		this.push()
+			// TODO skip value using the correct TAPE function and return
-			nn, err = this.iprintf("nn, err = tape.Skim(decoder, tag)\n")
-			n += nn; if err != nil { return n, err }
-			nn, err = this.generateErrorCheck()
-			n += nn; if err != nil { return n, err }
-			nn, err = this.iprintf("return n, nil\n")
-			n += nn; if err != nil { return n, err }
-		this.pop()
 		nn, err = this.iprintf("}\n")
 		n += nn; if err != nil { return n, err }
-		
 		nn, err = this.generateDecodeValue(message.Type, "this", "tag")
 		n += nn; if err != nil { return n, err }
 		nn, err = this.iprintf("return n, nil\n")
@@ -578,7 +538,7 @@ func (this *Generator) generateDecodeValue(typ Type, valueSource, tagSource stri
 //   - nn int
 func (this *Generator) generateDecodeBranchCall(typ Type, valueSource, tagSource string) (n int, err error) {
 	hash := HashType(typ)
-	nn, err := this.iprintf("nn, err = %s(%s, decoder, %s)\n", this.decodeBranchName(hash), valueSource, tagSource)
+	nn, err := this.iprintf("nn, err = %s(%s, %s)\n", this.decodeBranchName(hash), valueSource, tagSource)
 	n += nn; if err != nil { return n, err }
 	nn, err = this.generateErrorCheck()
 	n += nn; if err != nil { return n, err }
@@ -589,11 +549,11 @@ func (this *Generator) generateDecodeBranchCall(typ Type, valueSource, tagSource
 // generateDecodeBranch generates an aggregate decoder function definition for a
 // specified type. It assumes that hash == HashType(typ).
 func (this *Generator) generateDecodeBranch(hash [16]byte, typ Type) (n int, err error) {
-	nn, err := this.iprintf("\nfunc %s[T ~", this.decodeBranchName(hash))
+	nn, err := this.iprintf("func %s(this *", this.decodeBranchName(hash))
 	n += nn; if err != nil { return n, err }
 	nn, err = this.generateType(typ)
 	n += nn; if err != nil { return n, err }
-	nn, err = this.printf("](this *T, decoder *tape.Decoder, tag tape.Tag) (n int, err error) {\n")
+	nn, err = this.printf(" decoder *tape.Decoder, tag tape.Tag) (nn int, err error) \n{")
 	n += nn; if err != nil { return n, err }
 	this.push()
 	
@@ -625,14 +585,14 @@ func (this *Generator) generateDecodeBranch(hash [16]byte, typ Type) (n int, err
 				nn, err = this.iprintf("for _ = range %s {\n", lengthVar)
 				n += nn; if err != nil { return n, err }
 				this.push()
-					nn, err = this.iprintf("nn, err = tape.Skim(decoder, %s)\n", elementTagVar)
+					nn, err = this.iprintf("nn, err = tape.Skim(decoder, tag)")
 					n += nn; if err != nil { return n, err }
 					nn, err = this.generateErrorCheck()
 					n += nn; if err != nil { return n, err }
 				this.pop()
 				nn, err = this.iprintf("}\n")
 				n += nn; if err != nil { return n, err }
-				nn, err = this.iprintf("return n, nil\n")
+				nn, err = this.iprintf("return n, nil")
 				n += nn; if err != nil { return n, err }
 				return n, nil
 			}
@@ -642,11 +602,11 @@ func (this *Generator) generateDecodeBranch(hash [16]byte, typ Type) (n int, err
 			// max, whatever that is configured to be. the reason we
 			// want to read it here is that we would have to skip
 			// the tag anyway so why not.
-			nn, err = this.iprintf("if !(")
+			nn, err = this.iprintf("if %s != ", elementTagVar)
 			n += nn; if err != nil { return n, err }
-			nn, err = this.generateCanAssign(typ.Element, elementTagVar)
+			nn, err = this.generateTag(typ.Element, "(*this)")
 			n += nn; if err != nil { return n, err }
-			nn, err = this.printf(") {\n")
+			nn, err = this.printf(" {\n")
 			n += nn; if err != nil { return n, err }
 			this.push()
 				nn, err = abort()
@@ -662,7 +622,7 @@ func (this *Generator) generateDecodeBranch(hash [16]byte, typ Type) (n int, err
 			n += nn; if err != nil { return n, err }
 			nn, err = this.printf(", %s)\n", lengthVar)
 			n += nn; if err != nil { return n, err }
-			nn, err = this.iprintf("for index := range int(%s) {\n", lengthVar)
+			nn, err = this.iprintf("for index := range %s {\n", lengthVar)
 			n += nn; if err != nil { return n, err }
 			this.push()
 				nn, err = this.generateDecodeValue(typ.Element, "(*this)[index]", elementTagVar)
@@ -672,106 +632,12 @@ func (this *Generator) generateDecodeBranch(hash [16]byte, typ Type) (n int, err
 			n += nn; if err != nil { return n, err }
 		case TypeTableDefined:
 			// KTV: <length: UN> (<key: U16> <tag: Tag> <value>)*
-			// read header
+			// TODO
-			lengthVar := this.newTemporaryVar("length")
-			nn, err := this.iprintf("var %s uint64\n", lengthVar)
-			n += nn; if err != nil { return n, err }
-			nn, err = this.iprintf("%s, nn, err = decoder.ReadUintN(int(tag.CN()))\n", lengthVar)
-			n += nn; if err != nil { return n, err }
-			nn, err = this.generateErrorCheck()
-			n += nn; if err != nil { return n, err }
-			indexVar := this.newTemporaryVar("index")
-			nn, err = this.iprintf("%s := 0\n", indexVar)
-			n += nn; if err != nil { return n, err }
-			
-			// validate header
-			// TODO: here, validate that length is less than the
-			// max, whatever that is configured to be. if not, stop
-			// ALL decoding. skimming huge big ass data could cause
-			// problems
-
-			// read fields
-			nn, err = this.iprintf("for %s = range int(%s) {\n", indexVar, lengthVar)
-			n += nn; if err != nil { return n, err }
-			this.push()
-				// read field header
-				fieldKeyVar := this.newTemporaryVar("fieldKey")
-				nn, err = this.iprintf("var %s uint16\n", fieldKeyVar)
-				n += nn; if err != nil { return n, err }
-				nn, err = this.iprintf("%s, nn, err = decoder.ReadUint16()\n", fieldKeyVar)
-				n += nn; if err != nil { return n, err }
-				nn, err = this.generateErrorCheck()
-				n += nn; if err != nil { return n, err }
-				fieldTagVar := this.newTemporaryVar("fieldTag")
-				nn, err = this.iprintf("var %s tape.Tag\n", fieldTagVar)
-				n += nn; if err != nil { return n, err }
-				nn, err = this.iprintf("%s, nn, err = decoder.ReadTag()\n", fieldTagVar)
-				n += nn; if err != nil { return n, err }
-				nn, err = this.generateErrorCheck()
-				n += nn; if err != nil { return n, err }
-
-				// abort field macro
-				abortField := func() (n int, err error) {
-					nn, err = this.iprintf("tape.Skim(decoder, %s)\n", fieldTagVar)
-					n += nn; if err != nil { return n, err }
-					nn, err = this.iprintf("continue\n")
-					n += nn; if err != nil { return n, err }
-					return n, nil
-				}
-
-				// switch on tag
-				nn, err = this.iprintf("switch %s {\n", fieldKeyVar)
-				n += nn; if err != nil { return n, err }
-				for _, key := range slices.Sorted(maps.Keys(typ.Fields)) {
-					field := typ.Fields[key]
-					nn, err = this.iprintf("case 0x%04X:\n", key)
-					n += nn; if err != nil { return n, err }
-					this.push()
-
-					// validate field header
-					nn, err = this.iprintf("if !(")
-					n += nn; if err != nil { return n, err }
-					nn, err = this.generateCanAssign(field.Type, fieldTagVar)
-					n += nn; if err != nil { return n, err }
-					nn, err = this.printf(") {\n")
-					n += nn; if err != nil { return n, err }
-					this.push()
-						nn, err = abortField()
-						n += nn; if err != nil { return n, err }
-					this.pop()
-					nn, err = this.iprintf("}\n")
-					n += nn; if err != nil { return n, err }
-
-					// decode payload
-					nn, err = this.generateDecodeValue(field.Type, fmt.Sprintf("&(this.%s)", field.Name), fieldTagVar)
-					n += nn; if err != nil { return n, err }
-					this.pop()
-				}					
-				nn, err = this.iprintf("default:\n")
-				n += nn; if err != nil { return n, err }
-				this.push()
-					abortField()
-				this.pop()
-				nn, err = this.iprintf("}\n")
-				n += nn; if err != nil { return n, err }
-			this.pop()
-			nn, err = this.iprintf("}\n")
-			n += nn; if err != nil { return n, err }
-			
-			// TODO once options are implemented, have a set of
-			// bools for each non-optional field, and check here
-			// that they are all true. a counter will not work
-			// because if someone specifies a non-optional field
-			// twice, they can neglect to specify another
-			// non-optional field and we won't even know because the
-			// count will still be even. we shouldn't use a map
-			// either because its an allocation and its way more
-			// memory than just, like 5 bools (on the stack no less)
 		default: return n, fmt.Errorf("unexpected type: %T", typ)
 		}
 
 	this.pop()
-	nn, err = this.iprintf("}\n")
+	nn, err = this.iprintf("}")
 	n += nn; if err != nil { return n, err }
 	return n, nil
 }
@@ -965,19 +831,6 @@ func (this *Generator) generateTypeTableDefined(typ TypeTableDefined) (n int, er
 	return n, nil
 }
 
-// generateCanAssign generates an expression which checks if the tag specified
-// by tagSource can be assigned to a Go destination generated from typ. The
-// generated code is INLINE.
-func (this *Generator) generateCanAssign(typ Type, tagSource string) (n int, err error) {
-	nn, err := this.printf("canAssign(")
-	n += nn; if err != nil { return n, err }
-	nn, err = this.generateTN(typ)
-	n += nn; if err != nil { return n, err }
-	nn, err = this.printf(", %s)", tagSource)
-	n += nn; if err != nil { return n, err }
-	return n, nil
-}
-
 func (this *Generator) validateIntBitSize(size int) error {
 	switch size {
 	case 5, 8, 16, 32, 64: return nil