From 3658686aeea7acc61621782c7c1e6dad66517479 Mon Sep 17 00:00:00 2001 From: Andrew Gallant Date: Sat, 26 Jan 2013 12:51:48 -0500 Subject: [PATCH] gofmt --- nexgb/conn.go | 2 +- nexgb/doc.go | 20 ++++++++++---------- nexgb/xgb.go | 24 ++++++++++++------------ nexgb/xgbgen/expression.go | 2 +- nexgb/xgbgen/field.go | 2 +- nexgb/xgbgen/go_struct.go | 4 ++-- nexgb/xgbgen/request_reply.go | 2 +- nexgb/xproto/xproto_test.go | 4 ++-- 8 files changed, 30 insertions(+), 30 deletions(-) diff --git a/nexgb/conn.go b/nexgb/conn.go index bb2f413..7f4cf08 100644 --- a/nexgb/conn.go +++ b/nexgb/conn.go @@ -162,7 +162,7 @@ func (c *Conn) dial(display string) error { protocol = "tcp" } c.conn, err = net.Dial(protocol, - c.host+":"+strconv.Itoa(6000+c.DisplayNumber)) + c.host+":"+strconv.Itoa(6000+c.DisplayNumber)) } else { c.conn, err = net.Dial("unix", "/tmp/.X11-unix/X"+c.display) } diff --git a/nexgb/doc.go b/nexgb/doc.go index a5bb6fe..64540e9 100644 --- a/nexgb/doc.go +++ b/nexgb/doc.go @@ -15,8 +15,8 @@ https://github.com/BurntSushi/xgbutil Example This is an extremely terse example that demonstrates how to connect to X, -create a window, listen to StructureNotify events and Key{Press,Release} -events, map the window, and print out all events received. An example with +create a window, listen to StructureNotify events and Key{Press,Release} +events, map the window, and print out all events received. An example with accompanying documentation can be found in examples/create-window. package main @@ -111,11 +111,11 @@ evidence of this claim, please see the benchmarks in xproto/xproto_test.go. Tests -xproto/xproto_test.go contains a number of contrived tests that stress -particular corners of XGB that I presume could be problem areas. Namely: -requests with no replies, requests with replies, checked errors, unchecked -errors, sequence number wrapping, cookie buffer flushing (i.e., forcing a round -trip every N requests made that don't have a reply), getting/setting properties +xproto/xproto_test.go contains a number of contrived tests that stress +particular corners of XGB that I presume could be problem areas. Namely: +requests with no replies, requests with replies, checked errors, unchecked +errors, sequence number wrapping, cookie buffer flushing (i.e., forcing a round +trip every N requests made that don't have a reply), getting/setting properties and creating a window and listening to StructureNotify events. Code Generator @@ -131,15 +131,15 @@ What works I am reasonably confident that the core X protocol is in full working form. I've also tested the Xinerama and RandR extensions sparingly. Many of the other -existing extensions have Go source generated (and are compilable) and are -included in this package, but I am currently unsure of their status. They +existing extensions have Go source generated (and are compilable) and are +included in this package, but I am currently unsure of their status. They *should* work. What does not work XKB is the only extension that intentionally does not work, although I suspect that GLX also does not work (however, there is Go source code for GLX that -compiles, unlike XKB). I don't currently have any intention of getting XKB +compiles, unlike XKB). I don't currently have any intention of getting XKB working, due to its complexity and my current mental incapacity to test it. */ diff --git a/nexgb/xgb.go b/nexgb/xgb.go index b123ba1..3078c17 100644 --- a/nexgb/xgb.go +++ b/nexgb/xgb.go @@ -29,7 +29,7 @@ const ( xidBuffer = 5 // seqBuffer represents the queue size of the sequence number channel. - // I don't think this value matters much, since sequence number generation + // I don't think this value matters much, since sequence number generation // is not that expensive. seqBuffer = 5 @@ -132,7 +132,7 @@ var NewEventFuncs = make(map[int]NewEventFun) // NewExtEventFuncs is a temporary map that stores event constructor functions // for each extension. When an extension is initialized, each event for that -// extension is added to the 'NewEventFuncs' map. It should not be used. It is +// extension is added to the 'NewEventFuncs' map. It should not be used. It is // exported for use in the extension sub-packages. var NewExtEventFuncs = make(map[string]map[int]NewEventFun) @@ -195,11 +195,11 @@ func (conn *Conn) generateXIds() { defer close(conn.xidChan) // This requires some explanation. From the horse's mouth: - // "The resource-id-mask contains a single contiguous set of bits (at least - // 18). The client allocates resource IDs for types WINDOW, PIXMAP, - // CURSOR, FONT, GCONTEXT, and COLORMAP by choosing a value with only some - // subset of these bits set and ORing it with resource-id-base. Only values - // constructed in this way can be used to name newly created resources over + // "The resource-id-mask contains a single contiguous set of bits (at least + // 18). The client allocates resource IDs for types WINDOW, PIXMAP, + // CURSOR, FONT, GCONTEXT, and COLORMAP by choosing a value with only some + // subset of these bits set and ORing it with resource-id-base. Only values + // constructed in this way can be used to name newly created resources over // this connection." // So for example (using 8 bit integers), the mask might look like: // 00111000 @@ -240,7 +240,7 @@ func (c *Conn) newSequenceId() uint16 { // own goroutine. // A sequence id is generated for *every* request. It's the identifier used // to match up replies with requests. -// Since sequence ids can only be 16 bit integers we start over at zero when it +// Since sequence ids can only be 16 bit integers we start over at zero when it // comes time to wrap. // N.B. As long as the cookie buffer is less than 2^16, there are no limitations // on the number (or kind) of requests made in sequence. @@ -266,7 +266,7 @@ type request struct { cookie *Cookie } -// NewRequest takes the bytes and a cookie of a particular request, constructs +// NewRequest takes the bytes and a cookie of a particular request, constructs // a request type, and sends it over the Conn.reqChan channel. // Note that the sequence number is added to the cookie after it is sent // over the request channel, but before it is sent to X. @@ -500,9 +500,9 @@ func (c *Conn) WaitForEvent() (Event, Error) { return processEventOrError(<-c.eventChan) } -// PollForEvent returns the next event from the server if one is available in -// the internal queue without blocking. Note that unlike WaitForEvent, both -// Event and Error could be nil. Indeed, they are both nil when the event queue +// PollForEvent returns the next event from the server if one is available in +// the internal queue without blocking. Note that unlike WaitForEvent, both +// Event and Error could be nil. Indeed, they are both nil when the event queue // is empty. func (c *Conn) PollForEvent() (Event, Error) { select { diff --git a/nexgb/xgbgen/expression.go b/nexgb/xgbgen/expression.go index 2047b5f..f88232c 100644 --- a/nexgb/xgbgen/expression.go +++ b/nexgb/xgbgen/expression.go @@ -322,7 +322,7 @@ func (e *FieldRef) Initialize(p *Protocol) { } // EnumRef represents a reference to some enumeration field. -// EnumKind is the "group" an EnumItem is the name of the specific enumeration +// EnumKind is the "group" an EnumItem is the name of the specific enumeration // value inside that group. type EnumRef struct { EnumKind Type diff --git a/nexgb/xgbgen/field.go b/nexgb/xgbgen/field.go index 78475f8..16760d4 100644 --- a/nexgb/xgbgen/field.go +++ b/nexgb/xgbgen/field.go @@ -138,7 +138,7 @@ func (f *ListField) Length() Size { // Size computes the *size* of a list (in bytes). // It it typically a simple matter of multiplying the length of the list by // the size of the type of the list. -// But if it's a list of struct where the struct has a list field, we use a +// But if it's a list of struct where the struct has a list field, we use a // special function written in go_struct.go to compute the size (since the // size in this case can only be computed recursively). func (f *ListField) Size() Size { diff --git a/nexgb/xgbgen/go_struct.go b/nexgb/xgbgen/go_struct.go index cb765a0..984a336 100644 --- a/nexgb/xgbgen/go_struct.go +++ b/nexgb/xgbgen/go_struct.go @@ -27,7 +27,7 @@ func (s *Struct) Define(c *Context) { } } -// Read for a struct creates a function 'ReadStructName' that takes a source +// Read for a struct creates a function 'ReadStructName' that takes a source // byte slice (i.e., the buffer) and a destination struct, and returns // the number of bytes read off the buffer. // 'ReadStructName' should only be used to read raw reply data from the wire. @@ -49,7 +49,7 @@ func (s *Struct) Read(c *Context) { } // ReadList for a struct creates a function 'ReadStructNameList' that takes -// a source (i.e., the buffer) byte slice, and a destination slice and returns +// a source (i.e., the buffer) byte slice, and a destination slice and returns // the number of bytes read from the byte slice. func (s *Struct) ReadList(c *Context) { c.Putln("// %sReadList reads a byte slice into a list of %s values.", diff --git a/nexgb/xgbgen/request_reply.go b/nexgb/xgbgen/request_reply.go index 637266b..b8afe48 100644 --- a/nexgb/xgbgen/request_reply.go +++ b/nexgb/xgbgen/request_reply.go @@ -88,7 +88,7 @@ func (r *Request) Size(c *Context) Size { size := newFixedSize(0) // If this is a core protocol request, we squeeze in an extra byte of - // data (from the fields below) between the opcode and the size of the + // 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). diff --git a/nexgb/xproto/xproto_test.go b/nexgb/xproto/xproto_test.go index 8d0ca88..44d3285 100644 --- a/nexgb/xproto/xproto_test.go +++ b/nexgb/xproto/xproto_test.go @@ -88,8 +88,8 @@ func TestCookieBuffer(t *testing.T) { TestProperty(t) } -// TestSequenceWrap issues (2^16) + n requests w/ replies to guarantee that the -// sequence number (which is a 16 bit integer) will wrap. It then issues one +// TestSequenceWrap issues (2^16) + n requests w/ replies to guarantee that the +// sequence number (which is a 16 bit integer) will wrap. It then issues one // final request to ensure things still work properly. func TestSequenceWrap(t *testing.T) { n := (1 << 16) + 10