last commit before i tear everything down

nexgb/.gitignore

@@ -1,2 +1,2 @@
-xgbgen
+xgbgen/xgbgen
 .*.swp

nexgb/xgbgen/COPYING

@@ -0,0 +1,13 @@
+            DO WHAT THE FUCK YOU WANT TO PUBLIC LICENSE
+                    Version 2, December 2004
+
+ Copyright (C) 2004 Sam Hocevar <sam@hocevar.net>
+
+ Everyone is permitted to copy and distribute verbatim or modified
+ copies of this license document, and changing it is allowed as long
+ as the name is changed.
+
+            DO WHAT THE FUCK YOU WANT TO PUBLIC LICENSE
+   TERMS AND CONDITIONS FOR COPYING, DISTRIBUTION AND MODIFICATION
+
+  0. You just DO WHAT THE FUCK YOU WANT TO.

nexgb/xgbgen/bufcount.go

@@ -0,0 +1,15 @@
+package main
+
+/*
+	A buffer count is a mechanism by which to keep track of which byte one
+	is reading or writing to/from the wire.
+
+	It's an abstraction over the fact that while such a counter is usually
+	fixed, it can be made variable based on values at run-time.
+*/
+
+type BufCount struct {
+	Fixed int
+	Exprs []*Expression
+}
+

nexgb/xgbgen/go.go

@@ -23,6 +23,7 @@ package main
 */
 
 import (
+	"fmt"
 	"log"
 	"strings"
 )
@@ -214,16 +215,12 @@ func (bitcase *Bitcase) MorphDefine(c *Context) {
 	bitcase.Fields.MorphDefine(c)
 }
 
-func (fields Fields) MorphRead(c *Context, kind int, evNoSeq bool) {
-	var nextByte uint
-
-	switch kind {
-	case FieldsEvent:
-		nextByte = 1
-	}
+func (fields Fields) MorphRead(c *Context, kind int, evNoSeq bool,
+	prefix string, byt uint) uint {
 
+	nextByte := byt
 	for _, field := range fields {
-		nextByte = field.MorphRead(c, kind, nextByte)
+		nextByte = field.MorphRead(c, kind, nextByte, prefix)
 		switch kind {
 		case FieldsEvent:
 			// Skip the sequence id
@@ -232,23 +229,58 @@ func (fields Fields) MorphRead(c *Context, kind int, evNoSeq bool) {
 			}
 		}
 	}
+	return nextByte
 }
 
-func (field *Field) MorphRead(c *Context, kind int, byt uint) uint {
-	consumed := uint(0)
+func (field *Field) MorphRead(c *Context, kind int, byt uint,
+	prefix string) uint {
+
+	nextByte := byt
 	switch field.XMLName.Local {
 	case "pad":
-		consumed = uint(field.Bytes)
+		nextByte += uint(field.Bytes)
 	case "field":
-		if field.Type == "ClientMessageData" {
-			break
+		nextByte = field.MorphReadField(c, kind, nextByte, prefix)
+	case "list":
+		typ := field.Type.Morph(c)
+
+		// Create a temporary Field so we can use MorphReadField.
+		// temp := &Field{ 
+			// XMLName: xml.Name{Local: "field"}, 
+			// Name: field.Name, 
+			// Type: field.Type, 
+		// } 
+
+		// Special case: if the list is just raw bytes, use copy!
+		if typ == "byte" {
+			c.Putln("copy(%s%s, buf[%d:])", prefix, field.Name.Morph(c),
+				byt)
+			nextByte = byt + 20
+		} else {
+			c.Putln("//list!")
 		}
+	}
+	return nextByte
+}
+
+func (field *Field) MorphReadField(c *Context, kind int, byt uint,
+	prefix string) uint {
+
+	if union := field.Type.Union(c); union != nil {
+		c.Putln("")
+		c.Putln("%s%s = %s{}", prefix, field.Name.Morph(c), field.Type.Morph(c))
+		union.Fields.MorphRead(c, kind, false,
+			fmt.Sprintf("%s%s.", prefix, field.Name.Morph(c)), byt)
+		c.Putln("")
+		return byt
+	}
+
 	size := field.Type.Size(c)
 	typ := field.Type.Morph(c)
 	name := field.Name.Morph(c)
 	_, isBase := BaseTypeMap[string(field.Type)]
 
-		c.Put("v.%s = ", name)
+	c.Put("%s%s = ", prefix, name)
 	if !isBase {
 		c.Put("%s(", typ)
 	}
@@ -266,11 +298,7 @@ func (field *Field) MorphRead(c *Context, kind int, byt uint) uint {
 	}
 	c.Putln("")
 
-		consumed = size
-	case "list":
-		c.Putln("")
-	}
-	return byt + consumed
+	return byt + size
 }
 
 func (fields Fields) MorphWrite(c *Context, kind int) {
@@ -377,7 +405,7 @@ func (ev *Event) Morph(c *Context) {
 	c.Putln("")
 	c.Putln("func New%s(buf []byte) %sEvent {", name, name)
 	c.Putln("var v %sEvent", name)
-	ev.Fields.MorphRead(c, FieldsEvent, ev.NoSequence)
+	ev.Fields.MorphRead(c, FieldsEvent, ev.NoSequence, "v.", 1)
 	c.Putln("return v")
 	c.Putln("}")
 	c.Putln("")

nexgb/xgbgen/xml.go

@@ -166,6 +166,48 @@ type Name string
 
 type Type string
 
+// Union returns the 'Union' struct corresponding to this type, if
+// one exists.
+func (typ Type) Union(c *Context) *Union {
+	// If this is a typedef, use that instead.
+	if oldTyp, ok := typ.TypeDef(c); ok {
+		return oldTyp.Union(c)
+	}
+
+	// Otherwise, just look for a union type with 'typ' name.
+	for _, union := range c.xml.Unions {
+		if typ == union.Name {
+			return union
+		}
+	}
+	for _, imp := range c.xml.Imports {
+		for _, union := range imp.xml.Unions {
+			if typ == union.Name {
+				return union
+			}
+		}
+	}
+	return nil
+}
+
+// TypeDef returns the 'old' type corresponding to this type, if it's found
+// in a type def. If not found, the second return value is false.
+func (typ Type) TypeDef(c *Context) (Type, bool) {
+	for _, typedef := range c.xml.TypeDefs {
+		if typ == typedef.New {
+			return typedef.Old, true
+		}
+	}
+	for _, imp := range c.xml.Imports {
+		for _, typedef := range imp.xml.TypeDefs {
+			if typ == typedef.New {
+				return typedef.Old, true
+			}
+		}
+	}
+	return "", false
+}
+
 // Size is a nifty function that takes any type and digs until it finds
 // its underlying base type. At which point, the size can be determined.
 func (typ Type) Size(c *Context) uint {