Merge pull request #17 from ethanmoffat/fix_gen

Fix generated code: bug discovery from eolib-dotnet implementation

Author: ethanmoffat

README.md

@@ -9,7 +9,7 @@ Core library for writing Endless Online applications using the Go programming la
 The library may be referenced in a project via go get:
 
 ```
-go get github.com/ethanmoffat/eolib-go@v2.0.1
+go get github.com/ethanmoffat/eolib-go@v2.1.0
 ```
 
 ### Sample code

internal/codegen/shared.go

@@ -99,7 +99,7 @@ func snakeCaseToCamelCase(input string) string {
 				if ndx != 0 {
 					tmp = tmp + string(unicode.ToUpper(rune(out[ndx+1])))
 				} else {
-					tmp = tmp + string(out[ndx+1])
+					tmp = tmp + string(unicode.ToLower(rune(out[ndx+1])))
 				}
 			}
 

internal/codegen/struct.go

@@ -41,27 +41,25 @@ func CalculateTypeSize(typeName string, fullSpec xml.Protocol) (res int, err err
 		return getPrimitiveTypeSize(typeName, fullSpec)
 	}
 
-	var flattenedInstList []xml.ProtocolInstruction
-	for _, instruction := range (*structInfo).Instructions {
-		if instruction.XMLName.Local == "chunked" {
-			flattenedInstList = append(flattenedInstList, instruction.Chunked...)
-		} else {
-			flattenedInstList = append(flattenedInstList, instruction)
-		}
-	}
-
+	flattenedInstList := xml.Flatten((*structInfo).Instructions)
 	for _, instruction := range flattenedInstList {
 		switch instruction.XMLName.Local {
+		case "array":
+			fallthrough
 		case "field":
-			fieldTypeName, fieldTypeSize := GetInstructionTypeName(instruction)
+			fieldTypeName, fieldTypeSize := GetInstructionTypeName(*instruction)
 			if fieldTypeSize != "" {
 				fieldTypeName = fieldTypeSize
 			}
 
 			if instruction.Length != nil {
 				if length, err := strconv.ParseInt(*instruction.Length, 10, 32); err == nil {
 					// length is a numeric constant
-					res += int(length)
+					if fieldSize, err := CalculateTypeSize(fieldTypeName, fullSpec); err == nil {
+						res += fieldSize * int(length)
+					} else {
+						return 0, err
+					}
 				} else {
 					return 0, fmt.Errorf("instruction length %s must be a fixed size for %s (%s)", *instruction.Length, *instruction.Name, instruction.XMLName.Local)
 				}
@@ -74,8 +72,6 @@ func CalculateTypeSize(typeName string, fullSpec xml.Protocol) (res int, err err
 			}
 		case "break":
 			res += 1
-		case "array":
-		case "dummy":
 		}
 	}
 

internal/codegen/types/typesize.go

@@ -53,7 +53,12 @@ type ProtocolValue struct {
 }
 
 type ProtocolInstruction struct {
+	// XMLName is the XML element name of this instruction.
 	XMLName xml.Name
+	// IsChunked is True if this instruction appears within a "chunked" section
+	IsChunked bool
+	// ReferencedBy is the name of the instruction that references this instruction. This is only set for length instructions which are referenced by another instruction.
+	ReferencedBy *string
 
 	// ProtocolField properties
 	Name     *string `xml:"name,attr"`
@@ -87,6 +92,8 @@ type ProtocolInstruction struct {
 }
 
 type ProtocolCase struct {
+	IsChunked bool
+
 	Value        string                `xml:"value,attr"`
 	Default      bool                  `xml:"default,attr"`
 	Comment      string                `xml:"comment"`
@@ -95,19 +102,65 @@ type ProtocolCase struct {
 
 type OrdinalValue int
 
-func validate(instructions []ProtocolInstruction) error {
-	for _, inst := range instructions {
+func Flatten(instructions []ProtocolInstruction) []*ProtocolInstruction {
+	var flattenedInstList []*ProtocolInstruction
+	for ndx, instruction := range instructions {
+		if instruction.XMLName.Local == "chunked" {
+			flattenedInstList = append(flattenedInstList, Flatten(instruction.Chunked)...)
+		} else {
+			// note: when flattening, switches are *not* flattened as they may have cases with instructions with name collisions
+			// see: CharacterReplyServerPacket
+			flattenedInstList = append(flattenedInstList, &instructions[ndx])
+		}
+	}
+	return flattenedInstList
+}
+
+func getLengthInstructions(instructions []ProtocolInstruction) (lengthInstructions []*ProtocolInstruction) {
+	flattened := Flatten(instructions)
+	for i, inst := range flattened {
+		if inst.XMLName.Local == "length" {
+			lengthInstructions = append(lengthInstructions, flattened[i])
+		}
+	}
+	return
+}
+
+func findLengthInstructionByName(lengthName string, lengthInstructions []*ProtocolInstruction) *ProtocolInstruction {
+	for i, inst := range lengthInstructions {
+		if inst.Name != nil && *inst.Name == lengthName {
+			return lengthInstructions[i]
+		}
+	}
+	return nil
+}
+
+func validate(instructions []ProtocolInstruction, isChunked bool, lengthInstructions []*ProtocolInstruction) error {
+	localLengths := append(lengthInstructions, getLengthInstructions(instructions)...)
+
+	for i, inst := range instructions {
+		if isChunked {
+			instructions[i].IsChunked = true
+		}
+
+		if inst.Length != nil {
+			if lengthInstruction := findLengthInstructionByName(*inst.Length, localLengths); lengthInstruction != nil {
+				lengthInstruction.ReferencedBy = new(string)
+				*lengthInstruction.ReferencedBy = *inst.Name
+			}
+		}
+
 		if err := inst.Validate(); err != nil {
 			return err
 		}
 
-		if err := validate(inst.Chunked); err != nil {
+		if err := validate(inst.Chunked, true, localLengths); err != nil {
 			return err
 		}
 
 		if len(inst.Cases) > 0 {
 			for _, cs := range inst.Cases {
-				if err := validate(cs.Instructions); err != nil {
+				if err := validate(cs.Instructions, isChunked, localLengths); err != nil {
 					return err
 				}
 			}
@@ -119,13 +172,13 @@ func validate(instructions []ProtocolInstruction) error {
 
 func (p Protocol) Validate() error {
 	for _, st := range p.Structs {
-		if err := validate(st.Instructions); err != nil {
+		if err := validate(st.Instructions, false, nil); err != nil {
 			return err
 		}
 	}
 
 	for _, pkt := range p.Packets {
-		if err := validate(pkt.Instructions); err != nil {
+		if err := validate(pkt.Instructions, false, nil); err != nil {
 			return err
 		}
 	}
@@ -199,7 +252,7 @@ func (pi ProtocolInstruction) Validate() error {
 		fieldName := reflectType.Field(i)
 		fieldValue := reflectValue.Field(i)
 
-		if fieldName.Name == "XMLName" {
+		if fieldName.Name == "XMLName" || fieldName.Name == "IsChunked" || fieldName.Name == "ReferencedBy" {
 			continue
 		}