From 3658686aeea7acc61621782c7c1e6dad66517479 Mon Sep 17 00:00:00 2001
From: Andrew Gallant <jamslam@gmail.com>
Date: Sat, 26 Jan 2013 12:51:48 -0500
Subject: 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
--
cgit v1.2.3-70-g09d2