haven/nexgb/xgbgen/request_reply.go

155 lines
4.3 KiB
Go
Raw Normal View History

package main
import (
"fmt"
"log"
2012-05-05 08:55:38 +02:00
"unicode"
)
// Request represents all XML 'request' nodes.
// If the request doesn't have a reply, Reply is nil.
type Request struct {
srcName string // The Go name of this request.
xmlName string // The XML name of this request.
2012-04-30 08:44:31 +02:00
Opcode int
2012-05-07 10:09:19 +02:00
Combine bool // Not currently used.
Fields []Field // All fields in the request.
2012-05-07 10:09:19 +02:00
Reply *Reply // A reply, if one exists for this request.
}
type Requests []*Request
func (rs Requests) Len() int { return len(rs) }
func (rs Requests) Swap(i, j int) { rs[i], rs[j] = rs[j], rs[i] }
func (rs Requests) Less(i, j int) bool { return rs[i].xmlName < rs[j].xmlName }
// Initialize creates the proper Go source name for this request.
// It also initializes the reply if one exists, and all fields in this request.
func (r *Request) Initialize(p *Protocol) {
r.srcName = SrcName(p, r.xmlName)
if p.isExt() {
r.srcName = r.srcName
}
if r.Reply != nil {
r.Reply.Initialize(p)
}
for _, field := range r.Fields {
field.Initialize(p)
}
}
func (r *Request) SrcName() string {
return r.srcName
}
func (r *Request) XmlName() string {
return r.xmlName
}
// ReplyName gets the Go source name of the function that generates a
// reply type from a slice of bytes.
// The generated function is not currently exported.
func (r *Request) ReplyName() string {
2012-05-05 08:55:38 +02:00
if r.Reply == nil {
log.Panicf("Cannot call 'ReplyName' on request %s, which has no reply.",
r.SrcName())
}
name := r.SrcName()
lower := string(unicode.ToLower(rune(name[0]))) + name[1:]
return fmt.Sprintf("%sReply", lower)
}
// ReplyTypeName gets the Go source name of the type holding all reply data
// for this request.
2012-05-05 08:55:38 +02:00
func (r *Request) ReplyTypeName() string {
if r.Reply == nil {
log.Panicf("Cannot call 'ReplyName' on request %s, which has no reply.",
r.SrcName())
}
return fmt.Sprintf("%sReply", r.SrcName())
}
// ReqName gets the Go source name of the function that generates a byte
// slice from a list of parameters.
// The generated function is not currently exported.
func (r *Request) ReqName() string {
2012-05-05 08:55:38 +02:00
name := r.SrcName()
lower := string(unicode.ToLower(rune(name[0]))) + name[1:]
return fmt.Sprintf("%sRequest", lower)
}
// CookieName gets the Go source name of the type that holds cookies for
// this request.
2012-05-05 08:55:38 +02:00
func (r *Request) CookieName() string {
return fmt.Sprintf("%sCookie", r.SrcName())
}
// Size for Request needs a context.
// Namely, if this is an extension, we need to account for *four* bytes
// of a header (extension opcode, request opcode, and the sequence number).
// If it's a core protocol request, then we only account for *three*
// bytes of the header (remove the extension opcode).
func (r *Request) Size(c *Context) Size {
size := newFixedSize(0, true)
// If this is a core protocol request, we squeeze in an extra byte of
2013-01-26 18:51:48 +01:00
// data (from the fields below) between the opcode and the size of the
// request. In an extension request, this byte is always occupied
// by the opcode of the request (while the first byte is always occupied
// by the opcode of the extension).
if !c.protocol.isExt() {
size = size.Add(newFixedSize(3, true))
} else {
size = size.Add(newFixedSize(4, true))
}
for _, field := range r.Fields {
switch field.(type) {
case *LocalField: // local fields don't go over the wire
continue
case *SingleField:
// mofos!!!
if r.SrcName() == "ConfigureWindow" &&
field.SrcName() == "ValueMask" {
continue
}
size = size.Add(field.Size())
default:
size = size.Add(field.Size())
}
}
2012-05-05 08:55:38 +02:00
return newExpressionSize(&Padding{
Expr: size.Expression,
}, size.exact)
}
// Reply encapsulates the fields associated with a 'reply' element.
type Reply struct {
Fields []Field
}
// Size gets the number of bytes in this request's reply.
// A reply always has at least 7 bytes:
// 1 byte: A reply discriminant (first byte set to 1)
// 2 bytes: A sequence number
// 4 bytes: Number of additional bytes in 4-byte units past initial 32 bytes.
func (r *Reply) Size() Size {
size := newFixedSize(0, true)
// Account for reply discriminant, sequence number and reply length
size = size.Add(newFixedSize(7, true))
for _, field := range r.Fields {
size = size.Add(field.Size())
}
return size
}
func (r *Reply) Initialize(p *Protocol) {
for _, field := range r.Fields {
field.Initialize(p)
}
}