p/haven
1
0
Fork 0
Code Issues 1 Pull Requests Releases Wiki Activity

gofmt

Browse Source
This commit is contained in:
Andrew Gallant (Ocelot) 2012-04-30 02:44:31 -04:00
parent 05d8ec6a16
commit 2a2d8653b3
14 changed files with 163 additions and 233 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

15
nexgb/xgbgen/bufcount.go
View File

@ -1,15 +0,0 @@
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
}

4
nexgb/xgbgen/context.go
View File

@ -9,7 +9,7 @@ import (
type Context struct {
protocol *Protocol
out *bytes.Buffer
out *bytes.Buffer
}
func newContext() *Context {
@ -20,7 +20,7 @@ func newContext() *Context {
// Putln calls put and adds a new line to the end of 'format'.
func (c *Context) Putln(format string, v ...interface{}) {
c.Put(format + "\n", v...)
c.Put(format+"\n", v...)
}
// Put is a short alias to write to 'out'.

11
nexgb/xgbgen/expression.go
View File

@ -14,7 +14,7 @@ type Expression interface {
}
type BinaryOp struct {
Op string
Op string
Expr1 Expression
Expr2 Expression
}
@ -23,7 +23,7 @@ func newBinaryOp(op string, expr1, expr2 Expression) Expression {
switch {
case expr1 != nil && expr2 != nil:
return &BinaryOp{
Op: op,
Op: op,
Expr1: expr1,
Expr2: expr2,
}
@ -79,7 +79,7 @@ func (e *BinaryOp) Initialize(p *Protocol) {
}
type UnaryOp struct {
Op string
Op string
Expr Expression
}
@ -159,7 +159,7 @@ func (e *Value) String() string {
return e.Reduce("", "")
}
func (e *Value) Initialize(p *Protocol) { }
func (e *Value) Initialize(p *Protocol) {}
type Bit struct {
b uint
@ -181,7 +181,7 @@ func (e *Bit) String() string {
return e.Reduce("", "")
}
func (e *Bit) Initialize(p *Protocol) { }
func (e *Bit) Initialize(p *Protocol) {}
type FieldRef struct {
Name string
@ -273,4 +273,3 @@ func (e *SumOf) String() string {
func (e *SumOf) Initialize(p *Protocol) {
e.Name = SrcName(e.Name)
}

19
nexgb/xgbgen/field.go
View File

@ -31,7 +31,7 @@ func (p *PadField) Size() Size {
type SingleField struct {
srcName string
xmlName string
Type Type
Type Type
}
func (f *SingleField) Initialize(p *Protocol) {
@ -52,9 +52,9 @@ func (f *SingleField) Size() Size {
}
type ListField struct {
srcName string
xmlName string
Type Type
srcName string
xmlName string
Type Type
LengthExpr Expression
}
@ -85,8 +85,8 @@ type LocalField struct {
type ExprField struct {
srcName string
xmlName string
Type Type
Expr Expression
Type Type
Expr Expression
}
func (f *ExprField) SrcName() string {
@ -132,8 +132,8 @@ func (f *ValueField) Initialize(p *Protocol) {
}
type SwitchField struct {
Name string
Expr Expression
Name string
Expr Expression
Bitcases []*Bitcase
}
@ -165,6 +165,5 @@ func (f *SwitchField) Initialize(p *Protocol) {
type Bitcase struct {
Fields []Field
Expr Expression
Expr Expression
}

57
nexgb/xgbgen/go.go
View File

@ -16,37 +16,37 @@ var xgbGenResourceIdName = "Id"
// XML protocol description will produce an invalid Go program.
// The types on the left *never* show themselves in the source.
var BaseTypeMap = map[string]string{
"CARD8": "byte",
"CARD8": "byte",
"CARD16": "uint16",
"CARD32": "uint32",
"INT8": "int8",
"INT16": "int16",
"INT32": "int32",
"BYTE": "byte",
"BOOL": "bool",
"float": "float64",
"INT8": "int8",
"INT16": "int16",
"INT32": "int32",
"BYTE": "byte",
"BOOL": "bool",
"float": "float64",
"double": "float64",
"char": "byte",
"void": "byte",
"Id": "Id",
"char": "byte",
"void": "byte",
"Id": "Id",
}
// BaseTypeSizes should have precisely the same keys as in BaseTypeMap,
// and the values should correspond to the size of the type in bytes.
var BaseTypeSizes = map[string]uint{
"CARD8": 1,
"CARD8": 1,
"CARD16": 2,
"CARD32": 4,
"INT8": 1,
"INT16": 2,
"INT32": 4,
"BYTE": 1,
"BOOL": 1,
"float": 4,
"INT8": 1,
"INT16": 2,
"INT32": 4,
"BYTE": 1,
"BOOL": 1,
"float": 4,
"double": 8,
"char": 1,
"void": 1,
"Id": 4,
"char": 1,
"void": 1,
"Id": 4,
}
// TypeMap is a map from types in the XML to type names that is used
@ -54,13 +54,13 @@ var BaseTypeSizes = map[string]uint{
// type is replaced with the value type.
var TypeMap = map[string]string{
"VISUALTYPE": "VisualInfo",
"DEPTH": "DepthInfo",
"SCREEN": "ScreenInfo",
"Setup": "SetupInfo",
"DEPTH": "DepthInfo",
"SCREEN": "ScreenInfo",
"Setup": "SetupInfo",
}
// NameMap is the same as TypeMap, but for names.
var NameMap = map[string]string{ }
var NameMap = map[string]string{}
// Reading, writing and defining...
@ -151,8 +151,8 @@ func (s *Struct) ReadList(c *Context) {
c.Putln("consumed := 0")
c.Putln("consumed = 0 + consumed // no-op") // dirty hack for a no-op
c.Putln("for i := 0; i < length; i++ {")
c.Putln("v[i], consumed = New%s(buf[b:])", s.SrcName())
c.Putln("b += consumed")
c.Putln("v[i], consumed = New%s(buf[b:])", s.SrcName())
c.Putln("b += consumed")
c.Putln("}")
c.Putln("return v, pad(b)")
@ -347,14 +347,14 @@ func (f *ListField) Read(c *Context) {
length := f.LengthExpr.Reduce("v.", "")
c.Putln("v.%s = make([]Id, %s)", f.SrcName(), length)
c.Putln("for i := 0; i < %s; i++ {", length)
ReadSimpleSingleField(c, fmt.Sprintf("v.%s[i]", f.SrcName()), t)
ReadSimpleSingleField(c, fmt.Sprintf("v.%s[i]", f.SrcName()), t)
c.Putln("}")
c.Putln("")
case *Base:
length := f.LengthExpr.Reduce("v.", "")
c.Putln("v.%s = make([]%s, %s)", f.SrcName(), t.SrcName(), length)
c.Putln("for i := 0; i < %s; i++ {", length)
ReadSimpleSingleField(c, fmt.Sprintf("v.%s[i]", f.SrcName()), t)
ReadSimpleSingleField(c, fmt.Sprintf("v.%s[i]", f.SrcName()), t)
c.Putln("}")
c.Putln("")
case *Struct:
@ -408,4 +408,3 @@ func (f *SwitchField) Define(c *Context) {
func (f *SwitchField) Read(c *Context) {
c.Putln("// reading switch field: %s (%s)", f.Name, f.Expr)
}

1
nexgb/xgbgen/main.go
View File

@ -62,4 +62,3 @@ func main() {
}
}
}

50
nexgb/xgbgen/morph.go
View File

@ -1,50 +0,0 @@
// Morph cascades down all of the XML and calls each type's corresponding
// Morph function with itself as an argument (the context).
func (x *XML) Morph(c *Context) {
// Start the header...
c.Putln("package xgb")
c.Putln("/*")
c.Putln("\tX protocol API for '%s.xml'.", c.xml.Header)
c.Putln("\tThis file is automatically generated. Edit at your own peril!")
c.Putln("\tGenerated on %s",
time.Now().Format("Jan 2, 2006 at 3:04:05pm MST"))
c.Putln("*/")
c.Putln("")
x.Imports.Morph(c)
c.Putln("")
x.Enums.Morph(c)
c.Putln("")
x.Xids.Morph(c)
c.Putln("")
x.XidUnions.Morph(c)
c.Putln("")
x.TypeDefs.Morph(c)
c.Putln("")
x.Structs.Morph(c)
c.Putln("")
x.Unions.Morph(c)
c.Putln("")
x.Requests.Morph(c)
c.Putln("")
x.Errors.Morph(c)
c.Putln("")
x.ErrorCopies.Morph(c)
c.Putln("")
x.Events.Morph(c)
c.Putln("")
x.EventCopies.Morph(c)
c.Putln("")
}

17
nexgb/xgbgen/representation.go
View File

@ -1,14 +1,14 @@
package main
type Protocol struct {
Name string
ExtXName string
ExtName string
Name string
ExtXName string
ExtName string
MajorVersion string
MinorVersion string
Imports []*Protocol
Types []Type
Imports []*Protocol
Types []Type
Requests []*Request
}
@ -28,10 +28,10 @@ func (p *Protocol) Initialize() {
type Request struct {
srcName string
xmlName string
Opcode int
Opcode int
Combine bool
Fields []Field
Reply *Reply
Fields []Field
Reply *Reply
}
func (r *Request) Initialize(p *Protocol) {
@ -53,4 +53,3 @@ func (r *Reply) Initialize(p *Protocol) {
field.Initialize(p)
}
}

1
nexgb/xgbgen/size.go
View File

@ -19,4 +19,3 @@ func (s1 Size) Add(s2 Size) Size {
func (s1 Size) Multiply(s2 Size) Size {
return Size{newBinaryOp("*", s1, s2)}
}

75
nexgb/xgbgen/translation.go
View File

@ -1,4 +1,5 @@
package main
/*
translation.go provides a 'Translate' method on every XML type that converts
the XML type into our "better" representation.
@ -19,14 +20,14 @@ import (
func (xml *XML) Translate() *Protocol {
protocol := &Protocol{
Name: xml.Header,
ExtXName: xml.ExtensionXName,
ExtName: xml.ExtensionName,
Name: xml.Header,
ExtXName: xml.ExtensionXName,
ExtName: xml.ExtensionName,
MajorVersion: xml.MajorVersion,
MinorVersion: xml.MinorVersion,
Imports: make([]*Protocol, 0),
Types: make([]Type, 0),
Imports: make([]*Protocol, 0),
Types: make([]Type, 0),
Requests: make([]*Request, len(xml.Requests)),
}
@ -40,7 +41,7 @@ func (xml *XML) Translate() *Protocol {
newBaseType := &Base{
srcName: srcName,
xmlName: xmlName,
size: newFixedSize(BaseTypeSizes[xmlName]),
size: newFixedSize(BaseTypeSizes[xmlName]),
}
protocol.Types = append(protocol.Types, newBaseType)
}
@ -105,12 +106,12 @@ func (xml *XML) Translate() *Protocol {
func (x *XMLEnum) Translate() *Enum {
enum := &Enum{
xmlName: x.Name,
Items: make([]*EnumItem, len(x.Items)),
Items: make([]*EnumItem, len(x.Items)),
}
for i, item := range x.Items {
enum.Items[i] = &EnumItem{
xmlName: item.Name,
Expr: item.Expr.Translate(),
Expr: item.Expr.Translate(),
}
}
return enum
@ -125,16 +126,16 @@ func (x *XMLXid) Translate() *Resource {
func (x *XMLTypeDef) Translate() *TypeDef {
return &TypeDef{
xmlName: x.New,
Old: newTranslation(x.Old),
Old: newTranslation(x.Old),
}
}
func (x *XMLEvent) Translate() *Event {
ev := &Event{
xmlName: x.Name,
Number: x.Number,
xmlName: x.Name,
Number: x.Number,
NoSequence: x.NoSequence,
Fields: make([]Field, len(x.Fields)),
Fields: make([]Field, len(x.Fields)),
}
for i, field := range x.Fields {
ev.Fields[i] = field.Translate()
@ -145,16 +146,16 @@ func (x *XMLEvent) Translate() *Event {
func (x *XMLEventCopy) Translate() *EventCopy {
return &EventCopy{
xmlName: x.Name,
Number: x.Number,
Old: newTranslation(x.Ref),
Number: x.Number,
Old: newTranslation(x.Ref),
}
}
func (x *XMLError) Translate() *Error {
err := &Error{
xmlName: x.Name,
Number: x.Number,
Fields: make([]Field, len(x.Fields)),
Number: x.Number,
Fields: make([]Field, len(x.Fields)),
}
for i, field := range x.Fields {
err.Fields[i] = field.Translate()
@ -165,15 +166,15 @@ func (x *XMLError) Translate() *Error {
func (x *XMLErrorCopy) Translate() *ErrorCopy {
return &ErrorCopy{
xmlName: x.Name,
Number: x.Number,
Old: newTranslation(x.Ref),
Number: x.Number,
Old: newTranslation(x.Ref),
}
}
func (x *XMLStruct) Translate() *Struct {
s := &Struct{
xmlName: x.Name,
Fields: make([]Field, len(x.Fields)),
Fields: make([]Field, len(x.Fields)),
}
for i, field := range x.Fields {
s.Fields[i] = field.Translate()
@ -184,7 +185,7 @@ func (x *XMLStruct) Translate() *Struct {
func (x *XMLUnion) Translate() *Union {
u := &Union{
xmlName: x.Name,
Fields: make([]Field, len(x.Fields)),
Fields: make([]Field, len(x.Fields)),
}
for i, field := range x.Fields {
u.Fields[i] = field.Translate()
@ -195,10 +196,10 @@ func (x *XMLUnion) Translate() *Union {
func (x *XMLRequest) Translate() *Request {
r := &Request{
xmlName: x.Name,
Opcode: x.Opcode,
Opcode: x.Opcode,
Combine: x.Combine,
Fields: make([]Field, len(x.Fields)),
Reply: x.Reply.Translate(),
Fields: make([]Field, len(x.Fields)),
Reply: x.Reply.Translate(),
}
for i, field := range x.Fields {
r.Fields[i] = field.Translate()
@ -211,7 +212,7 @@ func (x *XMLRequest) Translate() *Request {
// (i.e., a parameter in the caller but does not get send over the wire.)
stringLenLocal := &LocalField{&SingleField{
xmlName: "string_len",
Type: newTranslation("CARD16"),
Type: newTranslation("CARD16"),
}}
r.Fields = append(r.Fields, stringLenLocal)
@ -243,7 +244,7 @@ func (x *XMLExpression) Translate() Expression {
log.Panicf("'op' found %d expressions; expected 2.", len(x.Exprs))
}
return &BinaryOp{
Op: x.Op,
Op: x.Op,
Expr1: x.Exprs[0].Translate(),
Expr2: x.Exprs[1].Translate(),
}
@ -252,7 +253,7 @@ func (x *XMLExpression) Translate() Expression {
log.Panicf("'unop' found %d expressions; expected 1.", len(x.Exprs))
}
return &UnaryOp{
Op: x.Op,
Op: x.Op,
Expr: x.Exprs[0].Translate(),
}
case "popcount":
@ -279,7 +280,7 @@ func (x *XMLExpression) Translate() Expression {
x.Data)
}
if bit < 0 || bit > 31 {
log.Panicf("A 'bit' literal must be in the range [0, 31], but " +
log.Panicf("A 'bit' literal must be in the range [0, 31], but "+
" is %d", bit)
}
return &Bit{
@ -300,7 +301,7 @@ func (x *XMLExpression) Translate() Expression {
}
}
log.Panicf("Unrecognized tag '%s' in expression context. Expected one of " +
log.Panicf("Unrecognized tag '%s' in expression context. Expected one of "+
"op, fieldref, value, bit, enumref, unop, sumof or popcount.",
x.XMLName.Local)
panic("unreachable")
@ -315,24 +316,24 @@ func (x *XMLField) Translate() Field {
case "field":
return &SingleField{
xmlName: x.Name,
Type: newTranslation(x.Type),
Type: newTranslation(x.Type),
}
case "list":
return &ListField{
xmlName: x.Name,
Type: newTranslation(x.Type),
xmlName: x.Name,
Type: newTranslation(x.Type),
LengthExpr: x.Expr.Translate(),
}
case "localfield":
return &LocalField{&SingleField{
xmlName: x.Name,
Type: newTranslation(x.Type),
Type: newTranslation(x.Type),
}}
case "exprfield":
return &ExprField{
xmlName: x.Name,
Type: newTranslation(x.Type),
Expr: x.Expr.Translate(),
Type: newTranslation(x.Type),
Expr: x.Expr.Translate(),
}
case "valueparam":
return &ValueField{
@ -342,8 +343,8 @@ func (x *XMLField) Translate() Field {
}
case "switch":
swtch := &SwitchField{
Name: x.Name,
Expr: x.Expr.Translate(),
Name: x.Name,
Expr: x.Expr.Translate(),
Bitcases: make([]*Bitcase, len(x.Bitcases)),
}
for i, bitcase := range x.Bitcases {
@ -358,7 +359,7 @@ func (x *XMLField) Translate() Field {
func (x *XMLBitcase) Translate() *Bitcase {
b := &Bitcase{
Expr: x.Expr().Translate(),
Expr: x.Expr().Translate(),
Fields: make([]Field, len(x.Fields)),
}
for i, field := range x.Fields {

32
nexgb/xgbgen/type.go
View File

@ -77,7 +77,7 @@ func (t *Translation) Initialize(p *Protocol) {
type Base struct {
srcName string
xmlName string
size Size
size Size
}
func (b *Base) SrcName() string {
@ -99,13 +99,13 @@ func (b *Base) Initialize(p *Protocol) {
type Enum struct {
srcName string
xmlName string
Items []*EnumItem
Items []*EnumItem
}
type EnumItem struct {
srcName string
xmlName string
Expr Expression
Expr Expression
}
func (enum *Enum) SrcName() string {
@ -154,7 +154,7 @@ func (r *Resource) Initialize(p *Protocol) {
type TypeDef struct {
srcName string
xmlName string
Old Type
Old Type
}
func (t *TypeDef) SrcName() string {
@ -175,11 +175,11 @@ func (t *TypeDef) Initialize(p *Protocol) {
}
type Event struct {
srcName string
xmlName string
Number int
srcName string
xmlName string
Number int
NoSequence bool
Fields []Field
Fields []Field
}
func (e *Event) SrcName() string {
@ -208,8 +208,8 @@ func (e *Event) EvType() string {
type EventCopy struct {
srcName string
xmlName string
Old Type
Number int
Old Type
Number int
}
func (e *EventCopy) SrcName() string {
@ -239,8 +239,8 @@ func (e *EventCopy) EvType() string {
type Error struct {
srcName string
xmlName string
Number int
Fields []Field
Number int
Fields []Field
}
func (e *Error) SrcName() string {
@ -270,8 +270,8 @@ func (e *Error) ErrType() string {
type ErrorCopy struct {
srcName string
xmlName string
Old Type
Number int
Old Type
Number int
}
func (e *ErrorCopy) SrcName() string {
@ -305,7 +305,7 @@ func (e *ErrorCopy) ErrType() string {
type Struct struct {
srcName string
xmlName string
Fields []Field
Fields []Field
}
func (s *Struct) SrcName() string {
@ -334,7 +334,7 @@ func (s *Struct) Initialize(p *Protocol) {
type Union struct {
srcName string
xmlName string
Fields []Field
Fields []Field
}
func (u *Union) SrcName() string {

81
nexgb/xgbgen/xml.go
View File

@ -8,29 +8,29 @@ import (
type XML struct {
// Root 'xcb' element properties.
XMLName xml.Name `xml:"xcb"`
Header string `xml:"header,attr"`
ExtensionXName string `xml:"extension-xname,attr"`
ExtensionName string `xml:"extension-name,attr"`
MajorVersion string `xml:"major-version,attr"`
MinorVersion string `xml:"minor-version,attr"`
XMLName xml.Name `xml:"xcb"`
Header string `xml:"header,attr"`
ExtensionXName string `xml:"extension-xname,attr"`
ExtensionName string `xml:"extension-name,attr"`
MajorVersion string `xml:"major-version,attr"`
MinorVersion string `xml:"minor-version,attr"`
// Types for all top-level elements.
// First are the simple ones.
Imports XMLImports `xml:"import"`
Enums XMLEnums `xml:"enum"`
Xids XMLXids `xml:"xidtype"`
XidUnions XMLXids `xml:"xidunion"`
TypeDefs XMLTypeDefs `xml:"typedef"`
Imports XMLImports `xml:"import"`
Enums XMLEnums `xml:"enum"`
Xids XMLXids `xml:"xidtype"`
XidUnions XMLXids `xml:"xidunion"`
TypeDefs XMLTypeDefs `xml:"typedef"`
EventCopies XMLEventCopies `xml:"eventcopy"`
ErrorCopies XMLErrorCopies `xml:"errorcopy"`
// Here are the complex ones, i.e., anything with "structure contents"
Structs XMLStructs `xml:"struct"`
Unions XMLUnions `xml:"union"`
Structs XMLStructs `xml:"struct"`
Unions XMLUnions `xml:"union"`
Requests XMLRequests `xml:"request"`
Events XMLEvents `xml:"event"`
Errors XMLErrors `xml:"error"`
Events XMLEvents `xml:"event"`
Errors XMLErrors `xml:"error"`
}
type XMLImports []*XMLImport
@ -39,14 +39,14 @@ func (imports XMLImports) Eval() {
for _, imp := range imports {
xmlBytes, err := ioutil.ReadFile(*protoPath + "/" + imp.Name + ".xml")
if err != nil {
log.Fatalf("Could not read X protocol description for import " +
log.Fatalf("Could not read X protocol description for import "+
"'%s' because: %s", imp.Name, err)
}
imp.xml = &XML{}
err = xml.Unmarshal(xmlBytes, imp.xml)
if err != nil {
log.Fatal("Could not parse X protocol description for import " +
log.Fatal("Could not parse X protocol description for import "+
"'%s' because: %s", imp.Name, err)
}
@ -57,18 +57,18 @@ func (imports XMLImports) Eval() {
type XMLImport struct {
Name string `xml:",chardata"`
xml *XML `xml:"-"`
xml *XML `xml:"-"`
}
type XMLEnums []XMLEnum
type XMLEnum struct {
Name string `xml:"name,attr"`
Name string `xml:"name,attr"`
Items []*XMLEnumItem `xml:"item"`
}
type XMLEnumItem struct {
Name string `xml:"name,attr"`
Name string `xml:"name,attr"`
Expr *XMLExpression `xml:",any"`
}
@ -76,7 +76,7 @@ type XMLXids []*XMLXid
type XMLXid struct {
XMLName xml.Name
Name string `xml:"name,attr"`
Name string `xml:"name,attr"`
}
type XMLTypeDefs []*XMLTypeDef
@ -89,41 +89,41 @@ type XMLTypeDef struct {
type XMLEventCopies []*XMLEventCopy
type XMLEventCopy struct {
Name string `xml:"name,attr"`
Number int `xml:"number,attr"`
Ref string `xml:"ref,attr"`
Name string `xml:"name,attr"`
Number int `xml:"number,attr"`
Ref string `xml:"ref,attr"`
}
type XMLErrorCopies []*XMLErrorCopy
type XMLErrorCopy struct {
Name string `xml:"name,attr"`
Number int `xml:"number,attr"`
Ref string `xml:"ref,attr"`
Name string `xml:"name,attr"`
Number int `xml:"number,attr"`
Ref string `xml:"ref,attr"`
}
type XMLStructs []*XMLStruct
type XMLStruct struct {
Name string `xml:"name,attr"`
Name string `xml:"name,attr"`
Fields XMLFields `xml:",any"`
}
type XMLUnions []*XMLUnion
type XMLUnion struct {
Name string `xml:"name,attr"`
Name string `xml:"name,attr"`
Fields XMLFields `xml:",any"`
}
type XMLRequests []*XMLRequest
type XMLRequest struct {
Name string `xml:"name,attr"`
Opcode int `xml:"opcode,attr"`
Combine bool `xml:"combine-adjacent,attr"`
Fields XMLFields `xml:",any"`
Reply *XMLReply `xml:"reply"`
Name string `xml:"name,attr"`
Opcode int `xml:"opcode,attr"`
Combine bool `xml:"combine-adjacent,attr"`
Fields XMLFields `xml:",any"`
Reply *XMLReply `xml:"reply"`
}
type XMLReply struct {
@ -133,17 +133,16 @@ type XMLReply struct {
type XMLEvents []*XMLEvent
type XMLEvent struct {
Name string `xml:"name,attr"`
Number int `xml:"number,attr"`
NoSequence bool `xml:"no-sequence-number,true"`
Fields XMLFields `xml:",any"`
Name string `xml:"name,attr"`
Number int `xml:"number,attr"`
NoSequence bool `xml:"no-sequence-number,true"`
Fields XMLFields `xml:",any"`
}
type XMLErrors []*XMLError
type XMLError struct {
Name string `xml:"name,attr"`
Number int `xml:"number,attr"`
Name string `xml:"name,attr"`
Number int `xml:"number,attr"`
Fields XMLFields `xml:",any"`
}

16
nexgb/xgbgen/xml_expression.go
View File

@ -13,14 +13,14 @@ type XMLExpression struct {
Exprs []*XMLExpression `xml:",any"`
Data string `xml:",chardata"`
Op string `xml:"op,attr"`
Ref string `xml:"ref,attr"`
Op string `xml:"op,attr"`
Ref string `xml:"ref,attr"`
}
func newValueExpression(v uint) *XMLExpression {
return &XMLExpression{
XMLName: xml.Name{Local: "value"},
Data: fmt.Sprintf("%d", v),
Data: fmt.Sprintf("%d", v),
}
}
@ -87,22 +87,22 @@ func (e *XMLExpression) Eval() uint {
e.Data)
}
if bit < 0 || bit > 31 {
log.Panicf("A 'bit' literal must be in the range [0, 31], but " +
log.Panicf("A 'bit' literal must be in the range [0, 31], but "+
" is %d", bit)
}
return 1 << uint(bit)
case "fieldref":
log.Panicf("Cannot compute concrete value of 'fieldref' in " +
log.Panicf("Cannot compute concrete value of 'fieldref' in "+
"expression '%s'.", e)
case "enumref":
log.Panicf("Cannot compute concrete value of 'enumref' in " +
log.Panicf("Cannot compute concrete value of 'enumref' in "+
"expression '%s'.", e)
case "sumof":
log.Panicf("Cannot compute concrete value of 'sumof' in " +
log.Panicf("Cannot compute concrete value of 'sumof' in "+
"expression '%s'.", e)
}
log.Panicf("Unrecognized tag '%s' in expression context. Expected one of " +
log.Panicf("Unrecognized tag '%s' in expression context. Expected one of "+
"op, fieldref, value, bit, enumref, unop, sumof or popcount.",
e.XMLName.Local)
panic("unreachable")

17
nexgb/xgbgen/xml_fields.go
View File

@ -1,4 +1,5 @@
package main
/*
A series of fields should be taken as "structure contents", and *not*
just the single 'field' elements. Namely, 'fields' subsumes 'field'
@ -50,8 +51,8 @@ type XMLField struct {
// I don't know which elements these are for. The documentation is vague.
// They also seem to be completely optional.
OptEnum string `xml:"enum,attr"`
OptMask string `xml:"mask,attr"`
OptEnum string `xml:"enum,attr"`
OptMask string `xml:"mask,attr"`
OptAltEnum string `xml:"altenum,attr"`
}
@ -103,14 +104,14 @@ type XMLBitcase struct {
// All the different expressions.
// When it comes time to choose one, use the 'Expr' method.
ExprOp *XMLExpression `xml:"op"`
ExprUnOp *XMLExpression `xml:"unop"`
ExprOp *XMLExpression `xml:"op"`
ExprUnOp *XMLExpression `xml:"unop"`
ExprField *XMLExpression `xml:"fieldref"`
ExprValue *XMLExpression `xml:"value"`
ExprBit *XMLExpression `xml:"bit"`
ExprEnum *XMLExpression `xml:"enumref"`
ExprSum *XMLExpression `xml:"sumof"`
ExprPop *XMLExpression `xml:"popcount"`
ExprBit *XMLExpression `xml:"bit"`
ExprEnum *XMLExpression `xml:"enumref"`
ExprSum *XMLExpression `xml:"sumof"`
ExprPop *XMLExpression `xml:"popcount"`
}
// StringPrefix is for debugging purposes only.