parsing and printing to new syntax.
Use -oldparser to parse the old syntax,
use -oldprinter to print the old syntax.
2) Change default gofmt formatting settings
to use tabs for indentation only and to use
spaces for alignment. This will make the code
alignment insensitive to an editor's tabwidth.
Use -spaces=false to use tabs for alignment.
3) Manually changed src/exp/parser/parser_test.go
so that it doesn't try to parse the parser's
source files using the old syntax (they have
new syntax now).
4) gofmt -w src misc test/bench
3rd set of files.
R=rsc
CC=golang-dev
https://golang.org/cl/180048
package ast
import (
- "go/token";
- "unicode";
- "utf8";
+ "go/token"
+ "unicode"
+ "utf8"
)
// All node types implement the Node interface.
type Node interface {
// Pos returns the (beginning) position of the node.
- Pos() token.Position;
+ Pos() token.Position
}
// All expression nodes implement the Expr interface.
type Expr interface {
- Node;
- exprNode();
+ Node
+ exprNode()
}
// All statement nodes implement the Stmt interface.
type Stmt interface {
- Node;
- stmtNode();
+ Node
+ stmtNode()
}
// All declaration nodes implement the Decl interface.
type Decl interface {
- Node;
- declNode();
+ Node
+ declNode()
}
// A Comment node represents a single //-style or /*-style comment.
type Comment struct {
- token.Position; // beginning position of the comment
- Text []byte; // comment text (excluding '\n' for //-style comments)
+ token.Position // beginning position of the comment
+ Text []byte // comment text (excluding '\n' for //-style comments)
}
// with no other tokens and no empty lines between.
//
type CommentGroup struct {
- List []*Comment;
- Next *CommentGroup; // next comment group in source order
+ List []*Comment
+ Next *CommentGroup // next comment group in source order
}
// in a signature.
//
type Field struct {
- Doc *CommentGroup; // associated documentation; or nil
- Names []*Ident; // field/method/parameter names; or nil if anonymous field
- Type Expr; // field/method/parameter type
- Tag []*BasicLit; // field tag; or nil
- Comment *CommentGroup; // line comments; or nil
+ Doc *CommentGroup // associated documentation; or nil
+ Names []*Ident // field/method/parameter names; or nil if anonymous field
+ Type Expr // field/method/parameter type
+ Tag []*BasicLit // field tag; or nil
+ Comment *CommentGroup // line comments; or nil
}
if len(f.Names) > 0 {
return f.Names[0].Pos()
}
- return f.Type.Pos();
+ return f.Type.Pos()
}
// syntax errors for which no correct expression nodes can be
// created.
//
- BadExpr struct {
- token.Position; // beginning position of bad expression
- };
+ BadExpr struct {
+ token.Position // beginning position of bad expression
+ }
// An Ident node represents an identifier.
- Ident struct {
- token.Position; // identifier position
- Value string; // identifier string (e.g. foobar)
- };
+ Ident struct {
+ token.Position // identifier position
+ Value string // identifier string (e.g. foobar)
+ }
// An Ellipsis node stands for the "..." type in a
// parameter list or the "..." length in an array type.
//
- Ellipsis struct {
- token.Position; // position of "..."
- };
+ Ellipsis struct {
+ token.Position // position of "..."
+ }
// A BasicLit node represents a literal of basic type.
- BasicLit struct {
- token.Position; // literal position
- Kind token.Token; // token.INT, token.FLOAT, token.CHAR, or token.STRING
- Value []byte; // literal string; e.g. 42, 0x7f, 3.14, 1e-9, 'a', '\x7f', "foo" or `\m\n\o`
- };
+ BasicLit struct {
+ token.Position // literal position
+ Kind token.Token // token.INT, token.FLOAT, token.CHAR, or token.STRING
+ Value []byte // literal string; e.g. 42, 0x7f, 3.14, 1e-9, 'a', '\x7f', "foo" or `\m\n\o`
+ }
// A StringList node represents a sequence of adjacent string literals.
// A single string literal (common case) is represented by a BasicLit
// node; StringList nodes are used only if there are two or more string
// literals in a sequence.
//
- StringList struct {
- Strings []*BasicLit; // list of strings, len(Strings) > 1
- };
+ StringList struct {
+ Strings []*BasicLit // list of strings, len(Strings) > 1
+ }
// A FuncLit node represents a function literal.
- FuncLit struct {
- Type *FuncType; // function type
- Body *BlockStmt; // function body
- };
+ FuncLit struct {
+ Type *FuncType // function type
+ Body *BlockStmt // function body
+ }
// A CompositeLit node represents a composite literal.
//
- CompositeLit struct {
- Type Expr; // literal type
- Lbrace token.Position; // position of "{"
- Elts []Expr; // list of composite elements
- Rbrace token.Position; // position of "}"
- };
+ CompositeLit struct {
+ Type Expr // literal type
+ Lbrace token.Position // position of "{"
+ Elts []Expr // list of composite elements
+ Rbrace token.Position // position of "}"
+ }
// A ParenExpr node represents a parenthesized expression.
- ParenExpr struct {
- token.Position; // position of "("
- X Expr; // parenthesized expression
- Rparen token.Position; // position of ")"
- };
+ ParenExpr struct {
+ token.Position // position of "("
+ X Expr // parenthesized expression
+ Rparen token.Position // position of ")"
+ }
// A SelectorExpr node represents an expression followed by a selector.
- SelectorExpr struct {
- X Expr; // expression
- Sel *Ident; // field selector
- };
+ SelectorExpr struct {
+ X Expr // expression
+ Sel *Ident // field selector
+ }
// An IndexExpr node represents an expression followed by an index.
- IndexExpr struct {
- X Expr; // expression
- Index Expr; // index expression
- };
+ IndexExpr struct {
+ X Expr // expression
+ Index Expr // index expression
+ }
// An SliceExpr node represents an expression followed by slice indices.
- SliceExpr struct {
- X Expr; // expression
- Index Expr; // beginning of slice range
- End Expr; // end of slice range; or nil
- };
+ SliceExpr struct {
+ X Expr // expression
+ Index Expr // beginning of slice range
+ End Expr // end of slice range; or nil
+ }
// A TypeAssertExpr node represents an expression followed by a
// type assertion.
//
- TypeAssertExpr struct {
- X Expr; // expression
- Type Expr; // asserted type; nil means type switch X.(type)
- };
+ TypeAssertExpr struct {
+ X Expr // expression
+ Type Expr // asserted type; nil means type switch X.(type)
+ }
// A CallExpr node represents an expression followed by an argument list.
- CallExpr struct {
- Fun Expr; // function expression
- Lparen token.Position; // position of "("
- Args []Expr; // function arguments
- Rparen token.Position; // positions of ")"
- };
+ CallExpr struct {
+ Fun Expr // function expression
+ Lparen token.Position // position of "("
+ Args []Expr // function arguments
+ Rparen token.Position // positions of ")"
+ }
// A StarExpr node represents an expression of the form "*" Expression.
// Semantically it could be a unary "*" expression, or a pointer type.
- StarExpr struct {
- token.Position; // position of "*"
- X Expr; // operand
- };
+ StarExpr struct {
+ token.Position // position of "*"
+ X Expr // operand
+ }
// A UnaryExpr node represents a unary expression.
// Unary "*" expressions are represented via StarExpr nodes.
//
- UnaryExpr struct {
- token.Position; // position of Op
- Op token.Token; // operator
- X Expr; // operand
- };
+ UnaryExpr struct {
+ token.Position // position of Op
+ Op token.Token // operator
+ X Expr // operand
+ }
// A BinaryExpr node represents a binary expression.
//
- BinaryExpr struct {
- X Expr; // left operand
- OpPos token.Position; // position of Op
- Op token.Token; // operator
- Y Expr; // right operand
- };
+ BinaryExpr struct {
+ X Expr // left operand
+ OpPos token.Position // position of Op
+ Op token.Token // operator
+ Y Expr // right operand
+ }
// A KeyValueExpr node represents (key : value) pairs
// in composite literals.
//
- KeyValueExpr struct {
- Key Expr;
- Colon token.Position; // position of ":"
- Value Expr;
- };
+ KeyValueExpr struct {
+ Key Expr
+ Colon token.Position // position of ":"
+ Value Expr
+ }
)
type ChanDir int
const (
- SEND ChanDir = 1 << iota;
- RECV;
+ SEND ChanDir = 1 << iota
+ RECV
)
//
type (
// An ArrayType node represents an array or slice type.
- ArrayType struct {
- token.Position; // position of "["
- Len Expr; // Ellipsis node for [...]T array types, nil for slice types
- Elt Expr; // element type
- };
+ ArrayType struct {
+ token.Position // position of "["
+ Len Expr // Ellipsis node for [...]T array types, nil for slice types
+ Elt Expr // element type
+ }
// A StructType node represents a struct type.
- StructType struct {
- token.Position; // position of "struct" keyword
- Lbrace token.Position; // position of "{"
- Fields []*Field; // list of field declarations
- Rbrace token.Position; // position of "}"
- Incomplete bool; // true if (source) fields are missing in the Fields list
- };
+ StructType struct {
+ token.Position // position of "struct" keyword
+ Lbrace token.Position // position of "{"
+ Fields []*Field // list of field declarations
+ Rbrace token.Position // position of "}"
+ Incomplete bool // true if (source) fields are missing in the Fields list
+ }
// Pointer types are represented via StarExpr nodes.
// A FuncType node represents a function type.
- FuncType struct {
- token.Position; // position of "func" keyword
- Params []*Field; // (incoming) parameters
- Results []*Field; // (outgoing) results
- };
+ FuncType struct {
+ token.Position // position of "func" keyword
+ Params []*Field // (incoming) parameters
+ Results []*Field // (outgoing) results
+ }
// An InterfaceType node represents an interface type.
- InterfaceType struct {
- token.Position; // position of "interface" keyword
- Lbrace token.Position; // position of "{"
- Methods []*Field; // list of methods
- Rbrace token.Position; // position of "}"
- Incomplete bool; // true if (source) methods are missing in the Methods list
- };
+ InterfaceType struct {
+ token.Position // position of "interface" keyword
+ Lbrace token.Position // position of "{"
+ Methods []*Field // list of methods
+ Rbrace token.Position // position of "}"
+ Incomplete bool // true if (source) methods are missing in the Methods list
+ }
// A MapType node represents a map type.
- MapType struct {
- token.Position; // position of "map" keyword
- Key Expr;
- Value Expr;
- };
+ MapType struct {
+ token.Position // position of "map" keyword
+ Key Expr
+ Value Expr
+ }
// A ChanType node represents a channel type.
- ChanType struct {
- token.Position; // position of "chan" keyword or "<-" (whichever comes first)
- Dir ChanDir; // channel direction
- Value Expr; // value type
- };
+ ChanType struct {
+ token.Position // position of "chan" keyword or "<-" (whichever comes first)
+ Dir ChanDir // channel direction
+ Value Expr // value type
+ }
)
// Pos() implementations for expression/type where the position
// corresponds to the position of a sub-node.
//
-func (x *StringList) Pos() token.Position { return x.Strings[0].Pos() }
-func (x *FuncLit) Pos() token.Position { return x.Type.Pos() }
-func (x *CompositeLit) Pos() token.Position { return x.Type.Pos() }
-func (x *SelectorExpr) Pos() token.Position { return x.X.Pos() }
-func (x *IndexExpr) Pos() token.Position { return x.X.Pos() }
-func (x *SliceExpr) Pos() token.Position { return x.X.Pos() }
-func (x *TypeAssertExpr) Pos() token.Position { return x.X.Pos() }
-func (x *CallExpr) Pos() token.Position { return x.Fun.Pos() }
-func (x *BinaryExpr) Pos() token.Position { return x.X.Pos() }
-func (x *KeyValueExpr) Pos() token.Position { return x.Key.Pos() }
+func (x *StringList) Pos() token.Position { return x.Strings[0].Pos() }
+func (x *FuncLit) Pos() token.Position { return x.Type.Pos() }
+func (x *CompositeLit) Pos() token.Position { return x.Type.Pos() }
+func (x *SelectorExpr) Pos() token.Position { return x.X.Pos() }
+func (x *IndexExpr) Pos() token.Position { return x.X.Pos() }
+func (x *SliceExpr) Pos() token.Position { return x.X.Pos() }
+func (x *TypeAssertExpr) Pos() token.Position { return x.X.Pos() }
+func (x *CallExpr) Pos() token.Position { return x.Fun.Pos() }
+func (x *BinaryExpr) Pos() token.Position { return x.X.Pos() }
+func (x *KeyValueExpr) Pos() token.Position { return x.Key.Pos() }
// exprNode() ensures that only expression/type nodes can be
// assigned to an ExprNode.
-func (x *BadExpr) exprNode() {}
-func (x *Ident) exprNode() {}
-func (x *Ellipsis) exprNode() {}
-func (x *BasicLit) exprNode() {}
-func (x *StringList) exprNode() {}
-func (x *FuncLit) exprNode() {}
-func (x *CompositeLit) exprNode() {}
-func (x *ParenExpr) exprNode() {}
-func (x *SelectorExpr) exprNode() {}
-func (x *IndexExpr) exprNode() {}
-func (x *SliceExpr) exprNode() {}
-func (x *TypeAssertExpr) exprNode() {}
-func (x *CallExpr) exprNode() {}
-func (x *StarExpr) exprNode() {}
-func (x *UnaryExpr) exprNode() {}
-func (x *BinaryExpr) exprNode() {}
-func (x *KeyValueExpr) exprNode() {}
-
-func (x *ArrayType) exprNode() {}
-func (x *StructType) exprNode() {}
-func (x *FuncType) exprNode() {}
-func (x *InterfaceType) exprNode() {}
-func (x *MapType) exprNode() {}
-func (x *ChanType) exprNode() {}
+func (x *BadExpr) exprNode() {}
+func (x *Ident) exprNode() {}
+func (x *Ellipsis) exprNode() {}
+func (x *BasicLit) exprNode() {}
+func (x *StringList) exprNode() {}
+func (x *FuncLit) exprNode() {}
+func (x *CompositeLit) exprNode() {}
+func (x *ParenExpr) exprNode() {}
+func (x *SelectorExpr) exprNode() {}
+func (x *IndexExpr) exprNode() {}
+func (x *SliceExpr) exprNode() {}
+func (x *TypeAssertExpr) exprNode() {}
+func (x *CallExpr) exprNode() {}
+func (x *StarExpr) exprNode() {}
+func (x *UnaryExpr) exprNode() {}
+func (x *BinaryExpr) exprNode() {}
+func (x *KeyValueExpr) exprNode() {}
+
+func (x *ArrayType) exprNode() {}
+func (x *StructType) exprNode() {}
+func (x *FuncType) exprNode() {}
+func (x *InterfaceType) exprNode() {}
+func (x *MapType) exprNode() {}
+func (x *ChanType) exprNode() {}
// IsExported returns whether name is an exported Go symbol
// (i.e., whether it begins with an uppercase letter).
func IsExported(name string) bool {
- ch, _ := utf8.DecodeRuneInString(name);
- return unicode.IsUpper(ch);
+ ch, _ := utf8.DecodeRuneInString(name)
+ return unicode.IsUpper(ch)
}
// IsExported returns whether name is an exported Go symbol
// (i.e., whether it begins with an uppercase letter).
-func (name *Ident) IsExported() bool { return IsExported(name.Value) }
+func (name *Ident) IsExported() bool { return IsExported(name.Value) }
-func (name *Ident) String() string { return name.Value }
+func (name *Ident) String() string { return name.Value }
// ----------------------------------------------------------------------------
// syntax errors for which no correct statement nodes can be
// created.
//
- BadStmt struct {
- token.Position; // beginning position of bad statement
- };
+ BadStmt struct {
+ token.Position // beginning position of bad statement
+ }
// A DeclStmt node represents a declaration in a statement list.
- DeclStmt struct {
- Decl Decl;
- };
+ DeclStmt struct {
+ Decl Decl
+ }
// An EmptyStmt node represents an empty statement.
// The "position" of the empty statement is the position
// of the immediately preceeding semicolon.
//
- EmptyStmt struct {
- token.Position; // position of preceeding ";"
- };
+ EmptyStmt struct {
+ token.Position // position of preceeding ";"
+ }
// A LabeledStmt node represents a labeled statement.
- LabeledStmt struct {
- Label *Ident;
- Stmt Stmt;
- };
+ LabeledStmt struct {
+ Label *Ident
+ Stmt Stmt
+ }
// An ExprStmt node represents a (stand-alone) expression
// in a statement list.
//
- ExprStmt struct {
- X Expr; // expression
- };
+ ExprStmt struct {
+ X Expr // expression
+ }
// An IncDecStmt node represents an increment or decrement statement.
- IncDecStmt struct {
- X Expr;
- Tok token.Token; // INC or DEC
- };
+ IncDecStmt struct {
+ X Expr
+ Tok token.Token // INC or DEC
+ }
// An AssignStmt node represents an assignment or
// a short variable declaration.
- AssignStmt struct {
- Lhs []Expr;
- TokPos token.Position; // position of Tok
- Tok token.Token; // assignment token, DEFINE
- Rhs []Expr;
- };
+ AssignStmt struct {
+ Lhs []Expr
+ TokPos token.Position // position of Tok
+ Tok token.Token // assignment token, DEFINE
+ Rhs []Expr
+ }
// A GoStmt node represents a go statement.
- GoStmt struct {
- token.Position; // position of "go" keyword
- Call *CallExpr;
- };
+ GoStmt struct {
+ token.Position // position of "go" keyword
+ Call *CallExpr
+ }
// A DeferStmt node represents a defer statement.
- DeferStmt struct {
- token.Position; // position of "defer" keyword
- Call *CallExpr;
- };
+ DeferStmt struct {
+ token.Position // position of "defer" keyword
+ Call *CallExpr
+ }
// A ReturnStmt node represents a return statement.
- ReturnStmt struct {
- token.Position; // position of "return" keyword
- Results []Expr;
- };
+ ReturnStmt struct {
+ token.Position // position of "return" keyword
+ Results []Expr
+ }
// A BranchStmt node represents a break, continue, goto,
// or fallthrough statement.
//
- BranchStmt struct {
- token.Position; // position of Tok
- Tok token.Token; // keyword token (BREAK, CONTINUE, GOTO, FALLTHROUGH)
- Label *Ident;
- };
+ BranchStmt struct {
+ token.Position // position of Tok
+ Tok token.Token // keyword token (BREAK, CONTINUE, GOTO, FALLTHROUGH)
+ Label *Ident
+ }
// A BlockStmt node represents a braced statement list.
- BlockStmt struct {
- token.Position; // position of "{"
- List []Stmt;
- Rbrace token.Position; // position of "}"
- };
+ BlockStmt struct {
+ token.Position // position of "{"
+ List []Stmt
+ Rbrace token.Position // position of "}"
+ }
// An IfStmt node represents an if statement.
- IfStmt struct {
- token.Position; // position of "if" keyword
- Init Stmt;
- Cond Expr;
- Body *BlockStmt;
- Else Stmt;
- };
+ IfStmt struct {
+ token.Position // position of "if" keyword
+ Init Stmt
+ Cond Expr
+ Body *BlockStmt
+ Else Stmt
+ }
// A CaseClause represents a case of an expression switch statement.
- CaseClause struct {
- token.Position; // position of "case" or "default" keyword
- Values []Expr; // nil means default case
- Colon token.Position; // position of ":"
- Body []Stmt; // statement list; or nil
- };
+ CaseClause struct {
+ token.Position // position of "case" or "default" keyword
+ Values []Expr // nil means default case
+ Colon token.Position // position of ":"
+ Body []Stmt // statement list; or nil
+ }
// A SwitchStmt node represents an expression switch statement.
- SwitchStmt struct {
- token.Position; // position of "switch" keyword
- Init Stmt;
- Tag Expr;
- Body *BlockStmt; // CaseClauses only
- };
+ SwitchStmt struct {
+ token.Position // position of "switch" keyword
+ Init Stmt
+ Tag Expr
+ Body *BlockStmt // CaseClauses only
+ }
// A TypeCaseClause represents a case of a type switch statement.
- TypeCaseClause struct {
- token.Position; // position of "case" or "default" keyword
- Types []Expr; // nil means default case
- Colon token.Position; // position of ":"
- Body []Stmt; // statement list; or nil
- };
+ TypeCaseClause struct {
+ token.Position // position of "case" or "default" keyword
+ Types []Expr // nil means default case
+ Colon token.Position // position of ":"
+ Body []Stmt // statement list; or nil
+ }
// An TypeSwitchStmt node represents a type switch statement.
- TypeSwitchStmt struct {
- token.Position; // position of "switch" keyword
- Init Stmt;
- Assign Stmt; // x := y.(type)
- Body *BlockStmt; // TypeCaseClauses only
- };
+ TypeSwitchStmt struct {
+ token.Position // position of "switch" keyword
+ Init Stmt
+ Assign Stmt // x := y.(type)
+ Body *BlockStmt // TypeCaseClauses only
+ }
// A CommClause node represents a case of a select statement.
- CommClause struct {
- token.Position; // position of "case" or "default" keyword
- Tok token.Token; // ASSIGN or DEFINE (valid only if Lhs != nil)
- Lhs, Rhs Expr; // Rhs == nil means default case
- Colon token.Position; // position of ":"
- Body []Stmt; // statement list; or nil
- };
+ CommClause struct {
+ token.Position // position of "case" or "default" keyword
+ Tok token.Token // ASSIGN or DEFINE (valid only if Lhs != nil)
+ Lhs, Rhs Expr // Rhs == nil means default case
+ Colon token.Position // position of ":"
+ Body []Stmt // statement list; or nil
+ }
// An SelectStmt node represents a select statement.
- SelectStmt struct {
- token.Position; // position of "select" keyword
- Body *BlockStmt; // CommClauses only
- };
+ SelectStmt struct {
+ token.Position // position of "select" keyword
+ Body *BlockStmt // CommClauses only
+ }
// A ForStmt represents a for statement.
- ForStmt struct {
- token.Position; // position of "for" keyword
- Init Stmt;
- Cond Expr;
- Post Stmt;
- Body *BlockStmt;
- };
+ ForStmt struct {
+ token.Position // position of "for" keyword
+ Init Stmt
+ Cond Expr
+ Post Stmt
+ Body *BlockStmt
+ }
// A RangeStmt represents a for statement with a range clause.
- RangeStmt struct {
- token.Position; // position of "for" keyword
- Key, Value Expr; // Value may be nil
- TokPos token.Position; // position of Tok
- Tok token.Token; // ASSIGN, DEFINE
- X Expr; // value to range over
- Body *BlockStmt;
- };
+ RangeStmt struct {
+ token.Position // position of "for" keyword
+ Key, Value Expr // Value may be nil
+ TokPos token.Position // position of Tok
+ Tok token.Token // ASSIGN, DEFINE
+ X Expr // value to range over
+ Body *BlockStmt
+ }
)
// Pos() implementations for statement nodes where the position
// corresponds to the position of a sub-node.
//
-func (s *DeclStmt) Pos() token.Position { return s.Decl.Pos() }
-func (s *LabeledStmt) Pos() token.Position { return s.Label.Pos() }
-func (s *ExprStmt) Pos() token.Position { return s.X.Pos() }
-func (s *IncDecStmt) Pos() token.Position { return s.X.Pos() }
-func (s *AssignStmt) Pos() token.Position { return s.Lhs[0].Pos() }
+func (s *DeclStmt) Pos() token.Position { return s.Decl.Pos() }
+func (s *LabeledStmt) Pos() token.Position { return s.Label.Pos() }
+func (s *ExprStmt) Pos() token.Position { return s.X.Pos() }
+func (s *IncDecStmt) Pos() token.Position { return s.X.Pos() }
+func (s *AssignStmt) Pos() token.Position { return s.Lhs[0].Pos() }
// stmtNode() ensures that only statement nodes can be
// assigned to a StmtNode.
//
-func (s *BadStmt) stmtNode() {}
-func (s *DeclStmt) stmtNode() {}
-func (s *EmptyStmt) stmtNode() {}
-func (s *LabeledStmt) stmtNode() {}
-func (s *ExprStmt) stmtNode() {}
-func (s *IncDecStmt) stmtNode() {}
-func (s *AssignStmt) stmtNode() {}
-func (s *GoStmt) stmtNode() {}
-func (s *DeferStmt) stmtNode() {}
-func (s *ReturnStmt) stmtNode() {}
-func (s *BranchStmt) stmtNode() {}
-func (s *BlockStmt) stmtNode() {}
-func (s *IfStmt) stmtNode() {}
-func (s *CaseClause) stmtNode() {}
-func (s *SwitchStmt) stmtNode() {}
-func (s *TypeCaseClause) stmtNode() {}
-func (s *TypeSwitchStmt) stmtNode() {}
-func (s *CommClause) stmtNode() {}
-func (s *SelectStmt) stmtNode() {}
-func (s *ForStmt) stmtNode() {}
-func (s *RangeStmt) stmtNode() {}
+func (s *BadStmt) stmtNode() {}
+func (s *DeclStmt) stmtNode() {}
+func (s *EmptyStmt) stmtNode() {}
+func (s *LabeledStmt) stmtNode() {}
+func (s *ExprStmt) stmtNode() {}
+func (s *IncDecStmt) stmtNode() {}
+func (s *AssignStmt) stmtNode() {}
+func (s *GoStmt) stmtNode() {}
+func (s *DeferStmt) stmtNode() {}
+func (s *ReturnStmt) stmtNode() {}
+func (s *BranchStmt) stmtNode() {}
+func (s *BlockStmt) stmtNode() {}
+func (s *IfStmt) stmtNode() {}
+func (s *CaseClause) stmtNode() {}
+func (s *SwitchStmt) stmtNode() {}
+func (s *TypeCaseClause) stmtNode() {}
+func (s *TypeSwitchStmt) stmtNode() {}
+func (s *CommClause) stmtNode() {}
+func (s *SelectStmt) stmtNode() {}
+func (s *ForStmt) stmtNode() {}
+func (s *RangeStmt) stmtNode() {}
// ----------------------------------------------------------------------------
//
type (
// The Spec type stands for any of *ImportSpec, *ValueSpec, and *TypeSpec.
- Spec interface {
- Node;
- specNode();
- };
+ Spec interface {
+ Node
+ specNode()
+ }
// An ImportSpec node represents a single package import.
- ImportSpec struct {
- Doc *CommentGroup; // associated documentation; or nil
- Name *Ident; // local package name (including "."); or nil
- Path []*BasicLit; // package path
- Comment *CommentGroup; // line comments; or nil
- };
+ ImportSpec struct {
+ Doc *CommentGroup // associated documentation; or nil
+ Name *Ident // local package name (including "."); or nil
+ Path []*BasicLit // package path
+ Comment *CommentGroup // line comments; or nil
+ }
// A ValueSpec node represents a constant or variable declaration
// (ConstSpec or VarSpec production).
- ValueSpec struct {
- Doc *CommentGroup; // associated documentation; or nil
- Names []*Ident; // value names
- Type Expr; // value type; or nil
- Values []Expr; // initial values; or nil
- Comment *CommentGroup; // line comments; or nil
- };
+ ValueSpec struct {
+ Doc *CommentGroup // associated documentation; or nil
+ Names []*Ident // value names
+ Type Expr // value type; or nil
+ Values []Expr // initial values; or nil
+ Comment *CommentGroup // line comments; or nil
+ }
// A TypeSpec node represents a type declaration (TypeSpec production).
- TypeSpec struct {
- Doc *CommentGroup; // associated documentation; or nil
- Name *Ident; // type name
- Type Expr;
- Comment *CommentGroup; // line comments; or nil
- };
+ TypeSpec struct {
+ Doc *CommentGroup // associated documentation; or nil
+ Name *Ident // type name
+ Type Expr
+ Comment *CommentGroup // line comments; or nil
+ }
)
if s.Name != nil {
return s.Name.Pos()
}
- return s.Path[0].Pos();
+ return s.Path[0].Pos()
}
-func (s *ValueSpec) Pos() token.Position { return s.Names[0].Pos() }
-func (s *TypeSpec) Pos() token.Position { return s.Name.Pos() }
+func (s *ValueSpec) Pos() token.Position { return s.Names[0].Pos() }
+func (s *TypeSpec) Pos() token.Position { return s.Name.Pos() }
// specNode() ensures that only spec nodes can be
// assigned to a Spec.
//
-func (s *ImportSpec) specNode() {}
-func (s *ValueSpec) specNode() {}
-func (s *TypeSpec) specNode() {}
+func (s *ImportSpec) specNode() {}
+func (s *ValueSpec) specNode() {}
+func (s *TypeSpec) specNode() {}
// A declaration is represented by one of the following declaration nodes.
// syntax errors for which no correct declaration nodes can be
// created.
//
- BadDecl struct {
- token.Position; // beginning position of bad declaration
- };
+ BadDecl struct {
+ token.Position // beginning position of bad declaration
+ }
// A GenDecl node (generic declaration node) represents an import,
// constant, type or variable declaration. A valid Lparen position
// token.TYPE *TypeSpec
// token.VAR *ValueSpec
//
- GenDecl struct {
- Doc *CommentGroup; // associated documentation; or nil
- token.Position; // position of Tok
- Tok token.Token; // IMPORT, CONST, TYPE, VAR
- Lparen token.Position; // position of '(', if any
- Specs []Spec;
- Rparen token.Position; // position of ')', if any
- };
+ GenDecl struct {
+ Doc *CommentGroup // associated documentation; or nil
+ token.Position // position of Tok
+ Tok token.Token // IMPORT, CONST, TYPE, VAR
+ Lparen token.Position // position of '(', if any
+ Specs []Spec
+ Rparen token.Position // position of ')', if any
+ }
// A FuncDecl node represents a function declaration.
- FuncDecl struct {
- Doc *CommentGroup; // associated documentation; or nil
- Recv *Field; // receiver (methods); or nil (functions)
- Name *Ident; // function/method name
- Type *FuncType; // position of Func keyword, parameters and results
- Body *BlockStmt; // function body; or nil (forward declaration)
- };
+ FuncDecl struct {
+ Doc *CommentGroup // associated documentation; or nil
+ Recv *Field // receiver (methods); or nil (functions)
+ Name *Ident // function/method name
+ Type *FuncType // position of Func keyword, parameters and results
+ Body *BlockStmt // function body; or nil (forward declaration)
+ }
)
// The position of a FuncDecl node is the position of its function type.
-func (d *FuncDecl) Pos() token.Position { return d.Type.Pos() }
+func (d *FuncDecl) Pos() token.Position { return d.Type.Pos() }
// declNode() ensures that only declaration nodes can be
// assigned to a DeclNode.
//
-func (d *BadDecl) declNode() {}
-func (d *GenDecl) declNode() {}
-func (d *FuncDecl) declNode() {}
+func (d *BadDecl) declNode() {}
+func (d *GenDecl) declNode() {}
+func (d *FuncDecl) declNode() {}
// ----------------------------------------------------------------------------
// A File node represents a Go source file.
//
type File struct {
- Doc *CommentGroup; // associated documentation; or nil
- token.Position; // position of "package" keyword
- Name *Ident; // package name
- Decls []Decl; // top-level declarations
- Comments *CommentGroup; // list of all comments in the source file
+ Doc *CommentGroup // associated documentation; or nil
+ token.Position // position of "package" keyword
+ Name *Ident // package name
+ Decls []Decl // top-level declarations
+ Comments *CommentGroup // list of all comments in the source file
}
// collectively building a Go package.
//
type Package struct {
- Name string; // package name
- Path string; // package path
- Files map[string]*File; // path-relative filenames
+ Name string // package name
+ Path string // package path
+ Files map[string]*File // path-relative filenames
}
func filterIdentList(list []*Ident) []*Ident {
- j := 0;
+ j := 0
for _, x := range list {
if x.IsExported() {
- list[j] = x;
- j++;
+ list[j] = x
+ j++
}
}
- return list[0:j];
+ return list[0:j]
}
case *StarExpr:
return isExportedType(t.X)
}
- return false;
+ return false
}
func filterFieldList(list []*Field, incomplete *bool) []*Field {
- j := 0;
+ j := 0
for _, f := range list {
- exported := false;
+ exported := false
if len(f.Names) == 0 {
// anonymous field
// (Note that a non-exported anonymous field
// type information.)
exported = isExportedType(f.Type)
} else {
- n := len(f.Names);
- f.Names = filterIdentList(f.Names);
+ n := len(f.Names)
+ f.Names = filterIdentList(f.Names)
if len(f.Names) < n {
*incomplete = true
}
- exported = len(f.Names) > 0;
+ exported = len(f.Names) > 0
}
if exported {
- filterType(f.Type);
- list[j] = f;
- j++;
+ filterType(f.Type)
+ list[j] = f
+ j++
}
}
if j < len(list) {
*incomplete = true
}
- return list[0:j];
+ return list[0:j]
}
case *StructType:
t.Fields = filterFieldList(t.Fields, &t.Incomplete)
case *FuncType:
- filterParamList(t.Params);
- filterParamList(t.Results);
+ filterParamList(t.Params)
+ filterParamList(t.Results)
case *InterfaceType:
t.Methods = filterFieldList(t.Methods, &t.Incomplete)
case *MapType:
- filterType(t.Key);
- filterType(t.Value);
+ filterType(t.Key)
+ filterType(t.Value)
case *ChanType:
filterType(t.Value)
}
func filterSpec(spec Spec) bool {
switch s := spec.(type) {
case *ValueSpec:
- s.Names = filterIdentList(s.Names);
+ s.Names = filterIdentList(s.Names)
if len(s.Names) > 0 {
- filterType(s.Type);
- return true;
+ filterType(s.Type)
+ return true
}
case *TypeSpec:
// TODO(gri) consider stripping forward declarations
// of structs, interfaces, functions, and methods
if s.Name.IsExported() {
- filterType(s.Type);
- return true;
+ filterType(s.Type)
+ return true
}
}
- return false;
+ return false
}
func filterSpecList(list []Spec) []Spec {
- j := 0;
+ j := 0
for _, s := range list {
if filterSpec(s) {
- list[j] = s;
- j++;
+ list[j] = s
+ j++
}
}
- return list[0:j];
+ return list[0:j]
}
func filterDecl(decl Decl) bool {
switch d := decl.(type) {
case *GenDecl:
- d.Specs = filterSpecList(d.Specs);
- return len(d.Specs) > 0;
+ d.Specs = filterSpecList(d.Specs)
+ return len(d.Specs) > 0
case *FuncDecl:
// TODO consider removing function declaration altogether if
// forward declaration (i.e., if d.Body == nil) because
// in that case the actual declaration will come later.
- d.Body = nil; // strip body
- return d.Name.IsExported();
+ d.Body = nil // strip body
+ return d.Name.IsExported()
}
- return false;
+ return false
}
// false otherwise.
//
func FileExports(src *File) bool {
- j := 0;
+ j := 0
for _, d := range src.Decls {
if filterDecl(d) {
- src.Decls[j] = d;
- j++;
+ src.Decls[j] = d
+ j++
}
}
- src.Decls = src.Decls[0:j];
- return j > 0;
+ src.Decls = src.Decls[0:j]
+ return j > 0
}
// returns false otherwise.
//
func PackageExports(pkg *Package) bool {
- hasExports := false;
+ hasExports := false
for _, f := range pkg.Files {
if FileExports(f) {
hasExports = true
}
}
- return hasExports;
+ return hasExports
}
func MergePackageFiles(pkg *Package) *File {
// Count the number of package comments and declarations across
// all package files.
- ncomments := 0;
- ndecls := 0;
+ ncomments := 0
+ ndecls := 0
for _, f := range pkg.Files {
if f.Doc != nil {
- ncomments += len(f.Doc.List) + 1 // +1 for separator
+ ncomments += len(f.Doc.List) + 1 // +1 for separator
}
- ndecls += len(f.Decls);
+ ndecls += len(f.Decls)
}
// Collect package comments from all package files into a single
// is unspecified. In general there should be only one file with
// a package comment; but it's better to collect extra comments
// than drop them on the floor.
- var doc *CommentGroup;
+ var doc *CommentGroup
if ncomments > 0 {
- list := make([]*Comment, ncomments-1); // -1: no separator before first group
- i := 0;
+ list := make([]*Comment, ncomments-1) // -1: no separator before first group
+ i := 0
for _, f := range pkg.Files {
if f.Doc != nil {
if i > 0 {
// not the first group - add separator
- list[i] = separator;
- i++;
+ list[i] = separator
+ i++
}
for _, c := range f.Doc.List {
- list[i] = c;
- i++;
+ list[i] = c
+ i++
}
}
}
- doc = &CommentGroup{list, nil};
+ doc = &CommentGroup{list, nil}
}
// Collect declarations from all package files.
- var decls []Decl;
+ var decls []Decl
if ndecls > 0 {
- decls = make([]Decl, ndecls);
- i := 0;
+ decls = make([]Decl, ndecls)
+ i := 0
for _, f := range pkg.Files {
for _, d := range f.Decls {
- decls[i] = d;
- i++;
+ decls[i] = d
+ i++
}
}
}
// TODO(gri) Should collect comments as well. For that the comment
// list should be changed back into a []*CommentGroup,
// otherwise need to modify the existing linked list.
- return &File{doc, noPos, &Ident{noPos, pkg.Name}, decls, nil};
+ return &File{doc, noPos, &Ident{noPos, pkg.Name}, decls, nil}
}
// NOTE: WORK IN PROGRESS
//
type Scope struct {
- Outer *Scope;
- Names map[string]*Ident;
+ Outer *Scope
+ Names map[string]*Ident
}
// NewScope creates a new scope nested in the outer scope.
-func NewScope(outer *Scope) *Scope { return &Scope{outer, make(map[string]*Ident)} }
+func NewScope(outer *Scope) *Scope { return &Scope{outer, make(map[string]*Ident)} }
// Declare inserts an identifier into the scope s. If the
if _, found := s.Names[ident.Value]; found {
return false
}
- s.Names[ident.Value] = ident;
- return true;
+ s.Names[ident.Value] = ident
+ return true
}
return ident
}
}
- return nil;
+ return nil
}
// If the result visitor w is not nil, Walk visits each of the children
// of node with the visitor w, followed by a call of w.Visit(nil).
type Visitor interface {
- Visit(node interface{}) (w Visitor);
+ Visit(node interface{}) (w Visitor)
}
// comments list.
case *Field:
- walkCommentGroup(v, n.Doc);
- Walk(v, n.Names);
- Walk(v, n.Type);
+ walkCommentGroup(v, n.Doc)
+ Walk(v, n.Names)
+ Walk(v, n.Type)
for _, x := range n.Tag {
Walk(v, x)
}
- walkCommentGroup(v, n.Comment);
+ walkCommentGroup(v, n.Comment)
// Expressions
case *BadExpr, *Ident, *Ellipsis, *BasicLit:
if n != nil {
Walk(v, n.Type)
}
- walkBlockStmt(v, n.Body);
+ walkBlockStmt(v, n.Body)
case *CompositeLit:
- Walk(v, n.Type);
- Walk(v, n.Elts);
+ Walk(v, n.Type)
+ Walk(v, n.Elts)
case *ParenExpr:
Walk(v, n.X)
case *SelectorExpr:
- Walk(v, n.X);
- walkIdent(v, n.Sel);
+ Walk(v, n.X)
+ walkIdent(v, n.Sel)
case *IndexExpr:
- Walk(v, n.X);
- Walk(v, n.Index);
+ Walk(v, n.X)
+ Walk(v, n.Index)
case *SliceExpr:
- Walk(v, n.X);
- Walk(v, n.Index);
- Walk(v, n.End);
+ Walk(v, n.X)
+ Walk(v, n.Index)
+ Walk(v, n.End)
case *TypeAssertExpr:
- Walk(v, n.X);
- Walk(v, n.Type);
+ Walk(v, n.X)
+ Walk(v, n.Type)
case *CallExpr:
- Walk(v, n.Fun);
- Walk(v, n.Args);
+ Walk(v, n.Fun)
+ Walk(v, n.Args)
case *StarExpr:
Walk(v, n.X)
Walk(v, n.X)
case *BinaryExpr:
- Walk(v, n.X);
- Walk(v, n.Y);
+ Walk(v, n.X)
+ Walk(v, n.Y)
case *KeyValueExpr:
- Walk(v, n.Key);
- Walk(v, n.Value);
+ Walk(v, n.Key)
+ Walk(v, n.Value)
// Types
case *ArrayType:
- Walk(v, n.Len);
- Walk(v, n.Elt);
+ Walk(v, n.Len)
+ Walk(v, n.Elt)
case *StructType:
Walk(v, n.Fields)
case *FuncType:
- Walk(v, n.Params);
- Walk(v, n.Results);
+ Walk(v, n.Params)
+ Walk(v, n.Results)
case *InterfaceType:
Walk(v, n.Methods)
case *MapType:
- Walk(v, n.Key);
- Walk(v, n.Value);
+ Walk(v, n.Key)
+ Walk(v, n.Value)
case *ChanType:
Walk(v, n.Value)
// nothing to do
case *LabeledStmt:
- walkIdent(v, n.Label);
- Walk(v, n.Stmt);
+ walkIdent(v, n.Label)
+ Walk(v, n.Stmt)
case *ExprStmt:
Walk(v, n.X)
Walk(v, n.X)
case *AssignStmt:
- Walk(v, n.Lhs);
- Walk(v, n.Rhs);
+ Walk(v, n.Lhs)
+ Walk(v, n.Rhs)
case *GoStmt:
if n.Call != nil {
Walk(v, n.List)
case *IfStmt:
- Walk(v, n.Init);
- Walk(v, n.Cond);
- walkBlockStmt(v, n.Body);
- Walk(v, n.Else);
+ Walk(v, n.Init)
+ Walk(v, n.Cond)
+ walkBlockStmt(v, n.Body)
+ Walk(v, n.Else)
case *CaseClause:
- Walk(v, n.Values);
- Walk(v, n.Body);
+ Walk(v, n.Values)
+ Walk(v, n.Body)
case *SwitchStmt:
- Walk(v, n.Init);
- Walk(v, n.Tag);
- walkBlockStmt(v, n.Body);
+ Walk(v, n.Init)
+ Walk(v, n.Tag)
+ walkBlockStmt(v, n.Body)
case *TypeCaseClause:
- Walk(v, n.Types);
- Walk(v, n.Body);
+ Walk(v, n.Types)
+ Walk(v, n.Body)
case *TypeSwitchStmt:
- Walk(v, n.Init);
- Walk(v, n.Assign);
- walkBlockStmt(v, n.Body);
+ Walk(v, n.Init)
+ Walk(v, n.Assign)
+ walkBlockStmt(v, n.Body)
case *CommClause:
- Walk(v, n.Lhs);
- Walk(v, n.Rhs);
- Walk(v, n.Body);
+ Walk(v, n.Lhs)
+ Walk(v, n.Rhs)
+ Walk(v, n.Body)
case *SelectStmt:
walkBlockStmt(v, n.Body)
case *ForStmt:
- Walk(v, n.Init);
- Walk(v, n.Cond);
- Walk(v, n.Post);
- walkBlockStmt(v, n.Body);
+ Walk(v, n.Init)
+ Walk(v, n.Cond)
+ Walk(v, n.Post)
+ walkBlockStmt(v, n.Body)
case *RangeStmt:
- Walk(v, n.Key);
- Walk(v, n.Value);
- Walk(v, n.X);
- walkBlockStmt(v, n.Body);
+ Walk(v, n.Key)
+ Walk(v, n.Value)
+ Walk(v, n.X)
+ walkBlockStmt(v, n.Body)
// Declarations
case *ImportSpec:
- walkCommentGroup(v, n.Doc);
- walkIdent(v, n.Name);
+ walkCommentGroup(v, n.Doc)
+ walkIdent(v, n.Name)
for _, x := range n.Path {
Walk(v, x)
}
- walkCommentGroup(v, n.Comment);
+ walkCommentGroup(v, n.Comment)
case *ValueSpec:
- walkCommentGroup(v, n.Doc);
- Walk(v, n.Names);
- Walk(v, n.Type);
- Walk(v, n.Values);
- walkCommentGroup(v, n.Comment);
+ walkCommentGroup(v, n.Doc)
+ Walk(v, n.Names)
+ Walk(v, n.Type)
+ Walk(v, n.Values)
+ walkCommentGroup(v, n.Comment)
case *TypeSpec:
- walkCommentGroup(v, n.Doc);
- walkIdent(v, n.Name);
- Walk(v, n.Type);
- walkCommentGroup(v, n.Comment);
+ walkCommentGroup(v, n.Doc)
+ walkIdent(v, n.Name)
+ Walk(v, n.Type)
+ walkCommentGroup(v, n.Comment)
case *BadDecl:
// nothing to do
case *GenDecl:
- walkCommentGroup(v, n.Doc);
+ walkCommentGroup(v, n.Doc)
for _, s := range n.Specs {
Walk(v, s)
}
case *FuncDecl:
- walkCommentGroup(v, n.Doc);
+ walkCommentGroup(v, n.Doc)
if n.Recv != nil {
Walk(v, n.Recv)
}
- walkIdent(v, n.Name);
+ walkIdent(v, n.Name)
if n.Type != nil {
Walk(v, n.Type)
}
- walkBlockStmt(v, n.Body);
+ walkBlockStmt(v, n.Body)
// Files and packages
case *File:
- walkCommentGroup(v, n.Doc);
- walkIdent(v, n.Name);
+ walkCommentGroup(v, n.Doc)
+ walkIdent(v, n.Name)
for _, d := range n.Decls {
Walk(v, d)
}
- walkCommentGroup(v, n.Comments);
+ walkCommentGroup(v, n.Comments)
case *Package:
for _, f := range n.Files {
}
default:
- fmt.Printf("ast.Walk: unexpected type %T", n);
- panic();
+ fmt.Printf("ast.Walk: unexpected type %T", n)
+ panic()
}
- v.Visit(nil);
+ v.Visit(nil)
}
package doc
import (
- "go/ast";
- "io";
- "strings";
- "template"; // for htmlEscape
+ "go/ast"
+ "io"
+ "strings"
+ "template" // for htmlEscape
)
// Comment extraction
if comment == nil {
return ""
}
- comments := make([]string, len(comment.List));
+ comments := make([]string, len(comment.List))
for i, c := range comment.List {
comments[i] = string(c.Text)
}
- lines := make([]string, 0, 20);
+ lines := make([]string, 0, 20)
for _, c := range comments {
// Remove comment markers.
// The parser has given us exactly the comment text.
case n >= 4 && c[0:2] == "/*" && c[n-2:n] == "*/":
c = c[2 : n-2]
case n >= 2 && c[0:2] == "//":
- c = c[2:n];
+ c = c[2:n]
// Remove leading space after //, if there is one.
if len(c) > 0 && c[0] == ' ' {
c = c[1:]
}
// Split on newlines.
- cl := strings.Split(c, "\n", 0);
+ cl := strings.Split(c, "\n", 0)
// Walk lines, stripping trailing white space and adding to list.
for _, l := range cl {
// Strip trailing white space
- m := len(l);
+ m := len(l)
for m > 0 && (l[m-1] == ' ' || l[m-1] == '\n' || l[m-1] == '\t' || l[m-1] == '\r') {
m--
}
- l = l[0:m];
+ l = l[0:m]
// Add to list.
- n := len(lines);
+ n := len(lines)
if n+1 >= cap(lines) {
- newlines := make([]string, n, 2*cap(lines));
+ newlines := make([]string, n, 2*cap(lines))
for k := range newlines {
newlines[k] = lines[k]
}
- lines = newlines;
+ lines = newlines
}
- lines = lines[0 : n+1];
- lines[n] = l;
+ lines = lines[0 : n+1]
+ lines[n] = l
}
}
// Remove leading blank lines; convert runs of
// interior blank lines to a single blank line.
- n := 0;
+ n := 0
for _, line := range lines {
if line != "" || n > 0 && lines[n-1] != "" {
- lines[n] = line;
- n++;
+ lines[n] = line
+ n++
}
}
- lines = lines[0:n];
+ lines = lines[0:n]
// Add final "" entry to get trailing newline from Join.
// The original loop always leaves room for one more.
if n > 0 && lines[n-1] != "" {
- lines = lines[0 : n+1];
- lines[n] = "";
+ lines = lines[0 : n+1]
+ lines[n] = ""
}
- return strings.Join(lines, "\n");
+ return strings.Join(lines, "\n")
}
// Split bytes into lines.
func split(text []byte) [][]byte {
// count lines
- n := 0;
- last := 0;
+ n := 0
+ last := 0
for i, c := range text {
if c == '\n' {
- last = i + 1;
- n++;
+ last = i + 1
+ n++
}
}
if last < len(text) {
}
// split
- out := make([][]byte, n);
- last = 0;
- n = 0;
+ out := make([][]byte, n)
+ last = 0
+ n = 0
for i, c := range text {
if c == '\n' {
- out[n] = text[last : i+1];
- last = i + 1;
- n++;
+ out[n] = text[last : i+1]
+ last = i + 1
+ n++
}
}
if last < len(text) {
out[n] = text[last:]
}
- return out;
+ return out
}
var (
- ldquo = strings.Bytes("“");
- rdquo = strings.Bytes("”");
+ ldquo = strings.Bytes("“")
+ rdquo = strings.Bytes("”")
)
// Escape comment text for HTML.
// Also, turn `` into “ and '' into ”.
func commentEscape(w io.Writer, s []byte) {
- last := 0;
+ last := 0
for i := 0; i < len(s)-1; i++ {
if s[i] == s[i+1] && (s[i] == '`' || s[i] == '\'') {
- template.HTMLEscape(w, s[last:i]);
- last = i + 2;
+ template.HTMLEscape(w, s[last:i])
+ last = i + 2
switch s[i] {
case '`':
w.Write(ldquo)
case '\'':
w.Write(rdquo)
}
- i++; // loop will add one more
+ i++ // loop will add one more
}
}
- template.HTMLEscape(w, s[last:]);
+ template.HTMLEscape(w, s[last:])
}
var (
- html_p = strings.Bytes("<p>\n");
- html_endp = strings.Bytes("</p>\n");
- html_pre = strings.Bytes("<pre>");
- html_endpre = strings.Bytes("</pre>\n");
+ html_p = strings.Bytes("<p>\n")
+ html_endp = strings.Bytes("</p>\n")
+ html_pre = strings.Bytes("<pre>")
+ html_endpre = strings.Bytes("</pre>\n")
)
func indentLen(s []byte) int {
- i := 0;
+ i := 0
for i < len(s) && (s[i] == ' ' || s[i] == '\t') {
i++
}
- return i;
+ return i
}
-func isBlank(s []byte) bool { return len(s) == 0 || (len(s) == 1 && s[0] == '\n') }
+func isBlank(s []byte) bool { return len(s) == 0 || (len(s) == 1 && s[0] == '\n') }
func commonPrefix(a, b []byte) []byte {
- i := 0;
+ i := 0
for i < len(a) && i < len(b) && a[i] == b[i] {
i++
}
- return a[0:i];
+ return a[0:i]
}
}
// compute maximum common white prefix
- prefix := block[0][0:indentLen(block[0])];
+ prefix := block[0][0:indentLen(block[0])]
for _, line := range block {
if !isBlank(line) {
prefix = commonPrefix(prefix, line[0:indentLen(line)])
}
}
- n := len(prefix);
+ n := len(prefix)
// remove
for i, line := range block {
// TODO(rsc): I'd like to pass in an array of variable names []string
// and then italicize those strings when they appear as words.
func ToHTML(w io.Writer, s []byte) {
- inpara := false;
+ inpara := false
close := func() {
if inpara {
- w.Write(html_endp);
- inpara = false;
+ w.Write(html_endp)
+ inpara = false
}
- };
+ }
open := func() {
if !inpara {
- w.Write(html_p);
- inpara = true;
+ w.Write(html_p)
+ inpara = true
}
- };
+ }
- lines := split(s);
- unindent(lines);
+ lines := split(s)
+ unindent(lines)
for i := 0; i < len(lines); {
- line := lines[i];
+ line := lines[i]
if isBlank(line) {
// close paragraph
- close();
- i++;
- continue;
+ close()
+ i++
+ continue
}
if indentLen(line) > 0 {
// close paragraph
- close();
+ close()
// count indented or blank lines
- j := i + 1;
+ j := i + 1
for j < len(lines) && (isBlank(lines[j]) || indentLen(lines[j]) > 0) {
j++
}
for j > i && isBlank(lines[j-1]) {
j--
}
- block := lines[i:j];
- i = j;
+ block := lines[i:j]
+ i = j
- unindent(block);
+ unindent(block)
// put those lines in a pre block.
// they don't get the nice text formatting,
// just html escaping
- w.Write(html_pre);
+ w.Write(html_pre)
for _, line := range block {
template.HTMLEscape(w, line)
}
- w.Write(html_endpre);
- continue;
+ w.Write(html_endpre)
+ continue
}
// open paragraph
- open();
- commentEscape(w, lines[i]);
- i++;
+ open()
+ commentEscape(w, lines[i])
+ i++
}
- close();
+ close()
}
package doc
import (
- "container/vector";
- "go/ast";
- "go/token";
- "regexp";
- "sort";
+ "container/vector"
+ "go/ast"
+ "go/token"
+ "regexp"
+ "sort"
)
type typeDoc struct {
// len(decl.Specs) == 1, and the element type is *ast.TypeSpec
// if the type declaration hasn't been seen yet, decl is nil
- decl *ast.GenDecl;
+ decl *ast.GenDecl
// values, factory functions, and methods associated with the type
- values *vector.Vector; // list of *ast.GenDecl (consts and vars)
- factories map[string]*ast.FuncDecl;
- methods map[string]*ast.FuncDecl;
+ values *vector.Vector // list of *ast.GenDecl (consts and vars)
+ factories map[string]*ast.FuncDecl
+ methods map[string]*ast.FuncDecl
}
// printing the corresponding AST node).
//
type docReader struct {
- doc *ast.CommentGroup; // package documentation, if any
- pkgName string;
- values *vector.Vector; // list of *ast.GenDecl (consts and vars)
- types map[string]*typeDoc;
- funcs map[string]*ast.FuncDecl;
- bugs *vector.Vector; // list of *ast.CommentGroup
+ doc *ast.CommentGroup // package documentation, if any
+ pkgName string
+ values *vector.Vector // list of *ast.GenDecl (consts and vars)
+ types map[string]*typeDoc
+ funcs map[string]*ast.FuncDecl
+ bugs *vector.Vector // list of *ast.CommentGroup
}
func (doc *docReader) init(pkgName string) {
- doc.pkgName = pkgName;
- doc.values = new(vector.Vector);
- doc.types = make(map[string]*typeDoc);
- doc.funcs = make(map[string]*ast.FuncDecl);
- doc.bugs = new(vector.Vector);
+ doc.pkgName = pkgName
+ doc.values = new(vector.Vector)
+ doc.types = make(map[string]*typeDoc)
+ doc.funcs = make(map[string]*ast.FuncDecl)
+ doc.bugs = new(vector.Vector)
}
func (doc *docReader) addType(decl *ast.GenDecl) {
- spec := decl.Specs[0].(*ast.TypeSpec);
- typ := doc.lookupTypeDoc(spec.Name.Value);
+ spec := decl.Specs[0].(*ast.TypeSpec)
+ typ := doc.lookupTypeDoc(spec.Name.Value)
// typ should always be != nil since declared types
// are always named - be conservative and check
if typ != nil {
func (doc *docReader) lookupTypeDoc(name string) *typeDoc {
if name == "" {
- return nil // no type docs for anonymous types
+ return nil // no type docs for anonymous types
}
if tdoc, found := doc.types[name]; found {
return tdoc
}
// type wasn't found - add one without declaration
- tdoc := &typeDoc{nil, new(vector.Vector), make(map[string]*ast.FuncDecl), make(map[string]*ast.FuncDecl)};
- doc.types[name] = tdoc;
- return tdoc;
+ tdoc := &typeDoc{nil, new(vector.Vector), make(map[string]*ast.FuncDecl), make(map[string]*ast.FuncDecl)}
+ doc.types[name] = tdoc
+ return tdoc
}
case *ast.StarExpr:
return baseTypeName(t.X)
}
- return "";
+ return ""
}
// Heuristic: For each typed entry, determine the type name, if any.
// If there is exactly one type name that is sufficiently
// frequent, associate the decl with the respective type.
- domName := "";
- domFreq := 0;
- prev := "";
+ domName := ""
+ domFreq := 0
+ prev := ""
for _, s := range decl.Specs {
if v, ok := s.(*ast.ValueSpec); ok {
- name := "";
+ name := ""
switch {
case v.Type != nil:
// a type is present; determine it's name
if domName != "" && domName != name {
// more than one type name - do not associate
// with any type
- domName = "";
- break;
+ domName = ""
+ break
}
- domName = name;
- domFreq++;
+ domName = name
+ domFreq++
}
- prev = name;
+ prev = name
}
}
// determine values list
- const threshold = 0.75;
- values := doc.values;
+ const threshold = 0.75
+ values := doc.values
if domName != "" && domFreq >= int(float(len(decl.Specs))*threshold) {
// typed entries are sufficiently frequent
- typ := doc.lookupTypeDoc(domName);
+ typ := doc.lookupTypeDoc(domName)
if typ != nil {
- values = typ.values // associate with that type
+ values = typ.values // associate with that type
}
}
- values.Push(decl);
+ values.Push(decl)
}
func (doc *docReader) addFunc(fun *ast.FuncDecl) {
- name := fun.Name.Value;
+ name := fun.Name.Value
// determine if it should be associated with a type
if fun.Recv != nil {
// method
- typ := doc.lookupTypeDoc(baseTypeName(fun.Recv.Type));
+ typ := doc.lookupTypeDoc(baseTypeName(fun.Recv.Type))
if typ != nil {
// exported receiver type
typ.methods[name] = fun
// that can be called because of exported values (consts, vars, or
// function results) of that type. Could determine if that is the
// case and then show those methods in an appropriate section.
- return;
+ return
}
// perhaps a factory function
// determine result type, if any
if len(fun.Type.Results) >= 1 {
- res := fun.Type.Results[0];
+ res := fun.Type.Results[0]
if len(res.Names) <= 1 {
// exactly one (named or anonymous) result associated
// with the first type in result signature (there may
// be more than one result)
- tname := baseTypeName(res.Type);
- typ := doc.lookupTypeDoc(tname);
+ tname := baseTypeName(res.Type)
+ typ := doc.lookupTypeDoc(tname)
if typ != nil {
// named and exported result type
if doc.pkgName == "os" && tname == "Error" &&
name != "NewError" && name != "NewSyscallError" {
// not a factory function for os.Error
- doc.funcs[name] = fun; // treat as ordinary function
- return;
+ doc.funcs[name] = fun // treat as ordinary function
+ return
}
- typ.factories[name] = fun;
- return;
+ typ.factories[name] = fun
+ return
}
}
}
// ordinary function
- doc.funcs[name] = fun;
+ doc.funcs[name] = fun
}
doc.addValue(d)
case token.TYPE:
// types are handled individually
- var noPos token.Position;
+ var noPos token.Position
for _, spec := range d.Specs {
// make a (fake) GenDecl node for this TypeSpec
// (we need to do this here - as opposed to just
func copyCommentList(list []*ast.Comment) []*ast.Comment {
- copy := make([]*ast.Comment, len(list));
+ copy := make([]*ast.Comment, len(list))
for i, c := range list {
copy[i] = c
}
- return copy;
+ return copy
}
var (
- bug_markers = regexp.MustCompile("^/[/*][ \t]*BUG\\(.*\\):[ \t]*"); // BUG(uid):
- bug_content = regexp.MustCompile("[^ \n\r\t]+"); // at least one non-whitespace char
+ bug_markers = regexp.MustCompile("^/[/*][ \t]*BUG\\(.*\\):[ \t]*") // BUG(uid):
+ bug_content = regexp.MustCompile("[^ \n\r\t]+") // at least one non-whitespace char
)
// using ast.MergePackageFiles which handles these
// comments correctly (but currently looses BUG(...)
// comments).
- doc.doc = src.Doc;
- src.Doc = nil; // doc consumed - remove from ast.File node
+ doc.doc = src.Doc
+ src.Doc = nil // doc consumed - remove from ast.File node
}
// add all declarations
// collect BUG(...) comments
for c := src.Comments; c != nil; c = c.Next {
- text := c.List[0].Text;
- cstr := string(text);
+ text := c.List[0].Text
+ cstr := string(text)
if m := bug_markers.ExecuteString(cstr); len(m) > 0 {
// found a BUG comment; maybe empty
if bstr := cstr[m[1]:]; bug_content.MatchString(bstr) {
// non-empty BUG comment; collect comment without BUG prefix
- list := copyCommentList(c.List);
- list[0].Text = text[m[1]:];
- doc.bugs.Push(&ast.CommentGroup{list, nil});
+ list := copyCommentList(c.List)
+ list[0].Text = text[m[1]:]
+ doc.bugs.Push(&ast.CommentGroup{list, nil})
}
}
}
- src.Comments = nil; // consumed unassociated comments - remove from ast.File node
+ src.Comments = nil // consumed unassociated comments - remove from ast.File node
}
func NewFileDoc(file *ast.File) *PackageDoc {
- var r docReader;
- r.init(file.Name.Value);
- r.addFile(file);
- return r.newDoc("", "", nil);
+ var r docReader
+ r.init(file.Name.Value)
+ r.addFile(file)
+ return r.newDoc("", "", nil)
}
func NewPackageDoc(pkg *ast.Package, importpath string) *PackageDoc {
- var r docReader;
- r.init(pkg.Name);
- filenames := make([]string, len(pkg.Files));
- i := 0;
+ var r docReader
+ r.init(pkg.Name)
+ filenames := make([]string, len(pkg.Files))
+ i := 0
for filename, f := range pkg.Files {
- r.addFile(f);
- filenames[i] = filename;
- i++;
+ r.addFile(f)
+ filenames[i] = filename
+ i++
}
- return r.newDoc(importpath, pkg.Path, filenames);
+ return r.newDoc(importpath, pkg.Path, filenames)
}
// values, either vars or consts.
//
type ValueDoc struct {
- Doc string;
- Decl *ast.GenDecl;
- order int;
+ Doc string
+ Decl *ast.GenDecl
+ order int
}
type sortValueDoc []*ValueDoc
-func (p sortValueDoc) Len() int { return len(p) }
-func (p sortValueDoc) Swap(i, j int) { p[i], p[j] = p[j], p[i] }
+func (p sortValueDoc) Len() int { return len(p) }
+func (p sortValueDoc) Swap(i, j int) { p[i], p[j] = p[j], p[i] }
func declName(d *ast.GenDecl) string {
return v.Name.Value
}
- return "";
+ return ""
}
if ni, nj := declName(p[i].Decl), declName(p[j].Decl); ni != nj {
return ni < nj
}
- return p[i].order < p[j].order;
+ return p[i].order < p[j].order
}
func makeValueDocs(v *vector.Vector, tok token.Token) []*ValueDoc {
- d := make([]*ValueDoc, v.Len()); // big enough in any case
- n := 0;
+ d := make([]*ValueDoc, v.Len()) // big enough in any case
+ n := 0
for i := range d {
- decl := v.At(i).(*ast.GenDecl);
+ decl := v.At(i).(*ast.GenDecl)
if decl.Tok == tok {
- d[n] = &ValueDoc{CommentText(decl.Doc), decl, i};
- n++;
- decl.Doc = nil; // doc consumed - removed from AST
+ d[n] = &ValueDoc{CommentText(decl.Doc), decl, i}
+ n++
+ decl.Doc = nil // doc consumed - removed from AST
}
}
- d = d[0:n];
- sort.Sort(sortValueDoc(d));
- return d;
+ d = d[0:n]
+ sort.Sort(sortValueDoc(d))
+ return d
}
// either a top-level function or a method function.
//
type FuncDoc struct {
- Doc string;
- Recv ast.Expr; // TODO(rsc): Would like string here
- Name string;
- Decl *ast.FuncDecl;
+ Doc string
+ Recv ast.Expr // TODO(rsc): Would like string here
+ Name string
+ Decl *ast.FuncDecl
}
type sortFuncDoc []*FuncDoc
-func (p sortFuncDoc) Len() int { return len(p) }
-func (p sortFuncDoc) Swap(i, j int) { p[i], p[j] = p[j], p[i] }
-func (p sortFuncDoc) Less(i, j int) bool { return p[i].Name < p[j].Name }
+func (p sortFuncDoc) Len() int { return len(p) }
+func (p sortFuncDoc) Swap(i, j int) { p[i], p[j] = p[j], p[i] }
+func (p sortFuncDoc) Less(i, j int) bool { return p[i].Name < p[j].Name }
func makeFuncDocs(m map[string]*ast.FuncDecl) []*FuncDoc {
- d := make([]*FuncDoc, len(m));
- i := 0;
+ d := make([]*FuncDoc, len(m))
+ i := 0
for _, f := range m {
- doc := new(FuncDoc);
- doc.Doc = CommentText(f.Doc);
- f.Doc = nil; // doc consumed - remove from ast.FuncDecl node
+ doc := new(FuncDoc)
+ doc.Doc = CommentText(f.Doc)
+ f.Doc = nil // doc consumed - remove from ast.FuncDecl node
if f.Recv != nil {
doc.Recv = f.Recv.Type
}
- doc.Name = f.Name.Value;
- doc.Decl = f;
- d[i] = doc;
- i++;
+ doc.Name = f.Name.Value
+ doc.Decl = f
+ d[i] = doc
+ i++
}
- sort.Sort(sortFuncDoc(d));
- return d;
+ sort.Sort(sortFuncDoc(d))
+ return d
}
// Factories is a sorted list of factory functions that return that type.
// Methods is a sorted list of method functions on that type.
type TypeDoc struct {
- Doc string;
- Type *ast.TypeSpec;
- Consts []*ValueDoc;
- Vars []*ValueDoc;
- Factories []*FuncDoc;
- Methods []*FuncDoc;
- Decl *ast.GenDecl;
- order int;
+ Doc string
+ Type *ast.TypeSpec
+ Consts []*ValueDoc
+ Vars []*ValueDoc
+ Factories []*FuncDoc
+ Methods []*FuncDoc
+ Decl *ast.GenDecl
+ order int
}
type sortTypeDoc []*TypeDoc
-func (p sortTypeDoc) Len() int { return len(p) }
-func (p sortTypeDoc) Swap(i, j int) { p[i], p[j] = p[j], p[i] }
+func (p sortTypeDoc) Len() int { return len(p) }
+func (p sortTypeDoc) Swap(i, j int) { p[i], p[j] = p[j], p[i] }
func (p sortTypeDoc) Less(i, j int) bool {
// sort by name
// pull blocks (name = "") up to top
if ni, nj := p[i].Type.Name.Value, p[j].Type.Name.Value; ni != nj {
return ni < nj
}
- return p[i].order < p[j].order;
+ return p[i].order < p[j].order
}
// blocks, but the doc extractor above has split them into
// individual declarations.
func (doc *docReader) makeTypeDocs(m map[string]*typeDoc) []*TypeDoc {
- d := make([]*TypeDoc, len(m));
- i := 0;
+ d := make([]*TypeDoc, len(m))
+ i := 0
for _, old := range m {
// all typeDocs should have a declaration associated with
// them after processing an entire package - be conservative
// and check
if decl := old.decl; decl != nil {
- typespec := decl.Specs[0].(*ast.TypeSpec);
- t := new(TypeDoc);
- doc := typespec.Doc;
- typespec.Doc = nil; // doc consumed - remove from ast.TypeSpec node
+ typespec := decl.Specs[0].(*ast.TypeSpec)
+ t := new(TypeDoc)
+ doc := typespec.Doc
+ typespec.Doc = nil // doc consumed - remove from ast.TypeSpec node
if doc == nil {
// no doc associated with the spec, use the declaration doc, if any
doc = decl.Doc
}
- decl.Doc = nil; // doc consumed - remove from ast.Decl node
- t.Doc = CommentText(doc);
- t.Type = typespec;
- t.Consts = makeValueDocs(old.values, token.CONST);
- t.Vars = makeValueDocs(old.values, token.VAR);
- t.Factories = makeFuncDocs(old.factories);
- t.Methods = makeFuncDocs(old.methods);
- t.Decl = old.decl;
- t.order = i;
- d[i] = t;
- i++;
+ decl.Doc = nil // doc consumed - remove from ast.Decl node
+ t.Doc = CommentText(doc)
+ t.Type = typespec
+ t.Consts = makeValueDocs(old.values, token.CONST)
+ t.Vars = makeValueDocs(old.values, token.VAR)
+ t.Factories = makeFuncDocs(old.factories)
+ t.Methods = makeFuncDocs(old.methods)
+ t.Decl = old.decl
+ t.order = i
+ d[i] = t
+ i++
} else {
// no corresponding type declaration found - move any associated
// values, factory functions, and methods back to the top-level
// file containing the explicit type declaration is missing or if
// an unqualified type name was used after a "." import)
// 1) move values
- doc.values.AppendVector(old.values);
+ doc.values.AppendVector(old.values)
// 2) move factory functions
for name, f := range old.factories {
doc.funcs[name] = f
}
}
}
- d = d[0:i]; // some types may have been ignored
- sort.Sort(sortTypeDoc(d));
- return d;
+ d = d[0:i] // some types may have been ignored
+ sort.Sort(sortTypeDoc(d))
+ return d
}
func makeBugDocs(v *vector.Vector) []string {
- d := make([]string, v.Len());
+ d := make([]string, v.Len())
for i := 0; i < v.Len(); i++ {
d[i] = CommentText(v.At(i).(*ast.CommentGroup))
}
- return d;
+ return d
}
// PackageDoc is the documentation for an entire package.
//
type PackageDoc struct {
- PackageName string;
- ImportPath string;
- FilePath string;
- Filenames []string;
- Doc string;
- Consts []*ValueDoc;
- Types []*TypeDoc;
- Vars []*ValueDoc;
- Funcs []*FuncDoc;
- Bugs []string;
+ PackageName string
+ ImportPath string
+ FilePath string
+ Filenames []string
+ Doc string
+ Consts []*ValueDoc
+ Types []*TypeDoc
+ Vars []*ValueDoc
+ Funcs []*FuncDoc
+ Bugs []string
}
// newDoc returns the accumulated documentation for the package.
//
func (doc *docReader) newDoc(importpath, filepath string, filenames []string) *PackageDoc {
- p := new(PackageDoc);
- p.PackageName = doc.pkgName;
- p.ImportPath = importpath;
- p.FilePath = filepath;
- sort.SortStrings(filenames);
- p.Filenames = filenames;
- p.Doc = CommentText(doc.doc);
+ p := new(PackageDoc)
+ p.PackageName = doc.pkgName
+ p.ImportPath = importpath
+ p.FilePath = filepath
+ sort.SortStrings(filenames)
+ p.Filenames = filenames
+ p.Doc = CommentText(doc.doc)
// makeTypeDocs may extend the list of doc.values and
// doc.funcs and thus must be called before any other
// function consuming those lists
- p.Types = doc.makeTypeDocs(doc.types);
- p.Consts = makeValueDocs(doc.values, token.CONST);
- p.Vars = makeValueDocs(doc.values, token.VAR);
- p.Funcs = makeFuncDocs(doc.funcs);
- p.Bugs = makeBugDocs(doc.bugs);
- return p;
+ p.Types = doc.makeTypeDocs(doc.types)
+ p.Consts = makeValueDocs(doc.values, token.CONST)
+ p.Vars = makeValueDocs(doc.values, token.VAR)
+ p.Funcs = makeFuncDocs(doc.funcs)
+ p.Bugs = makeBugDocs(doc.bugs)
+ return p
}
// Does s look like a regular expression?
func isRegexp(s string) bool {
- metachars := ".(|)*+?^$[]";
+ metachars := ".(|)*+?^$[]"
for _, c := range s {
for _, m := range metachars {
if c == m {
}
}
}
- return false;
+ return false
}
return true
}
}
- return false;
+ return false
}
}
}
}
- return false;
+ return false
}
func filterValueDocs(a []*ValueDoc, names []string) []*ValueDoc {
- w := 0;
+ w := 0
for _, vd := range a {
if matchDecl(vd.Decl, names) {
- a[w] = vd;
- w++;
+ a[w] = vd
+ w++
}
}
- return a[0:w];
+ return a[0:w]
}
func filterFuncDocs(a []*FuncDoc, names []string) []*FuncDoc {
- w := 0;
+ w := 0
for _, fd := range a {
if match(fd.Name, names) {
- a[w] = fd;
- w++;
+ a[w] = fd
+ w++
}
}
- return a[0:w];
+ return a[0:w]
}
func filterTypeDocs(a []*TypeDoc, names []string) []*TypeDoc {
- w := 0;
+ w := 0
for _, td := range a {
- n := 0; // number of matches
+ n := 0 // number of matches
if matchDecl(td.Decl, names) {
n = 1
} else {
// type name doesn't match, but we may have matching consts, vars, factories or methods
- td.Consts = filterValueDocs(td.Consts, names);
- td.Vars = filterValueDocs(td.Vars, names);
- td.Factories = filterFuncDocs(td.Factories, names);
- td.Methods = filterFuncDocs(td.Methods, names);
- n += len(td.Consts) + len(td.Vars) + len(td.Factories) + len(td.Methods);
+ td.Consts = filterValueDocs(td.Consts, names)
+ td.Vars = filterValueDocs(td.Vars, names)
+ td.Factories = filterFuncDocs(td.Factories, names)
+ td.Methods = filterFuncDocs(td.Methods, names)
+ n += len(td.Consts) + len(td.Vars) + len(td.Factories) + len(td.Methods)
}
if n > 0 {
- a[w] = td;
- w++;
+ a[w] = td
+ w++
}
}
- return a[0:w];
+ return a[0:w]
}
// TODO(r): maybe precompile the regexps.
//
func (p *PackageDoc) Filter(names []string) {
- p.Consts = filterValueDocs(p.Consts, names);
- p.Vars = filterValueDocs(p.Vars, names);
- p.Types = filterTypeDocs(p.Types, names);
- p.Funcs = filterFuncDocs(p.Funcs, names);
- p.Doc = ""; // don't show top-level package doc
+ p.Consts = filterValueDocs(p.Consts, names)
+ p.Vars = filterValueDocs(p.Vars, names)
+ p.Types = filterTypeDocs(p.Types, names)
+ p.Funcs = filterFuncDocs(p.Funcs, names)
+ p.Doc = "" // don't show top-level package doc
}
package parser
import (
- "bytes";
- "fmt";
- "go/ast";
- "go/scanner";
- "io";
- "io/ioutil";
- "os";
- pathutil "path";
- "strings";
+ "bytes"
+ "fmt"
+ "go/ast"
+ "go/scanner"
+ "io"
+ "io/ioutil"
+ "os"
+ pathutil "path"
+ "strings"
)
return s.Bytes(), nil
}
case io.Reader:
- var buf bytes.Buffer;
- _, err := io.Copy(&buf, s);
+ var buf bytes.Buffer
+ _, err := io.Copy(&buf, s)
if err != nil {
return nil, err
}
- return buf.Bytes(), nil;
+ return buf.Bytes(), nil
default:
return nil, os.ErrorString("invalid source")
}
}
- return ioutil.ReadFile(filename);
+ return ioutil.ReadFile(filename)
}
// may be nil or contain a partial AST.
//
func ParseExpr(filename string, src interface{}) (ast.Expr, os.Error) {
- data, err := readSource(filename, src);
+ data, err := readSource(filename, src)
if err != nil {
return nil, err
}
- var p parser;
- p.init(filename, data, 0);
- return p.parseExpr(), p.GetError(scanner.Sorted);
+ var p parser
+ p.init(filename, data, 0)
+ return p.parseExpr(), p.GetError(scanner.Sorted)
}
// list may be nil or contain partial ASTs.
//
func ParseStmtList(filename string, src interface{}) ([]ast.Stmt, os.Error) {
- data, err := readSource(filename, src);
+ data, err := readSource(filename, src)
if err != nil {
return nil, err
}
- var p parser;
- p.init(filename, data, 0);
- return p.parseStmtList(), p.GetError(scanner.Sorted);
+ var p parser
+ p.init(filename, data, 0)
+ return p.parseStmtList(), p.GetError(scanner.Sorted)
}
// list may be nil or contain partial ASTs.
//
func ParseDeclList(filename string, src interface{}) ([]ast.Decl, os.Error) {
- data, err := readSource(filename, src);
+ data, err := readSource(filename, src)
if err != nil {
return nil, err
}
- var p parser;
- p.init(filename, data, 0);
- return p.parseDeclList(), p.GetError(scanner.Sorted);
+ var p parser
+ p.init(filename, data, 0)
+ return p.parseDeclList(), p.GetError(scanner.Sorted)
}
// are returned via a scanner.ErrorList which is sorted by file position.
//
func ParseFile(filename string, src interface{}, mode uint) (*ast.File, os.Error) {
- data, err := readSource(filename, src);
+ data, err := readSource(filename, src)
if err != nil {
return nil, err
}
- var p parser;
- p.init(filename, data, mode);
- return p.parseFile(), p.GetError(scanner.NoMultiples);
+ var p parser
+ p.init(filename, data, mode)
+ return p.parseFile(), p.GetError(scanner.NoMultiples)
}
// flags that control the amount of source text parsed are ignored.
//
func ParsePkgFile(pkgname, filename string, mode uint) (*ast.File, os.Error) {
- src, err := ioutil.ReadFile(filename);
+ src, err := ioutil.ReadFile(filename)
if err != nil {
return nil, err
}
if pkgname != "" {
- prog, err := ParseFile(filename, src, PackageClauseOnly);
+ prog, err := ParseFile(filename, src, PackageClauseOnly)
if err != nil {
return nil, err
}
}
// ignore flags that control partial parsing
- return ParseFile(filename, src, mode&^(PackageClauseOnly|ImportsOnly));
+ return ParseFile(filename, src, mode&^(PackageClauseOnly|ImportsOnly))
}
// Mode flags that control the amount of source text parsed are ignored.
//
func ParsePackage(path string, filter func(*os.Dir) bool, mode uint) (*ast.Package, os.Error) {
- fd, err := os.Open(path, os.O_RDONLY, 0);
+ fd, err := os.Open(path, os.O_RDONLY, 0)
if err != nil {
return nil, err
}
- defer fd.Close();
+ defer fd.Close()
- list, err := fd.Readdir(-1);
+ list, err := fd.Readdir(-1)
if err != nil {
return nil, err
}
- name := "";
- files := make(map[string]*ast.File);
+ name := ""
+ files := make(map[string]*ast.File)
for i := 0; i < len(list); i++ {
- entry := &list[i];
+ entry := &list[i]
if filter == nil || filter(entry) {
- src, err := ParsePkgFile(name, pathutil.Join(path, entry.Name), mode);
+ src, err := ParsePkgFile(name, pathutil.Join(path, entry.Name), mode)
if err != nil {
return nil, err
}
- files[entry.Name] = src;
+ files[entry.Name] = src
if name == "" {
name = src.Name.Value
}
return nil, os.NewError(path + ": no package found")
}
- return &ast.Package{name, path, files}, nil;
+ return &ast.Package{name, path, files}, nil
}
package parser
import (
- "container/vector";
- "fmt";
- "go/ast";
- "go/scanner";
- "go/token";
+ "container/vector"
+ "fmt"
+ "go/ast"
+ "go/scanner"
+ "go/token"
)
// parser functionality.
//
const (
- PackageClauseOnly uint = 1 << iota; // parsing stops after package clause
- ImportsOnly; // parsing stops after import declarations
- ParseComments; // parse comments and add them to AST
- Trace; // print a trace of parsed productions
+ PackageClauseOnly uint = 1 << iota // parsing stops after package clause
+ ImportsOnly // parsing stops after import declarations
+ ParseComments // parse comments and add them to AST
+ Trace // print a trace of parsed productions
)
// The parser structure holds the parser's internal state.
type parser struct {
- scanner.ErrorVector;
- scanner scanner.Scanner;
+ scanner.ErrorVector
+ scanner scanner.Scanner
// Tracing/debugging
- mode uint; // parsing mode
- trace bool; // == (mode & Trace != 0)
- indent uint; // indentation used for tracing output
+ mode uint // parsing mode
+ trace bool // == (mode & Trace != 0)
+ indent uint // indentation used for tracing output
// Comments
- comments *ast.CommentGroup; // list of collected comments
- lastComment *ast.CommentGroup; // last comment in the comments list
- leadComment *ast.CommentGroup; // the last lead comment
- lineComment *ast.CommentGroup; // the last line comment
+ comments *ast.CommentGroup // list of collected comments
+ lastComment *ast.CommentGroup // last comment in the comments list
+ leadComment *ast.CommentGroup // the last lead comment
+ lineComment *ast.CommentGroup // the last line comment
// Next token
- pos token.Position; // token position
- tok token.Token; // one token look-ahead
- lit []byte; // token literal
+ pos token.Position // token position
+ tok token.Token // one token look-ahead
+ lit []byte // token literal
// Non-syntactic parser control
- exprLev int; // < 0: in control clause, >= 0: in expression
+ exprLev int // < 0: in control clause, >= 0: in expression
// Scopes
- pkgScope *ast.Scope;
- fileScope *ast.Scope;
- topScope *ast.Scope;
+ pkgScope *ast.Scope
+ fileScope *ast.Scope
+ topScope *ast.Scope
}
// scannerMode returns the scanner mode bits given the parser's mode bits.
func scannerMode(mode uint) uint {
- var m uint = scanner.InsertSemis;
+ var m uint = scanner.InsertSemis
if mode&ParseComments != 0 {
m |= scanner.ScanComments
}
- return m;
+ return m
}
func (p *parser) init(filename string, src []byte, mode uint) {
- p.scanner.Init(filename, src, p, scannerMode(mode));
- p.mode = mode;
- p.trace = mode&Trace != 0; // for convenience (p.trace is used frequently)
- p.next();
+ p.scanner.Init(filename, src, p, scannerMode(mode))
+ p.mode = mode
+ p.trace = mode&Trace != 0 // for convenience (p.trace is used frequently)
+ p.next()
}
func (p *parser) printTrace(a ...) {
const dots = ". . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . " +
- ". . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . ";
- const n = uint(len(dots));
- fmt.Printf("%5d:%3d: ", p.pos.Line, p.pos.Column);
- i := 2 * p.indent;
+ ". . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . "
+ const n = uint(len(dots))
+ fmt.Printf("%5d:%3d: ", p.pos.Line, p.pos.Column)
+ i := 2 * p.indent
for ; i > n; i -= n {
fmt.Print(dots)
}
- fmt.Print(dots[0:i]);
- fmt.Println(a);
+ fmt.Print(dots[0:i])
+ fmt.Println(a)
}
func trace(p *parser, msg string) *parser {
- p.printTrace(msg, "(");
- p.indent++;
- return p;
+ p.printTrace(msg, "(")
+ p.indent++
+ return p
}
// Usage pattern: defer un(trace(p, "..."));
func un(p *parser) {
- p.indent--;
- p.printTrace(")");
+ p.indent--
+ p.printTrace(")")
}
// very first token (p.pos.Line == 0) is not initialized (it
// is token.ILLEGAL), so don't print it .
if p.trace && p.pos.Line > 0 {
- s := p.tok.String();
+ s := p.tok.String()
switch {
case p.tok.IsLiteral():
p.printTrace(s, string(p.lit))
}
}
- p.pos, p.tok, p.lit = p.scanner.Scan();
+ p.pos, p.tok, p.lit = p.scanner.Scan()
}
// Consume a comment and return it and the line on which it ends.
func (p *parser) consumeComment() (comment *ast.Comment, endline int) {
// /*-style comments may end on a different line than where they start.
// Scan the comment for '\n' chars and adjust endline accordingly.
- endline = p.pos.Line;
+ endline = p.pos.Line
if p.lit[1] == '*' {
for _, b := range p.lit {
if b == '\n' {
}
}
- comment = &ast.Comment{p.pos, p.lit};
- p.next0();
+ comment = &ast.Comment{p.pos, p.lit}
+ p.next0()
- return;
+ return
}
// a comment group.
//
func (p *parser) consumeCommentGroup() int {
- var list vector.Vector;
- endline := p.pos.Line;
+ var list vector.Vector
+ endline := p.pos.Line
for p.tok == token.COMMENT && endline+1 >= p.pos.Line {
- var comment *ast.Comment;
- comment, endline = p.consumeComment();
- list.Push(comment);
+ var comment *ast.Comment
+ comment, endline = p.consumeComment()
+ list.Push(comment)
}
// convert list
- group := make([]*ast.Comment, list.Len());
+ group := make([]*ast.Comment, list.Len())
for i := 0; i < list.Len(); i++ {
group[i] = list.At(i).(*ast.Comment)
}
// add comment group to the comments list
- g := &ast.CommentGroup{group, nil};
+ g := &ast.CommentGroup{group, nil}
if p.lastComment != nil {
p.lastComment.Next = g
} else {
p.comments = g
}
- p.lastComment = g;
+ p.lastComment = g
- return endline;
+ return endline
}
// stored in the AST.
//
func (p *parser) next() {
- p.leadComment = nil;
- p.lineComment = nil;
- line := p.pos.Line; // current line
- p.next0();
+ p.leadComment = nil
+ p.lineComment = nil
+ line := p.pos.Line // current line
+ p.next0()
if p.tok == token.COMMENT {
if p.pos.Line == line {
// The comment is on same line as previous token; it
// cannot be a lead comment but may be a line comment.
- endline := p.consumeCommentGroup();
+ endline := p.consumeCommentGroup()
if p.pos.Line != endline {
// The next token is on a different line, thus
// the last comment group is a line comment.
}
// consume successor comments, if any
- endline := -1;
+ endline := -1
for p.tok == token.COMMENT {
endline = p.consumeCommentGroup()
}
func (p *parser) errorExpected(pos token.Position, msg string) {
- msg = "expected " + msg;
+ msg = "expected " + msg
if pos.Offset == p.pos.Offset {
// the error happened at the current position;
// make the error message more specific
- msg += ", found '" + p.tok.String() + "'";
+ msg += ", found '" + p.tok.String() + "'"
if p.tok.IsLiteral() {
msg += " " + string(p.lit)
}
}
- p.Error(pos, msg);
+ p.Error(pos, msg)
}
func (p *parser) expect(tok token.Token) token.Position {
- pos := p.pos;
+ pos := p.pos
if p.tok != tok {
p.errorExpected(pos, "'"+tok.String()+"'")
}
- p.next(); // make progress in any case
- return pos;
+ p.next() // make progress in any case
+ return pos
}
// Scope support
func openScope(p *parser) *parser {
- p.topScope = ast.NewScope(p.topScope);
- return p;
+ p.topScope = ast.NewScope(p.topScope)
+ return p
}
// Usage pattern: defer close(openScope(p));
-func close(p *parser) { p.topScope = p.topScope.Outer }
+func close(p *parser) { p.topScope = p.topScope.Outer }
func (p *parser) declare(ident *ast.Ident) {
func (p *parser) parseIdent() *ast.Ident {
if p.tok == token.IDENT {
- x := &ast.Ident{p.pos, string(p.lit)};
- p.next();
- return x;
+ x := &ast.Ident{p.pos, string(p.lit)}
+ p.next()
+ return x
}
- p.expect(token.IDENT); // use expect() error handling
- return &ast.Ident{p.pos, ""};
+ p.expect(token.IDENT) // use expect() error handling
+ return &ast.Ident{p.pos, ""}
}
defer un(trace(p, "IdentList"))
}
- var list vector.Vector;
- list.Push(p.parseIdent());
+ var list vector.Vector
+ list.Push(p.parseIdent())
for p.tok == token.COMMA {
- p.next();
- list.Push(p.parseIdent());
+ p.next()
+ list.Push(p.parseIdent())
}
// convert vector
- idents := make([]*ast.Ident, list.Len());
+ idents := make([]*ast.Ident, list.Len())
for i := 0; i < list.Len(); i++ {
idents[i] = list.At(i).(*ast.Ident)
}
- return idents;
+ return idents
}
func makeExprList(list *vector.Vector) []ast.Expr {
- exprs := make([]ast.Expr, list.Len());
+ exprs := make([]ast.Expr, list.Len())
for i := 0; i < list.Len(); i++ {
exprs[i] = list.At(i).(ast.Expr)
}
- return exprs;
+ return exprs
}
defer un(trace(p, "ExpressionList"))
}
- var list vector.Vector;
- list.Push(p.parseExpr());
+ var list vector.Vector
+ list.Push(p.parseExpr())
for p.tok == token.COMMA {
- p.next();
- list.Push(p.parseExpr());
+ p.next()
+ list.Push(p.parseExpr())
}
- return makeExprList(&list);
+ return makeExprList(&list)
}
defer un(trace(p, "Type"))
}
- typ := p.tryType();
+ typ := p.tryType()
if typ == nil {
- p.errorExpected(p.pos, "type");
- p.next(); // make progress
- return &ast.BadExpr{p.pos};
+ p.errorExpected(p.pos, "type")
+ p.next() // make progress
+ return &ast.BadExpr{p.pos}
}
- return typ;
+ return typ
}
defer un(trace(p, "QualifiedIdent"))
}
- var x ast.Expr = p.parseIdent();
+ var x ast.Expr = p.parseIdent()
if p.tok == token.PERIOD {
// first identifier is a package identifier
- p.next();
- sel := p.parseIdent();
- x = &ast.SelectorExpr{x, sel};
+ p.next()
+ sel := p.parseIdent()
+ x = &ast.SelectorExpr{x, sel}
}
- return x;
+ return x
}
defer un(trace(p, "TypeName"))
}
- return p.parseQualifiedIdent();
+ return p.parseQualifiedIdent()
}
defer un(trace(p, "ArrayType"))
}
- lbrack := p.expect(token.LBRACK);
- var len ast.Expr;
+ lbrack := p.expect(token.LBRACK)
+ var len ast.Expr
if ellipsisOk && p.tok == token.ELLIPSIS {
- len = &ast.Ellipsis{p.pos};
- p.next();
+ len = &ast.Ellipsis{p.pos}
+ p.next()
} else if p.tok != token.RBRACK {
len = p.parseExpr()
}
- p.expect(token.RBRACK);
- elt := p.parseType();
+ p.expect(token.RBRACK)
+ elt := p.parseType()
- return &ast.ArrayType{lbrack, len, elt};
+ return &ast.ArrayType{lbrack, len, elt}
}
func (p *parser) makeIdentList(list *vector.Vector) []*ast.Ident {
- idents := make([]*ast.Ident, list.Len());
+ idents := make([]*ast.Ident, list.Len())
for i := 0; i < list.Len(); i++ {
- ident, isIdent := list.At(i).(*ast.Ident);
+ ident, isIdent := list.At(i).(*ast.Ident)
if !isIdent {
- pos := list.At(i).(ast.Expr).Pos();
- p.errorExpected(pos, "identifier");
- idents[i] = &ast.Ident{pos, ""};
+ pos := list.At(i).(ast.Expr).Pos()
+ p.errorExpected(pos, "identifier")
+ idents[i] = &ast.Ident{pos, ""}
}
- idents[i] = ident;
+ idents[i] = ident
}
- return idents;
+ return idents
}
defer un(trace(p, "FieldDecl"))
}
- doc := p.leadComment;
+ doc := p.leadComment
// a list of identifiers looks like a list of type names
- var list vector.Vector;
+ var list vector.Vector
for {
// TODO(gri): do not allow ()'s here
- list.Push(p.parseType());
+ list.Push(p.parseType())
if p.tok != token.COMMA {
break
}
- p.next();
+ p.next()
}
// if we had a list of identifiers, it must be followed by a type
- typ := p.tryType();
+ typ := p.tryType()
// optional tag
- var tag []*ast.BasicLit;
+ var tag []*ast.BasicLit
if p.tok == token.STRING {
- x := &ast.BasicLit{p.pos, p.tok, p.lit};
- p.next();
- tag = []*ast.BasicLit{x};
+ x := &ast.BasicLit{p.pos, p.tok, p.lit}
+ p.next()
+ tag = []*ast.BasicLit{x}
}
// analyze case
- var idents []*ast.Ident;
+ var idents []*ast.Ident
if typ != nil {
// IdentifierList Type
idents = p.makeIdentList(&list)
// TODO(gri): check that this looks like a type
typ = list.At(0).(ast.Expr)
} else {
- p.errorExpected(p.pos, "anonymous field");
- typ = &ast.BadExpr{p.pos};
+ p.errorExpected(p.pos, "anonymous field")
+ typ = &ast.BadExpr{p.pos}
}
}
- p.expectSemi();
+ p.expectSemi()
- return &ast.Field{doc, idents, typ, tag, p.lineComment};
+ return &ast.Field{doc, idents, typ, tag, p.lineComment}
}
defer un(trace(p, "StructType"))
}
- pos := p.expect(token.STRUCT);
- lbrace := p.expect(token.LBRACE);
- var list vector.Vector;
+ pos := p.expect(token.STRUCT)
+ lbrace := p.expect(token.LBRACE)
+ var list vector.Vector
for p.tok == token.IDENT || p.tok == token.MUL {
list.Push(p.parseFieldDecl())
}
- rbrace := p.expect(token.RBRACE);
+ rbrace := p.expect(token.RBRACE)
// convert vector
- fields := make([]*ast.Field, list.Len());
+ fields := make([]*ast.Field, list.Len())
for i := list.Len() - 1; i >= 0; i-- {
fields[i] = list.At(i).(*ast.Field)
}
- return &ast.StructType{pos, lbrace, fields, rbrace, false};
+ return &ast.StructType{pos, lbrace, fields, rbrace, false}
}
defer un(trace(p, "PointerType"))
}
- star := p.expect(token.MUL);
- base := p.parseType();
+ star := p.expect(token.MUL)
+ base := p.parseType()
- return &ast.StarExpr{star, base};
+ return &ast.StarExpr{star, base}
}
func (p *parser) tryParameterType(ellipsisOk bool) ast.Expr {
if ellipsisOk && p.tok == token.ELLIPSIS {
- pos := p.pos;
- p.next();
+ pos := p.pos
+ p.next()
if p.tok != token.RPAREN {
// "..." always must be at the very end of a parameter list
p.Error(pos, "expected type, found '...'")
}
- return &ast.Ellipsis{pos};
+ return &ast.Ellipsis{pos}
}
- return p.tryType();
+ return p.tryType()
}
func (p *parser) parseParameterType(ellipsisOk bool) ast.Expr {
- typ := p.tryParameterType(ellipsisOk);
+ typ := p.tryParameterType(ellipsisOk)
if typ == nil {
- p.errorExpected(p.pos, "type");
- p.next(); // make progress
- typ = &ast.BadExpr{p.pos};
+ p.errorExpected(p.pos, "type")
+ p.next() // make progress
+ typ = &ast.BadExpr{p.pos}
}
- return typ;
+ return typ
}
}
// a list of identifiers looks like a list of type names
- var list vector.Vector;
+ var list vector.Vector
for {
// TODO(gri): do not allow ()'s here
- list.Push(p.parseParameterType(ellipsisOk));
+ list.Push(p.parseParameterType(ellipsisOk))
if p.tok != token.COMMA {
break
}
- p.next();
+ p.next()
}
// if we had a list of identifiers, it must be followed by a type
- typ := p.tryParameterType(ellipsisOk);
+ typ := p.tryParameterType(ellipsisOk)
- return &list, typ;
+ return &list, typ
}
defer un(trace(p, "ParameterList"))
}
- list, typ := p.parseParameterDecl(ellipsisOk);
+ list, typ := p.parseParameterDecl(ellipsisOk)
if typ != nil {
// IdentifierList Type
- idents := p.makeIdentList(list);
- list.Resize(0, 0);
- list.Push(&ast.Field{nil, idents, typ, nil, nil});
+ idents := p.makeIdentList(list)
+ list.Resize(0, 0)
+ list.Push(&ast.Field{nil, idents, typ, nil, nil})
if p.tok == token.COMMA {
p.next()
}
for p.tok != token.RPAREN && p.tok != token.EOF {
- idents := p.parseIdentList();
- typ := p.parseParameterType(ellipsisOk);
- list.Push(&ast.Field{nil, idents, typ, nil, nil});
+ idents := p.parseIdentList()
+ typ := p.parseParameterType(ellipsisOk)
+ list.Push(&ast.Field{nil, idents, typ, nil, nil})
if p.tok != token.COMMA {
break
}
- p.next();
+ p.next()
}
} else {
}
// convert list
- params := make([]*ast.Field, list.Len());
+ params := make([]*ast.Field, list.Len())
for i := 0; i < list.Len(); i++ {
params[i] = list.At(i).(*ast.Field)
}
- return params;
+ return params
}
defer un(trace(p, "Parameters"))
}
- var params []*ast.Field;
- p.expect(token.LPAREN);
+ var params []*ast.Field
+ p.expect(token.LPAREN)
if p.tok != token.RPAREN {
params = p.parseParameterList(ellipsisOk)
}
- p.expect(token.RPAREN);
+ p.expect(token.RPAREN)
- return params;
+ return params
}
defer un(trace(p, "Result"))
}
- var results []*ast.Field;
+ var results []*ast.Field
if p.tok == token.LPAREN {
results = p.parseParameters(false)
} else if p.tok != token.FUNC {
- typ := p.tryType();
+ typ := p.tryType()
if typ != nil {
- results = make([]*ast.Field, 1);
- results[0] = &ast.Field{Type: typ};
+ results = make([]*ast.Field, 1)
+ results[0] = &ast.Field{Type: typ}
}
}
- return results;
+ return results
}
defer un(trace(p, "Signature"))
}
- params = p.parseParameters(true);
- results = p.parseResult();
+ params = p.parseParameters(true)
+ results = p.parseResult()
- return;
+ return
}
defer un(trace(p, "FuncType"))
}
- pos := p.expect(token.FUNC);
- params, results := p.parseSignature();
+ pos := p.expect(token.FUNC)
+ params, results := p.parseSignature()
- return &ast.FuncType{pos, params, results};
+ return &ast.FuncType{pos, params, results}
}
defer un(trace(p, "MethodSpec"))
}
- doc := p.leadComment;
- var idents []*ast.Ident;
- var typ ast.Expr;
- x := p.parseQualifiedIdent();
+ doc := p.leadComment
+ var idents []*ast.Ident
+ var typ ast.Expr
+ x := p.parseQualifiedIdent()
if ident, isIdent := x.(*ast.Ident); isIdent && p.tok == token.LPAREN {
// method
- idents = []*ast.Ident{ident};
- params, results := p.parseSignature();
- typ = &ast.FuncType{noPos, params, results};
+ idents = []*ast.Ident{ident}
+ params, results := p.parseSignature()
+ typ = &ast.FuncType{noPos, params, results}
} else {
// embedded interface
typ = x
}
- p.expectSemi();
+ p.expectSemi()
- return &ast.Field{doc, idents, typ, nil, p.lineComment};
+ return &ast.Field{doc, idents, typ, nil, p.lineComment}
}
defer un(trace(p, "InterfaceType"))
}
- pos := p.expect(token.INTERFACE);
- lbrace := p.expect(token.LBRACE);
- var list vector.Vector;
+ pos := p.expect(token.INTERFACE)
+ lbrace := p.expect(token.LBRACE)
+ var list vector.Vector
for p.tok == token.IDENT {
list.Push(p.parseMethodSpec())
}
- rbrace := p.expect(token.RBRACE);
+ rbrace := p.expect(token.RBRACE)
// convert vector
- methods := make([]*ast.Field, list.Len());
+ methods := make([]*ast.Field, list.Len())
for i := list.Len() - 1; i >= 0; i-- {
methods[i] = list.At(i).(*ast.Field)
}
- return &ast.InterfaceType{pos, lbrace, methods, rbrace, false};
+ return &ast.InterfaceType{pos, lbrace, methods, rbrace, false}
}
defer un(trace(p, "MapType"))
}
- pos := p.expect(token.MAP);
- p.expect(token.LBRACK);
- key := p.parseType();
- p.expect(token.RBRACK);
- value := p.parseType();
+ pos := p.expect(token.MAP)
+ p.expect(token.LBRACK)
+ key := p.parseType()
+ p.expect(token.RBRACK)
+ value := p.parseType()
- return &ast.MapType{pos, key, value};
+ return &ast.MapType{pos, key, value}
}
defer un(trace(p, "ChanType"))
}
- pos := p.pos;
- dir := ast.SEND | ast.RECV;
+ pos := p.pos
+ dir := ast.SEND | ast.RECV
if p.tok == token.CHAN {
- p.next();
+ p.next()
if p.tok == token.ARROW {
- p.next();
- dir = ast.SEND;
+ p.next()
+ dir = ast.SEND
}
} else {
- p.expect(token.ARROW);
- p.expect(token.CHAN);
- dir = ast.RECV;
+ p.expect(token.ARROW)
+ p.expect(token.CHAN)
+ dir = ast.RECV
}
- value := p.parseType();
+ value := p.parseType()
- return &ast.ChanType{pos, dir, value};
+ return &ast.ChanType{pos, dir, value}
}
case token.CHAN, token.ARROW:
return p.parseChanType()
case token.LPAREN:
- lparen := p.pos;
- p.next();
- typ := p.parseType();
- rparen := p.expect(token.RPAREN);
- return &ast.ParenExpr{lparen, typ, rparen};
+ lparen := p.pos
+ p.next()
+ typ := p.parseType()
+ rparen := p.expect(token.RPAREN)
+ return &ast.ParenExpr{lparen, typ, rparen}
}
// no type found
- return nil;
+ return nil
}
-func (p *parser) tryType() ast.Expr { return p.tryRawType(false) }
+func (p *parser) tryType() ast.Expr { return p.tryRawType(false) }
// ----------------------------------------------------------------------------
// Blocks
func makeStmtList(list *vector.Vector) []ast.Stmt {
- stats := make([]ast.Stmt, list.Len());
+ stats := make([]ast.Stmt, list.Len())
for i := 0; i < list.Len(); i++ {
stats[i] = list.At(i).(ast.Stmt)
}
- return stats;
+ return stats
}
defer un(trace(p, "StatementList"))
}
- var list vector.Vector;
+ var list vector.Vector
for p.tok != token.CASE && p.tok != token.DEFAULT && p.tok != token.RBRACE && p.tok != token.EOF {
list.Push(p.parseStmt())
}
- return makeStmtList(&list);
+ return makeStmtList(&list)
}
defer un(trace(p, "BlockStmt"))
}
- defer close(openScope(p));
+ defer close(openScope(p))
- lbrace := p.expect(token.LBRACE);
- list := p.parseStmtList();
- rbrace := p.expect(token.RBRACE);
+ lbrace := p.expect(token.LBRACE)
+ list := p.parseStmtList()
+ rbrace := p.expect(token.RBRACE)
- return &ast.BlockStmt{lbrace, list, rbrace};
+ return &ast.BlockStmt{lbrace, list, rbrace}
}
defer un(trace(p, "FuncTypeOrLit"))
}
- typ := p.parseFuncType();
+ typ := p.parseFuncType()
if p.tok != token.LBRACE {
// function type only
return typ
}
- p.exprLev++;
- body := p.parseBlockStmt();
- p.exprLev--;
+ p.exprLev++
+ body := p.parseBlockStmt()
+ p.exprLev--
- return &ast.FuncLit{typ, body};
+ return &ast.FuncLit{typ, body}
}
return p.parseIdent()
case token.INT, token.FLOAT, token.CHAR, token.STRING:
- x := &ast.BasicLit{p.pos, p.tok, p.lit};
- p.next();
- return x;
+ x := &ast.BasicLit{p.pos, p.tok, p.lit}
+ p.next()
+ return x
case token.LPAREN:
- lparen := p.pos;
- p.next();
- p.exprLev++;
- x := p.parseExpr();
- p.exprLev--;
- rparen := p.expect(token.RPAREN);
- return &ast.ParenExpr{lparen, x, rparen};
+ lparen := p.pos
+ p.next()
+ p.exprLev++
+ x := p.parseExpr()
+ p.exprLev--
+ rparen := p.expect(token.RPAREN)
+ return &ast.ParenExpr{lparen, x, rparen}
case token.FUNC:
return p.parseFuncTypeOrLit()
default:
- t := p.tryRawType(true); // could be type for composite literal or conversion
+ t := p.tryRawType(true) // could be type for composite literal or conversion
if t != nil {
return t
}
}
- p.errorExpected(p.pos, "operand");
- p.next(); // make progress
- return &ast.BadExpr{p.pos};
+ p.errorExpected(p.pos, "operand")
+ p.next() // make progress
+ return &ast.BadExpr{p.pos}
}
defer un(trace(p, "SelectorOrTypeAssertion"))
}
- p.expect(token.PERIOD);
+ p.expect(token.PERIOD)
if p.tok == token.IDENT {
// selector
- sel := p.parseIdent();
- return &ast.SelectorExpr{x, sel};
+ sel := p.parseIdent()
+ return &ast.SelectorExpr{x, sel}
}
// type assertion
- p.expect(token.LPAREN);
- var typ ast.Expr;
+ p.expect(token.LPAREN)
+ var typ ast.Expr
if p.tok == token.TYPE {
// type switch: typ == nil
p.next()
} else {
typ = p.parseType()
}
- p.expect(token.RPAREN);
+ p.expect(token.RPAREN)
- return &ast.TypeAssertExpr{x, typ};
+ return &ast.TypeAssertExpr{x, typ}
}
defer un(trace(p, "IndexOrSlice"))
}
- p.expect(token.LBRACK);
- p.exprLev++;
- index := p.parseExpr();
+ p.expect(token.LBRACK)
+ p.exprLev++
+ index := p.parseExpr()
if p.tok == token.COLON {
- p.next();
- var end ast.Expr;
+ p.next()
+ var end ast.Expr
if p.tok != token.RBRACK {
end = p.parseExpr()
}
- x = &ast.SliceExpr{x, index, end};
+ x = &ast.SliceExpr{x, index, end}
} else {
x = &ast.IndexExpr{x, index}
}
- p.exprLev--;
- p.expect(token.RBRACK);
+ p.exprLev--
+ p.expect(token.RBRACK)
- return x;
+ return x
}
defer un(trace(p, "CallOrConversion"))
}
- lparen := p.expect(token.LPAREN);
- p.exprLev++;
- var list vector.Vector;
+ lparen := p.expect(token.LPAREN)
+ p.exprLev++
+ var list vector.Vector
for p.tok != token.RPAREN && p.tok != token.EOF {
- list.Push(p.parseExpr());
+ list.Push(p.parseExpr())
if p.tok != token.COMMA {
break
}
- p.next();
+ p.next()
}
- p.exprLev--;
- rparen := p.expect(token.RPAREN);
+ p.exprLev--
+ rparen := p.expect(token.RPAREN)
- return &ast.CallExpr{fun, lparen, makeExprList(&list), rparen};
+ return &ast.CallExpr{fun, lparen, makeExprList(&list), rparen}
}
defer un(trace(p, "Element"))
}
- x := p.parseExpr();
+ x := p.parseExpr()
if p.tok == token.COLON {
- colon := p.pos;
- p.next();
- x = &ast.KeyValueExpr{x, colon, p.parseExpr()};
+ colon := p.pos
+ p.next()
+ x = &ast.KeyValueExpr{x, colon, p.parseExpr()}
}
- return x;
+ return x
}
defer un(trace(p, "ElementList"))
}
- var list vector.Vector;
+ var list vector.Vector
for p.tok != token.RBRACE && p.tok != token.EOF {
- list.Push(p.parseElement());
+ list.Push(p.parseElement())
if p.tok != token.COMMA {
break
}
- p.next();
+ p.next()
}
- return makeExprList(&list);
+ return makeExprList(&list)
}
defer un(trace(p, "CompositeLit"))
}
- lbrace := p.expect(token.LBRACE);
- var elts []ast.Expr;
+ lbrace := p.expect(token.LBRACE)
+ var elts []ast.Expr
if p.tok != token.RBRACE {
elts = p.parseElementList()
}
- rbrace := p.expect(token.RBRACE);
- return &ast.CompositeLit{typ, lbrace, elts, rbrace};
+ rbrace := p.expect(token.RBRACE)
+ return &ast.CompositeLit{typ, lbrace, elts, rbrace}
}
case *ast.TypeAssertExpr:
if t.Type == nil {
// the form X.(type) is only allowed in type switch expressions
- p.errorExpected(x.Pos(), "expression");
- x = &ast.BadExpr{x.Pos()};
+ p.errorExpected(x.Pos(), "expression")
+ x = &ast.BadExpr{x.Pos()}
}
case *ast.CallExpr:
case *ast.StarExpr:
case *ast.UnaryExpr:
if t.Op == token.RANGE {
// the range operator is only allowed at the top of a for statement
- p.errorExpected(x.Pos(), "expression");
- x = &ast.BadExpr{x.Pos()};
+ p.errorExpected(x.Pos(), "expression")
+ x = &ast.BadExpr{x.Pos()}
}
case *ast.BinaryExpr:
default:
// all other nodes are not proper expressions
- p.errorExpected(x.Pos(), "expression");
- x = &ast.BadExpr{x.Pos()};
+ p.errorExpected(x.Pos(), "expression")
+ x = &ast.BadExpr{x.Pos()}
}
- return x;
+ return x
}
case *ast.BadExpr:
case *ast.Ident:
case *ast.ParenExpr:
- return isTypeName(t.X) // TODO(gri): should (TypeName) be illegal?
+ return isTypeName(t.X) // TODO(gri): should (TypeName) be illegal?
case *ast.SelectorExpr:
return isTypeName(t.X)
default:
- return false // all other nodes are not type names
+ return false // all other nodes are not type names
}
- return true;
+ return true
}
case *ast.StructType:
case *ast.MapType:
default:
- return false // all other nodes are not legal composite literal types
+ return false // all other nodes are not legal composite literal types
}
- return true;
+ return true
}
case *ast.UnaryExpr:
if t.Op == token.RANGE {
// the range operator is only allowed at the top of a for statement
- p.errorExpected(x.Pos(), "expression");
- x = &ast.BadExpr{x.Pos()};
+ p.errorExpected(x.Pos(), "expression")
+ x = &ast.BadExpr{x.Pos()}
}
case *ast.ArrayType:
if len, isEllipsis := t.Len.(*ast.Ellipsis); isEllipsis {
- p.Error(len.Pos(), "expected array length, found '...'");
- x = &ast.BadExpr{x.Pos()};
+ p.Error(len.Pos(), "expected array length, found '...'")
+ x = &ast.BadExpr{x.Pos()}
}
}
// all other nodes are expressions or types
- return x;
+ return x
}
defer un(trace(p, "PrimaryExpr"))
}
- x := p.parseOperand();
-L: for {
+ x := p.parseOperand()
+L: for {
switch p.tok {
case token.PERIOD:
x = p.parseSelectorOrTypeAssertion(p.checkExpr(x))
}
}
- return x;
+ return x
}
switch p.tok {
case token.ADD, token.SUB, token.NOT, token.XOR, token.ARROW, token.AND, token.RANGE:
- pos, op := p.pos, p.tok;
- p.next();
- x := p.parseUnaryExpr();
- return &ast.UnaryExpr{pos, op, p.checkExpr(x)};
+ pos, op := p.pos, p.tok
+ p.next()
+ x := p.parseUnaryExpr()
+ return &ast.UnaryExpr{pos, op, p.checkExpr(x)}
case token.MUL:
// unary "*" expression or pointer type
- pos := p.pos;
- p.next();
- x := p.parseUnaryExpr();
- return &ast.StarExpr{pos, p.checkExprOrType(x)};
+ pos := p.pos
+ p.next()
+ x := p.parseUnaryExpr()
+ return &ast.StarExpr{pos, p.checkExprOrType(x)}
}
- return p.parsePrimaryExpr();
+ return p.parsePrimaryExpr()
}
defer un(trace(p, "BinaryExpr"))
}
- x := p.parseUnaryExpr();
+ x := p.parseUnaryExpr()
for prec := p.tok.Precedence(); prec >= prec1; prec-- {
for p.tok.Precedence() == prec {
- pos, op := p.pos, p.tok;
- p.next();
- y := p.parseBinaryExpr(prec + 1);
- x = &ast.BinaryExpr{p.checkExpr(x), pos, op, p.checkExpr(y)};
+ pos, op := p.pos, p.tok
+ p.next()
+ y := p.parseBinaryExpr(prec + 1)
+ x = &ast.BinaryExpr{p.checkExpr(x), pos, op, p.checkExpr(y)}
}
}
- return x;
+ return x
}
defer un(trace(p, "Expression"))
}
- return p.parseBinaryExpr(token.LowestPrec + 1);
+ return p.parseBinaryExpr(token.LowestPrec + 1)
}
defer un(trace(p, "SimpleStmt"))
}
- x := p.parseExprList();
+ x := p.parseExprList()
switch p.tok {
case token.COLON:
// labeled statement
- p.next();
+ p.next()
if labelOk && len(x) == 1 {
if label, isIdent := x[0].(*ast.Ident); isIdent {
return &ast.LabeledStmt{label, p.parseStmt()}
}
}
- p.Error(x[0].Pos(), "illegal label declaration");
- return &ast.BadStmt{x[0].Pos()};
+ p.Error(x[0].Pos(), "illegal label declaration")
+ return &ast.BadStmt{x[0].Pos()}
case
token.DEFINE, token.ASSIGN, token.ADD_ASSIGN,
token.REM_ASSIGN, token.AND_ASSIGN, token.OR_ASSIGN,
token.XOR_ASSIGN, token.SHL_ASSIGN, token.SHR_ASSIGN, token.AND_NOT_ASSIGN:
// assignment statement
- pos, tok := p.pos, p.tok;
- p.next();
- y := p.parseExprList();
+ pos, tok := p.pos, p.tok
+ p.next()
+ y := p.parseExprList()
if len(x) > 1 && len(y) > 1 && len(x) != len(y) {
p.Error(x[0].Pos(), "arity of lhs doesn't match rhs")
}
- return &ast.AssignStmt{x, pos, tok, y};
+ return &ast.AssignStmt{x, pos, tok, y}
}
if len(x) > 1 {
if p.tok == token.INC || p.tok == token.DEC {
// increment or decrement
- s := &ast.IncDecStmt{x[0], p.tok};
- p.next(); // consume "++" or "--"
- return s;
+ s := &ast.IncDecStmt{x[0], p.tok}
+ p.next() // consume "++" or "--"
+ return s
}
// expression
- return &ast.ExprStmt{x[0]};
+ return &ast.ExprStmt{x[0]}
}
func (p *parser) parseCallExpr() *ast.CallExpr {
- x := p.parseExpr();
+ x := p.parseExpr()
if call, isCall := x.(*ast.CallExpr); isCall {
return call
}
- p.errorExpected(x.Pos(), "function/method call");
- return nil;
+ p.errorExpected(x.Pos(), "function/method call")
+ return nil
}
defer un(trace(p, "GoStmt"))
}
- pos := p.expect(token.GO);
- call := p.parseCallExpr();
- p.expectSemi();
+ pos := p.expect(token.GO)
+ call := p.parseCallExpr()
+ p.expectSemi()
if call == nil {
return &ast.BadStmt{pos}
}
- return &ast.GoStmt{pos, call};
+ return &ast.GoStmt{pos, call}
}
defer un(trace(p, "DeferStmt"))
}
- pos := p.expect(token.DEFER);
- call := p.parseCallExpr();
- p.expectSemi();
+ pos := p.expect(token.DEFER)
+ call := p.parseCallExpr()
+ p.expectSemi()
if call == nil {
return &ast.BadStmt{pos}
}
- return &ast.DeferStmt{pos, call};
+ return &ast.DeferStmt{pos, call}
}
defer un(trace(p, "ReturnStmt"))
}
- pos := p.pos;
- p.expect(token.RETURN);
- var x []ast.Expr;
+ pos := p.pos
+ p.expect(token.RETURN)
+ var x []ast.Expr
if p.tok != token.SEMICOLON && p.tok != token.RBRACE {
x = p.parseExprList()
}
- p.expectSemi();
+ p.expectSemi()
- return &ast.ReturnStmt{pos, x};
+ return &ast.ReturnStmt{pos, x}
}
defer un(trace(p, "BranchStmt"))
}
- s := &ast.BranchStmt{p.pos, tok, nil};
- p.expect(tok);
+ s := &ast.BranchStmt{p.pos, tok, nil}
+ p.expect(tok)
if tok != token.FALLTHROUGH && p.tok == token.IDENT {
s.Label = p.parseIdent()
}
- p.expectSemi();
+ p.expectSemi()
- return s;
+ return s
}
if es, isExpr := s.(*ast.ExprStmt); isExpr {
return p.checkExpr(es.X)
}
- p.Error(s.Pos(), "expected condition, found simple statement");
- return &ast.BadExpr{s.Pos()};
+ p.Error(s.Pos(), "expected condition, found simple statement")
+ return &ast.BadExpr{s.Pos()}
}
func (p *parser) parseControlClause(isForStmt bool) (s1, s2, s3 ast.Stmt) {
if p.tok != token.LBRACE {
- prevLev := p.exprLev;
- p.exprLev = -1;
+ prevLev := p.exprLev
+ p.exprLev = -1
if p.tok != token.SEMICOLON {
s1 = p.parseSimpleStmt(false)
}
if p.tok == token.SEMICOLON {
- p.next();
+ p.next()
if p.tok != token.LBRACE && p.tok != token.SEMICOLON {
s2 = p.parseSimpleStmt(false)
}
if isForStmt {
// for statements have a 3rd section
- p.expectSemi();
+ p.expectSemi()
if p.tok != token.LBRACE {
s3 = p.parseSimpleStmt(false)
}
s1, s2 = nil, s1
}
- p.exprLev = prevLev;
+ p.exprLev = prevLev
}
- return s1, s2, s3;
+ return s1, s2, s3
}
}
// IfStmt block
- defer close(openScope(p));
+ defer close(openScope(p))
- pos := p.expect(token.IF);
- s1, s2, _ := p.parseControlClause(false);
- body := p.parseBlockStmt();
- var else_ ast.Stmt;
+ pos := p.expect(token.IF)
+ s1, s2, _ := p.parseControlClause(false)
+ body := p.parseBlockStmt()
+ var else_ ast.Stmt
if p.tok == token.ELSE {
- p.next();
- else_ = p.parseStmt();
+ p.next()
+ else_ = p.parseStmt()
} else {
p.expectSemi()
}
- return &ast.IfStmt{pos, s1, p.makeExpr(s2), body, else_};
+ return &ast.IfStmt{pos, s1, p.makeExpr(s2), body, else_}
}
}
// CaseClause block
- defer close(openScope(p));
+ defer close(openScope(p))
// SwitchCase
- pos := p.pos;
- var x []ast.Expr;
+ pos := p.pos
+ var x []ast.Expr
if p.tok == token.CASE {
- p.next();
- x = p.parseExprList();
+ p.next()
+ x = p.parseExprList()
} else {
p.expect(token.DEFAULT)
}
- colon := p.expect(token.COLON);
- body := p.parseStmtList();
+ colon := p.expect(token.COLON)
+ body := p.parseStmtList()
- return &ast.CaseClause{pos, x, colon, body};
+ return &ast.CaseClause{pos, x, colon, body}
}
defer un(trace(p, "TypeList"))
}
- var list vector.Vector;
- list.Push(p.parseType());
+ var list vector.Vector
+ list.Push(p.parseType())
for p.tok == token.COMMA {
- p.next();
- list.Push(p.parseType());
+ p.next()
+ list.Push(p.parseType())
}
- return makeExprList(&list);
+ return makeExprList(&list)
}
}
// TypeCaseClause block
- defer close(openScope(p));
+ defer close(openScope(p))
// TypeSwitchCase
- pos := p.pos;
- var types []ast.Expr;
+ pos := p.pos
+ var types []ast.Expr
if p.tok == token.CASE {
- p.next();
- types = p.parseTypeList();
+ p.next()
+ types = p.parseTypeList()
} else {
p.expect(token.DEFAULT)
}
- colon := p.expect(token.COLON);
- body := p.parseStmtList();
+ colon := p.expect(token.COLON)
+ body := p.parseStmtList()
- return &ast.TypeCaseClause{pos, types, colon, body};
+ return &ast.TypeCaseClause{pos, types, colon, body}
}
}
if e, ok := s.(*ast.ExprStmt); ok {
if a, ok := e.X.(*ast.TypeAssertExpr); ok {
- return a.Type != nil // regular type assertion
+ return a.Type != nil // regular type assertion
}
- return true;
+ return true
}
- return false;
+ return false
}
}
// SwitchStmt block
- defer close(openScope(p));
+ defer close(openScope(p))
- pos := p.expect(token.SWITCH);
- s1, s2, _ := p.parseControlClause(false);
+ pos := p.expect(token.SWITCH)
+ s1, s2, _ := p.parseControlClause(false)
if isExprSwitch(s2) {
- lbrace := p.expect(token.LBRACE);
- var cases vector.Vector;
+ lbrace := p.expect(token.LBRACE)
+ var cases vector.Vector
for p.tok == token.CASE || p.tok == token.DEFAULT {
cases.Push(p.parseCaseClause())
}
- rbrace := p.expect(token.RBRACE);
- body := &ast.BlockStmt{lbrace, makeStmtList(&cases), rbrace};
- p.expectSemi();
- return &ast.SwitchStmt{pos, s1, p.makeExpr(s2), body};
+ rbrace := p.expect(token.RBRACE)
+ body := &ast.BlockStmt{lbrace, makeStmtList(&cases), rbrace}
+ p.expectSemi()
+ return &ast.SwitchStmt{pos, s1, p.makeExpr(s2), body}
}
// type switch
// TODO(gri): do all the checks!
- lbrace := p.expect(token.LBRACE);
- var cases vector.Vector;
+ lbrace := p.expect(token.LBRACE)
+ var cases vector.Vector
for p.tok == token.CASE || p.tok == token.DEFAULT {
cases.Push(p.parseTypeCaseClause())
}
- rbrace := p.expect(token.RBRACE);
- p.expectSemi();
- body := &ast.BlockStmt{lbrace, makeStmtList(&cases), rbrace};
- return &ast.TypeSwitchStmt{pos, s1, s2, body};
+ rbrace := p.expect(token.RBRACE)
+ p.expectSemi()
+ body := &ast.BlockStmt{lbrace, makeStmtList(&cases), rbrace}
+ return &ast.TypeSwitchStmt{pos, s1, s2, body}
}
}
// CommClause block
- defer close(openScope(p));
+ defer close(openScope(p))
// CommCase
- pos := p.pos;
- var tok token.Token;
- var lhs, rhs ast.Expr;
+ pos := p.pos
+ var tok token.Token
+ var lhs, rhs ast.Expr
if p.tok == token.CASE {
- p.next();
+ p.next()
if p.tok == token.ARROW {
// RecvExpr without assignment
rhs = p.parseExpr()
} else {
// SendExpr or RecvExpr
- rhs = p.parseExpr();
+ rhs = p.parseExpr()
if p.tok == token.ASSIGN || p.tok == token.DEFINE {
// RecvExpr with assignment
- tok = p.tok;
- p.next();
- lhs = rhs;
+ tok = p.tok
+ p.next()
+ lhs = rhs
if p.tok == token.ARROW {
rhs = p.parseExpr()
} else {
- p.expect(token.ARROW) // use expect() error handling
+ p.expect(token.ARROW) // use expect() error handling
}
}
// else SendExpr
p.expect(token.DEFAULT)
}
- colon := p.expect(token.COLON);
- body := p.parseStmtList();
+ colon := p.expect(token.COLON)
+ body := p.parseStmtList()
- return &ast.CommClause{pos, tok, lhs, rhs, colon, body};
+ return &ast.CommClause{pos, tok, lhs, rhs, colon, body}
}
defer un(trace(p, "SelectStmt"))
}
- pos := p.expect(token.SELECT);
- lbrace := p.expect(token.LBRACE);
- var cases vector.Vector;
+ pos := p.expect(token.SELECT)
+ lbrace := p.expect(token.LBRACE)
+ var cases vector.Vector
for p.tok == token.CASE || p.tok == token.DEFAULT {
cases.Push(p.parseCommClause())
}
- rbrace := p.expect(token.RBRACE);
- p.expectSemi();
- body := &ast.BlockStmt{lbrace, makeStmtList(&cases), rbrace};
+ rbrace := p.expect(token.RBRACE)
+ p.expectSemi()
+ body := &ast.BlockStmt{lbrace, makeStmtList(&cases), rbrace}
- return &ast.SelectStmt{pos, body};
+ return &ast.SelectStmt{pos, body}
}
}
// ForStmt block
- defer close(openScope(p));
+ defer close(openScope(p))
- pos := p.expect(token.FOR);
- s1, s2, s3 := p.parseControlClause(true);
- body := p.parseBlockStmt();
- p.expectSemi();
+ pos := p.expect(token.FOR)
+ s1, s2, s3 := p.parseControlClause(true)
+ body := p.parseBlockStmt()
+ p.expectSemi()
if as, isAssign := s2.(*ast.AssignStmt); isAssign {
// possibly a for statement with a range clause; check assignment operator
if as.Tok != token.ASSIGN && as.Tok != token.DEFINE {
- p.errorExpected(as.TokPos, "'=' or ':='");
- return &ast.BadStmt{pos};
+ p.errorExpected(as.TokPos, "'=' or ':='")
+ return &ast.BadStmt{pos}
}
// check lhs
- var key, value ast.Expr;
+ var key, value ast.Expr
switch len(as.Lhs) {
case 2:
- value = as.Lhs[1];
- fallthrough;
+ value = as.Lhs[1]
+ fallthrough
case 1:
key = as.Lhs[0]
default:
- p.errorExpected(as.Lhs[0].Pos(), "1 or 2 expressions");
- return &ast.BadStmt{pos};
+ p.errorExpected(as.Lhs[0].Pos(), "1 or 2 expressions")
+ return &ast.BadStmt{pos}
}
// check rhs
if len(as.Rhs) != 1 {
- p.errorExpected(as.Rhs[0].Pos(), "1 expressions");
- return &ast.BadStmt{pos};
+ p.errorExpected(as.Rhs[0].Pos(), "1 expressions")
+ return &ast.BadStmt{pos}
}
if rhs, isUnary := as.Rhs[0].(*ast.UnaryExpr); isUnary && rhs.Op == token.RANGE {
// rhs is range expression; check lhs
return &ast.RangeStmt{pos, key, value, as.TokPos, as.Tok, rhs.X, body}
} else {
- p.errorExpected(s2.Pos(), "range clause");
- return &ast.BadStmt{pos};
+ p.errorExpected(s2.Pos(), "range clause")
+ return &ast.BadStmt{pos}
}
} else {
// regular for statement
return &ast.ForStmt{pos, s1, p.makeExpr(s2), s3, body}
}
- panic(); // unreachable
- return nil;
+ panic() // unreachable
+ return nil
}
s = &ast.DeclStmt{p.parseDecl()}
case
// tokens that may start a top-level expression
- token.IDENT, token.INT, token.FLOAT, token.CHAR, token.STRING, token.FUNC, token.LPAREN, // operand
- token.LBRACK, token.STRUCT, // composite type
- token.MUL, token.AND, token.ARROW, token.ADD, token.SUB, token.XOR: // unary operators
- s = p.parseSimpleStmt(true);
+ token.IDENT, token.INT, token.FLOAT, token.CHAR, token.STRING, token.FUNC, token.LPAREN, // operand
+ token.LBRACK, token.STRUCT, // composite type
+ token.MUL, token.AND, token.ARROW, token.ADD, token.SUB, token.XOR: // unary operators
+ s = p.parseSimpleStmt(true)
// because of the required look-ahead, labeled statements are
// parsed by parseSimpleStmt - don't expect a semicolon after
// them
case token.BREAK, token.CONTINUE, token.GOTO, token.FALLTHROUGH:
s = p.parseBranchStmt(p.tok)
case token.LBRACE:
- s = p.parseBlockStmt();
- p.expectSemi();
+ s = p.parseBlockStmt()
+ p.expectSemi()
case token.IF:
s = p.parseIfStmt()
case token.SWITCH:
case token.FOR:
s = p.parseForStmt()
case token.SEMICOLON:
- p.next();
- fallthrough;
+ p.next()
+ fallthrough
case token.RBRACE:
// a semicolon may be omitted before a closing "}"
s = &ast.EmptyStmt{p.pos}
default:
// no statement found
- p.errorExpected(p.pos, "statement");
- p.next(); // make progress
- s = &ast.BadStmt{p.pos};
+ p.errorExpected(p.pos, "statement")
+ p.next() // make progress
+ s = &ast.BadStmt{p.pos}
}
- return;
+ return
}
defer un(trace(p, "ImportSpec"))
}
- var ident *ast.Ident;
+ var ident *ast.Ident
if p.tok == token.PERIOD {
- ident = &ast.Ident{p.pos, "."};
- p.next();
+ ident = &ast.Ident{p.pos, "."}
+ p.next()
} else if p.tok == token.IDENT {
ident = p.parseIdent()
}
- var path []*ast.BasicLit;
+ var path []*ast.BasicLit
if p.tok == token.STRING {
- x := &ast.BasicLit{p.pos, p.tok, p.lit};
- p.next();
- path = []*ast.BasicLit{x};
+ x := &ast.BasicLit{p.pos, p.tok, p.lit}
+ p.next()
+ path = []*ast.BasicLit{x}
} else {
- p.expect(token.STRING) // use expect() error handling
+ p.expect(token.STRING) // use expect() error handling
}
- p.expectSemi();
+ p.expectSemi()
- return &ast.ImportSpec{doc, ident, path, p.lineComment};
+ return &ast.ImportSpec{doc, ident, path, p.lineComment}
}
defer un(trace(p, "ConstSpec"))
}
- idents := p.parseIdentList();
- typ := p.tryType();
- var values []ast.Expr;
+ idents := p.parseIdentList()
+ typ := p.tryType()
+ var values []ast.Expr
if typ != nil || p.tok == token.ASSIGN {
- p.expect(token.ASSIGN);
- values = p.parseExprList();
+ p.expect(token.ASSIGN)
+ values = p.parseExprList()
}
- p.expectSemi();
+ p.expectSemi()
- return &ast.ValueSpec{doc, idents, typ, values, p.lineComment};
+ return &ast.ValueSpec{doc, idents, typ, values, p.lineComment}
}
defer un(trace(p, "TypeSpec"))
}
- ident := p.parseIdent();
- typ := p.parseType();
- p.expectSemi();
+ ident := p.parseIdent()
+ typ := p.parseType()
+ p.expectSemi()
- return &ast.TypeSpec{doc, ident, typ, p.lineComment};
+ return &ast.TypeSpec{doc, ident, typ, p.lineComment}
}
defer un(trace(p, "VarSpec"))
}
- idents := p.parseIdentList();
- typ := p.tryType();
- var values []ast.Expr;
+ idents := p.parseIdentList()
+ typ := p.tryType()
+ var values []ast.Expr
if typ == nil || p.tok == token.ASSIGN {
- p.expect(token.ASSIGN);
- values = p.parseExprList();
+ p.expect(token.ASSIGN)
+ values = p.parseExprList()
}
- p.expectSemi();
+ p.expectSemi()
- return &ast.ValueSpec{doc, idents, typ, values, p.lineComment};
+ return &ast.ValueSpec{doc, idents, typ, values, p.lineComment}
}
defer un(trace(p, keyword.String()+"Decl"))
}
- doc := p.leadComment;
- pos := p.expect(keyword);
- var lparen, rparen token.Position;
- var list vector.Vector;
+ doc := p.leadComment
+ pos := p.expect(keyword)
+ var lparen, rparen token.Position
+ var list vector.Vector
if p.tok == token.LPAREN {
- lparen = p.pos;
- p.next();
+ lparen = p.pos
+ p.next()
for p.tok != token.RPAREN && p.tok != token.EOF {
list.Push(f(p, p.leadComment))
}
- rparen = p.expect(token.RPAREN);
- p.expectSemi();
+ rparen = p.expect(token.RPAREN)
+ p.expectSemi()
} else {
list.Push(f(p, nil))
}
// convert vector
- specs := make([]ast.Spec, list.Len());
+ specs := make([]ast.Spec, list.Len())
for i := 0; i < list.Len(); i++ {
specs[i] = list.At(i).(ast.Spec)
}
- return &ast.GenDecl{doc, pos, keyword, lparen, specs, rparen};
+ return &ast.GenDecl{doc, pos, keyword, lparen, specs, rparen}
}
defer un(trace(p, "Receiver"))
}
- pos := p.pos;
- par := p.parseParameters(false);
+ pos := p.pos
+ par := p.parseParameters(false)
// must have exactly one receiver
if len(par) != 1 || len(par) == 1 && len(par[0].Names) > 1 {
- p.errorExpected(pos, "exactly one receiver");
- return &ast.Field{Type: &ast.BadExpr{noPos}};
+ p.errorExpected(pos, "exactly one receiver")
+ return &ast.Field{Type: &ast.BadExpr{noPos}}
}
- recv := par[0];
+ recv := par[0]
// recv type must be TypeName or *TypeName
- base := recv.Type;
+ base := recv.Type
if ptr, isPtr := base.(*ast.StarExpr); isPtr {
base = ptr.X
}
p.errorExpected(base.Pos(), "type name")
}
- return recv;
+ return recv
}
defer un(trace(p, "FunctionDecl"))
}
- doc := p.leadComment;
- pos := p.expect(token.FUNC);
+ doc := p.leadComment
+ pos := p.expect(token.FUNC)
- var recv *ast.Field;
+ var recv *ast.Field
if p.tok == token.LPAREN {
recv = p.parseReceiver()
}
- ident := p.parseIdent();
- params, results := p.parseSignature();
+ ident := p.parseIdent()
+ params, results := p.parseSignature()
- var body *ast.BlockStmt;
+ var body *ast.BlockStmt
if p.tok == token.LBRACE {
body = p.parseBlockStmt()
}
- p.expectSemi();
+ p.expectSemi()
- return &ast.FuncDecl{doc, recv, ident, &ast.FuncType{pos, params, results}, body};
+ return &ast.FuncDecl{doc, recv, ident, &ast.FuncType{pos, params, results}, body}
}
defer un(trace(p, "Declaration"))
}
- var f parseSpecFunction;
+ var f parseSpecFunction
switch p.tok {
case token.CONST:
f = parseConstSpec
return p.parseFunctionDecl()
default:
- pos := p.pos;
- p.errorExpected(pos, "declaration");
- decl := &ast.BadDecl{pos};
- p.next(); // make progress in any case
- return decl;
+ pos := p.pos
+ p.errorExpected(pos, "declaration")
+ decl := &ast.BadDecl{pos}
+ p.next() // make progress in any case
+ return decl
}
- return p.parseGenDecl(p.tok, f);
+ return p.parseGenDecl(p.tok, f)
}
defer un(trace(p, "DeclList"))
}
- var list vector.Vector;
+ var list vector.Vector
for p.tok != token.EOF {
list.Push(p.parseDecl())
}
// convert vector
- decls := make([]ast.Decl, list.Len());
+ decls := make([]ast.Decl, list.Len())
for i := 0; i < list.Len(); i++ {
decls[i] = list.At(i).(ast.Decl)
}
- return decls;
+ return decls
}
}
// file block
- defer close(openScope(p));
+ defer close(openScope(p))
// package clause
- doc := p.leadComment;
- pos := p.expect(token.PACKAGE);
- ident := p.parseIdent();
- p.expectSemi();
+ doc := p.leadComment
+ pos := p.expect(token.PACKAGE)
+ ident := p.parseIdent()
+ p.expectSemi()
- var decls []ast.Decl;
+ var decls []ast.Decl
// Don't bother parsing the rest if we had errors already.
// Likely not a Go source file at all.
if p.ErrorCount() == 0 && p.mode&PackageClauseOnly == 0 {
// import decls
- var list vector.Vector;
+ var list vector.Vector
for p.tok == token.IMPORT {
list.Push(p.parseGenDecl(token.IMPORT, parseImportSpec))
}
}
// convert declaration list
- decls = make([]ast.Decl, list.Len());
+ decls = make([]ast.Decl, list.Len())
for i := 0; i < list.Len(); i++ {
decls[i] = list.At(i).(ast.Decl)
}
}
- return &ast.File{doc, pos, ident, decls, p.comments};
+ return &ast.File{doc, pos, ident, decls, p.comments}
}
package parser
import (
- "os";
- "testing";
+ "os"
+ "testing"
)
func TestParseIllegalInputs(t *testing.T) {
for _, src := range illegalInputs {
- _, err := ParseFile("", src, 0);
+ _, err := ParseFile("", src, 0)
if err == nil {
t.Errorf("ParseFile(%v) should have failed", src)
}
func TestParseValidPrograms(t *testing.T) {
for _, src := range validPrograms {
- _, err := ParseFile("", src, 0);
+ _, err := ParseFile("", src, 0)
if err != nil {
t.Errorf("ParseFile(%q): %v", src, err)
}
func TestParse3(t *testing.T) {
for _, filename := range validFiles {
- _, err := ParseFile(filename, nil, 0);
+ _, err := ParseFile(filename, nil, 0)
if err != nil {
t.Errorf("ParseFile(%s): %v", filename, err)
}
default:
return false
}
- return true;
+ return true
}
-func dirFilter(d *os.Dir) bool { return nameFilter(d.Name) }
+func dirFilter(d *os.Dir) bool { return nameFilter(d.Name) }
func TestParse4(t *testing.T) {
- path := ".";
- pkg, err := ParsePackage(path, dirFilter, 0);
+ path := "."
+ pkg, err := ParsePackage(path, dirFilter, 0)
if err != nil {
t.Fatalf("ParsePackage(%s): %v", path, err)
}
package printer
import (
- "bytes";
- "go/ast";
- "go/token";
+ "bytes"
+ "go/ast"
+ "go/token"
)
// Disabled formatting - enable eventually and remove the flag.
const (
- compositeLitBlank = false;
+ compositeLitBlank = false
)
// TODO(gri): Reconsider signature (provide position instead of line)
//
func (p *printer) linebreak(line, min, max int, ws whiteSpace, newSection bool) (printedBreak bool) {
- n := line - p.pos.Line;
+ n := line - p.pos.Line
switch {
case n < min:
n = min
}
if n > 0 {
- p.print(ws);
+ p.print(ws)
if newSection {
- p.print(formfeed);
- n--;
- printedBreak = true;
+ p.print(formfeed)
+ n--
+ printedBreak = true
}
}
for ; n > 0; n-- {
- p.print(newline);
- printedBreak = true;
+ p.print(newline)
+ printedBreak = true
}
- return;
+ return
}
// Print a list of individual comments.
func (p *printer) commentList(list []*ast.Comment) {
for i, c := range list {
- t := c.Text;
+ t := c.Text
// TODO(gri): this needs to be styled like normal comments
- p.print(c.Pos(), t);
+ p.print(c.Pos(), t)
if t[1] == '/' && i+1 < len(list) {
//-style comment which is not at the end; print a newline
p.print(newline)
func (p *printer) leadComment(d *ast.CommentGroup) {
// Ignore the comment if we have comments interspersed (p.comment != nil).
if p.comment == nil && d != nil {
- p.commentList(d.List);
- p.print(newline);
+ p.commentList(d.List)
+ p.print(newline)
}
}
func (p *printer) lineComment(d *ast.CommentGroup) {
// Ignore the comment if we have comments interspersed (p.comment != nil).
if p.comment == nil && d != nil {
- p.print(vtab);
- p.commentList(d.List);
+ p.print(vtab)
+ p.commentList(d.List)
}
}
// Sets multiLine to true if the identifier list spans multiple lines.
func (p *printer) identList(list []*ast.Ident, multiLine *bool) {
// convert into an expression list so we can re-use exprList formatting
- xlist := make([]ast.Expr, len(list));
+ xlist := make([]ast.Expr, len(list))
for i, x := range list {
xlist[i] = x
}
- p.exprList(noPos, xlist, 1, commaSep, multiLine);
+ p.exprList(noPos, xlist, 1, commaSep, multiLine)
}
// Sets multiLine to true if the string list spans multiple lines.
func (p *printer) stringList(list []*ast.BasicLit, multiLine *bool) {
// convert into an expression list so we can re-use exprList formatting
- xlist := make([]ast.Expr, len(list));
+ xlist := make([]ast.Expr, len(list))
for i, x := range list {
xlist[i] = x
}
- p.exprList(noPos, xlist, 1, plusSep, multiLine);
+ p.exprList(noPos, xlist, 1, plusSep, multiLine)
}
type exprListMode uint
const (
- blankStart exprListMode = 1 << iota; // print a blank before a non-empty list
- blankEnd; // print a blank after a non-empty list
- plusSep; // elements are separared by + operators
- commaSep; // elements are separated by commas
- commaTerm; // elements are terminated by comma
- noIndent; // no extra indentation in multi-line lists
+ blankStart exprListMode = 1 << iota // print a blank before a non-empty list
+ blankEnd // print a blank after a non-empty list
+ plusSep // elements are separared by + operators
+ commaSep // elements are separated by commas
+ commaTerm // elements are terminated by comma
+ noIndent // no extra indentation in multi-line lists
)
// some reasonable grace period (12/11/09).
func (p *printer) beforeComment(pos token.Position) token.Position {
if p.comment != nil {
- p := p.comment.List[0].Position;
+ p := p.comment.List[0].Position
if !pos.IsValid() || pos.Offset > p.Offset {
return p
}
}
- return pos;
+ return pos
}
// TODO(gri): endLine may be incorrect as it is really the beginning
// of the last list entry. There may be only one, very long
// entry in which case line == endLine.
- line := list[0].Pos().Line;
- endLine := list[len(list)-1].Pos().Line;
+ line := list[0].Pos().Line
+ endLine := list[len(list)-1].Pos().Line
if prev.IsValid() && prev.Line == line && line == endLine {
// all list entries on a single line
if mode&commaSep != 0 {
p.print(token.COMMA)
}
- p.print(blank);
+ p.print(blank)
}
- p.expr0(x, depth, multiLine);
+ p.expr0(x, depth, multiLine)
}
if mode&blankEnd != 0 {
p.print(blank)
}
- return;
+ return
}
// list entries span multiple lines;
// don't add extra indentation if noIndent is set;
// i.e., pretend that the first line is already indented
- ws := ignore;
+ ws := ignore
if mode&noIndent == 0 {
ws = indent
}
if prev.IsValid() && prev.Line < line && p.linebreak(line, 1, 2, ws, true) {
- ws = ignore;
- *multiLine = true;
+ ws = ignore
+ *multiLine = true
}
for i, x := range list {
- prev := line;
- line = x.Pos().Line;
+ prev := line
+ line = x.Pos().Line
if i > 0 {
if mode&plusSep != 0 {
p.print(blank, p.beforeComment(noPos), token.ADD)
}
if prev < line && prev > 0 && line > 0 {
if p.linebreak(line, 1, 2, ws, true) {
- ws = ignore;
- *multiLine = true;
+ ws = ignore
+ *multiLine = true
}
} else {
p.print(blank)
}
}
- p.expr0(x, depth, multiLine);
+ p.expr0(x, depth, multiLine)
}
if mode&commaTerm != 0 {
- p.print(token.COMMA);
+ p.print(token.COMMA)
if ws == ignore && mode&noIndent == 0 {
// unindent if we indented
p.print(unindent)
}
- p.print(formfeed); // terminating comma needs a line break to look good
- return;
+ p.print(formfeed) // terminating comma needs a line break to look good
+ return
}
if mode&blankEnd != 0 {
// Sets multiLine to true if the the parameter list spans multiple lines.
func (p *printer) parameters(list []*ast.Field, multiLine *bool) {
- p.print(token.LPAREN);
+ p.print(token.LPAREN)
if len(list) > 0 {
for i, par := range list {
if i > 0 {
p.print(token.COMMA, blank)
}
if len(par.Names) > 0 {
- p.identList(par.Names, multiLine);
- p.print(blank);
+ p.identList(par.Names, multiLine)
+ p.print(blank)
}
- p.expr(par.Type, multiLine);
+ p.expr(par.Type, multiLine)
}
}
- p.print(token.RPAREN);
+ p.print(token.RPAREN)
}
// Returns true if a separating semicolon is optional.
// Sets multiLine to true if the signature spans multiple lines.
func (p *printer) signature(params, result []*ast.Field, multiLine *bool) (optSemi bool) {
- p.parameters(params, multiLine);
+ p.parameters(params, multiLine)
if result != nil {
- p.print(blank);
+ p.print(blank)
if len(result) == 1 && result[0].Names == nil {
// single anonymous result; no ()'s unless it's a function type
- f := result[0];
+ f := result[0]
if _, isFtyp := f.Type.(*ast.FuncType); !isFtyp {
- optSemi = p.expr(f.Type, multiLine);
- return;
+ optSemi = p.expr(f.Type, multiLine)
+ return
}
}
- p.parameters(result, multiLine);
+ p.parameters(result, multiLine)
}
- return;
+ return
}
func identListSize(list []*ast.Ident, maxSize int) (size int) {
for i, x := range list {
if i > 0 {
- size += 2 // ", "
+ size += 2 // ", "
}
- size += len(x.Value);
+ size += len(x.Value)
if size >= maxSize {
break
}
}
- return;
+ return
}
func (p *printer) isOneLineFieldList(list []*ast.Field) bool {
if len(list) != 1 {
- return false // allow only one field
+ return false // allow only one field
}
- f := list[0];
+ f := list[0]
if f.Tag != nil || f.Comment != nil {
- return false // don't allow tags or comments
+ return false // don't allow tags or comments
}
// only name(s) and type
- const maxSize = 30; // adjust as appropriate, this is an approximate value
- namesSize := identListSize(f.Names, maxSize);
+ const maxSize = 30 // adjust as appropriate, this is an approximate value
+ namesSize := identListSize(f.Names, maxSize)
if namesSize > 0 {
- namesSize = 1 // blank between names and types
+ namesSize = 1 // blank between names and types
}
- typeSize := p.nodeSize(f.Type, maxSize);
- return namesSize+typeSize <= maxSize;
+ typeSize := p.nodeSize(f.Type, maxSize)
+ return namesSize+typeSize <= maxSize
}
// possibly a one-line struct/interface
if len(list) == 0 {
// no blank between keyword and {} in this case
- p.print(lbrace, token.LBRACE, rbrace, token.RBRACE);
- return;
+ p.print(lbrace, token.LBRACE, rbrace, token.RBRACE)
+ return
} else if ctxt&(compositeLit|structType) == compositeLit|structType &&
- p.isOneLineFieldList(list) { // for now ignore interfaces
+ p.isOneLineFieldList(list) { // for now ignore interfaces
// small enough - print on one line
// (don't use identList and ignore source line breaks)
- p.print(lbrace, token.LBRACE, blank);
- f := list[0];
+ p.print(lbrace, token.LBRACE, blank)
+ f := list[0]
for i, x := range f.Names {
if i > 0 {
p.print(token.COMMA, blank)
}
- p.expr(x, ignoreMultiLine);
+ p.expr(x, ignoreMultiLine)
}
if len(f.Names) > 0 {
p.print(blank)
}
- p.expr(f.Type, ignoreMultiLine);
- p.print(blank, rbrace, token.RBRACE);
- return;
+ p.expr(f.Type, ignoreMultiLine)
+ p.print(blank, rbrace, token.RBRACE)
+ return
}
}
// at least one entry or incomplete
- p.print(blank, lbrace, token.LBRACE, indent, formfeed);
+ p.print(blank, lbrace, token.LBRACE, indent, formfeed)
if ctxt&structType != 0 {
- sep := vtab;
+ sep := vtab
if len(list) == 1 {
sep = blank
}
- var ml bool;
+ var ml bool
for i, f := range list {
if i > 0 {
p.linebreak(f.Pos().Line, 1, 2, ignore, ml)
}
- ml = false;
- extraTabs := 0;
- p.leadComment(f.Doc);
+ ml = false
+ extraTabs := 0
+ p.leadComment(f.Doc)
if len(f.Names) > 0 {
// named fields
- p.identList(f.Names, &ml);
- p.print(sep);
- p.expr(f.Type, &ml);
- extraTabs = 1;
+ p.identList(f.Names, &ml)
+ p.print(sep)
+ p.expr(f.Type, &ml)
+ extraTabs = 1
} else {
// anonymous field
- p.expr(f.Type, &ml);
- extraTabs = 2;
+ p.expr(f.Type, &ml)
+ extraTabs = 2
}
if f.Tag != nil {
if len(f.Names) > 0 && sep == vtab {
p.print(sep)
}
- p.print(sep);
- p.expr(&ast.StringList{f.Tag}, &ml);
- extraTabs = 0;
+ p.print(sep)
+ p.expr(&ast.StringList{f.Tag}, &ml)
+ extraTabs = 0
}
if p.Mode&NoSemis == 0 {
p.print(token.SEMICOLON)
for ; extraTabs > 0; extraTabs-- {
p.print(vtab)
}
- p.lineComment(f.Comment);
+ p.lineComment(f.Comment)
}
}
if isIncomplete {
p.print(formfeed)
}
// TODO(gri): this needs to be styled like normal comments
- p.print("// contains unexported fields");
+ p.print("// contains unexported fields")
}
- } else { // interface
+ } else { // interface
- var ml bool;
+ var ml bool
for i, f := range list {
if i > 0 {
p.linebreak(f.Pos().Line, 1, 2, ignore, ml)
}
- ml = false;
- p.leadComment(f.Doc);
+ ml = false
+ p.leadComment(f.Doc)
if ftyp, isFtyp := f.Type.(*ast.FuncType); isFtyp {
// method
- p.expr(f.Names[0], &ml);
- p.signature(ftyp.Params, ftyp.Results, &ml);
+ p.expr(f.Names[0], &ml)
+ p.signature(ftyp.Params, ftyp.Results, &ml)
} else {
// embedded interface
p.expr(f.Type, &ml)
if p.Mode&NoSemis == 0 {
p.print(token.SEMICOLON)
}
- p.lineComment(f.Comment);
+ p.lineComment(f.Comment)
}
if isIncomplete {
if len(list) > 0 {
p.print(formfeed)
}
// TODO(gri): this needs to be styled like normal comments
- p.print("// contains unexported methods");
+ p.print("// contains unexported methods")
}
}
- p.print(unindent, formfeed, rbrace, token.RBRACE);
+ p.print(unindent, formfeed, rbrace, token.RBRACE)
}
type exprContext uint
const (
- compositeLit = 1 << iota;
- structType;
+ compositeLit = 1 << iota
+ structType
)
// pretend this is an *ast.ParenExpr and do nothing.
break
}
- h5, h6, mp := walkBinary(l);
- has5 = has5 || h5;
- has6 = has6 || h6;
+ h5, h6, mp := walkBinary(l)
+ has5 = has5 || h5
+ has6 = has6 || h6
if maxProblem < mp {
maxProblem = mp
}
// pretend this is an *ast.ParenExpr and do nothing.
break
}
- h5, h6, mp := walkBinary(r);
- has5 = has5 || h5;
- has6 = has6 || h6;
+ h5, h6, mp := walkBinary(r)
+ has5 = has5 || h5
+ has6 = has6 || h6
if maxProblem < mp {
maxProblem = mp
}
}
}
}
- return;
+ return
}
func cutoff(e *ast.BinaryExpr, depth int) int {
- has5, has6, maxProblem := walkBinary(e);
+ has5, has6, maxProblem := walkBinary(e)
if maxProblem > 0 {
return maxProblem + 1
}
if depth == 1 {
return 6
}
- return 5;
+ return 5
}
if depth == 1 {
return 7
}
- return 5;
+ return 5
}
func diffPrec(expr ast.Expr, prec int) int {
- x, ok := expr.(*ast.BinaryExpr);
+ x, ok := expr.(*ast.BinaryExpr)
if !ok || prec != x.Op.Precedence() {
return 1
}
- return 0;
+ return 0
}
//
// Sets multiLine to true if the binary expression spans multiple lines.
func (p *printer) binaryExpr(x *ast.BinaryExpr, prec1, cutoff, depth int, multiLine *bool) {
- prec := x.Op.Precedence();
+ prec := x.Op.Precedence()
if prec < prec1 {
// parenthesis needed
// Note: The parser inserts an ast.ParenExpr node; thus this case
// can only occur if the AST is created in a different way.
- p.print(token.LPAREN);
- p.expr0(x, depth-1, multiLine); // parentheses undo one level of depth
- p.print(token.RPAREN);
- return;
+ p.print(token.LPAREN)
+ p.expr0(x, depth-1, multiLine) // parentheses undo one level of depth
+ p.print(token.RPAREN)
+ return
}
- printBlank := prec < cutoff;
+ printBlank := prec < cutoff
- ws := indent;
- p.expr1(x.X, prec, depth+diffPrec(x.X, prec), 0, multiLine);
+ ws := indent
+ p.expr1(x.X, prec, depth+diffPrec(x.X, prec), 0, multiLine)
if printBlank {
p.print(blank)
}
- xline := p.pos.Line; // before the operator (it may be on the next line!)
- yline := x.Y.Pos().Line;
- p.print(p.beforeComment(x.OpPos), x.Op);
+ xline := p.pos.Line // before the operator (it may be on the next line!)
+ yline := x.Y.Pos().Line
+ p.print(p.beforeComment(x.OpPos), x.Op)
if xline != yline && xline > 0 && yline > 0 {
// at least one line break, but respect an extra empty line
// in the source
if p.linebreak(yline, 1, 2, ws, true) {
- ws = ignore;
- *multiLine = true;
- printBlank = false; // no blank after line break
+ ws = ignore
+ *multiLine = true
+ printBlank = false // no blank after line break
}
}
if printBlank {
p.print(blank)
}
- p.expr1(x.Y, prec+1, depth+1, 0, multiLine);
+ p.expr1(x.Y, prec+1, depth+1, 0, multiLine)
if ws == ignore {
p.print(unindent)
}
func isBinary(expr ast.Expr) bool {
- _, ok := expr.(*ast.BinaryExpr);
- return ok;
+ _, ok := expr.(*ast.BinaryExpr)
+ return ok
}
// Returns true if a separating semicolon is optional.
// Sets multiLine to true if the expression spans multiple lines.
func (p *printer) expr1(expr ast.Expr, prec1, depth int, ctxt exprContext, multiLine *bool) (optSemi bool) {
- p.print(expr.Pos());
+ p.print(expr.Pos())
switch x := expr.(type) {
case *ast.BadExpr:
case *ast.BinaryExpr:
if depth < 1 {
- p.internalError("depth < 1:", depth);
- depth = 1;
+ p.internalError("depth < 1:", depth)
+ depth = 1
}
- p.binaryExpr(x, prec1, cutoff(x, depth), depth, multiLine);
+ p.binaryExpr(x, prec1, cutoff(x, depth), depth, multiLine)
case *ast.KeyValueExpr:
- p.expr(x.Key, multiLine);
- p.print(x.Colon, token.COLON, blank);
- p.expr(x.Value, multiLine);
+ p.expr(x.Key, multiLine)
+ p.print(x.Colon, token.COLON, blank)
+ p.expr(x.Value, multiLine)
case *ast.StarExpr:
- const prec = token.UnaryPrec;
+ const prec = token.UnaryPrec
if prec < prec1 {
// parenthesis needed
- p.print(token.LPAREN);
- p.print(token.MUL);
- optSemi = p.expr(x.X, multiLine);
- p.print(token.RPAREN);
+ p.print(token.LPAREN)
+ p.print(token.MUL)
+ optSemi = p.expr(x.X, multiLine)
+ p.print(token.RPAREN)
} else {
// no parenthesis needed
- p.print(token.MUL);
- optSemi = p.expr(x.X, multiLine);
+ p.print(token.MUL)
+ optSemi = p.expr(x.X, multiLine)
}
case *ast.UnaryExpr:
- const prec = token.UnaryPrec;
+ const prec = token.UnaryPrec
if prec < prec1 {
// parenthesis needed
- p.print(token.LPAREN);
- p.expr(x, multiLine);
- p.print(token.RPAREN);
+ p.print(token.LPAREN)
+ p.expr(x, multiLine)
+ p.print(token.RPAREN)
} else {
// no parenthesis needed
- p.print(x.Op);
+ p.print(x.Op)
if x.Op == token.RANGE {
p.print(blank)
}
- p.expr1(x.X, prec, depth, 0, multiLine);
+ p.expr1(x.X, prec, depth, 0, multiLine)
}
case *ast.BasicLit:
p.stringList(x.Strings, multiLine)
case *ast.FuncLit:
- p.expr(x.Type, multiLine);
- p.funcBody(x.Body, distance(x.Type.Pos(), p.pos), true, multiLine);
+ p.expr(x.Type, multiLine)
+ p.funcBody(x.Body, distance(x.Type.Pos(), p.pos), true, multiLine)
case *ast.ParenExpr:
- p.print(token.LPAREN);
- p.expr0(x.X, depth-1, multiLine); // parentheses undo one level of depth
- p.print(x.Rparen, token.RPAREN);
+ p.print(token.LPAREN)
+ p.expr0(x.X, depth-1, multiLine) // parentheses undo one level of depth
+ p.print(x.Rparen, token.RPAREN)
case *ast.SelectorExpr:
- p.expr1(x.X, token.HighestPrec, depth, 0, multiLine);
- p.print(token.PERIOD);
- p.expr1(x.Sel, token.HighestPrec, depth, 0, multiLine);
+ p.expr1(x.X, token.HighestPrec, depth, 0, multiLine)
+ p.print(token.PERIOD)
+ p.expr1(x.Sel, token.HighestPrec, depth, 0, multiLine)
case *ast.TypeAssertExpr:
- p.expr1(x.X, token.HighestPrec, depth, 0, multiLine);
- p.print(token.PERIOD, token.LPAREN);
+ p.expr1(x.X, token.HighestPrec, depth, 0, multiLine)
+ p.print(token.PERIOD, token.LPAREN)
if x.Type != nil {
p.expr(x.Type, multiLine)
} else {
p.print(token.TYPE)
}
- p.print(token.RPAREN);
+ p.print(token.RPAREN)
case *ast.IndexExpr:
// TODO(gri): should treat[] like parentheses and undo one level of depth
- p.expr1(x.X, token.HighestPrec, 1, 0, multiLine);
- p.print(token.LBRACK);
- p.expr0(x.Index, depth+1, multiLine);
- p.print(token.RBRACK);
+ p.expr1(x.X, token.HighestPrec, 1, 0, multiLine)
+ p.print(token.LBRACK)
+ p.expr0(x.Index, depth+1, multiLine)
+ p.print(token.RBRACK)
case *ast.SliceExpr:
// TODO(gri): should treat[] like parentheses and undo one level of depth
- p.expr1(x.X, token.HighestPrec, 1, 0, multiLine);
- p.print(token.LBRACK);
- p.expr0(x.Index, depth+1, multiLine);
+ p.expr1(x.X, token.HighestPrec, 1, 0, multiLine)
+ p.print(token.LBRACK)
+ p.expr0(x.Index, depth+1, multiLine)
// blanks around ":" if both sides exist and either side is a binary expression
if depth <= 1 && x.End != nil && (isBinary(x.Index) || isBinary(x.End)) {
p.print(blank, token.COLON, blank)
if x.End != nil {
p.expr0(x.End, depth+1, multiLine)
}
- p.print(token.RBRACK);
+ p.print(token.RBRACK)
case *ast.CallExpr:
if len(x.Args) > 1 {
depth++
}
- p.expr1(x.Fun, token.HighestPrec, depth, 0, multiLine);
- p.print(x.Lparen, token.LPAREN);
- p.exprList(x.Lparen, x.Args, depth, commaSep, multiLine);
- p.print(x.Rparen, token.RPAREN);
+ p.expr1(x.Fun, token.HighestPrec, depth, 0, multiLine)
+ p.print(x.Lparen, token.LPAREN)
+ p.exprList(x.Lparen, x.Args, depth, commaSep, multiLine)
+ p.print(x.Rparen, token.RPAREN)
case *ast.CompositeLit:
- p.expr1(x.Type, token.HighestPrec, depth, compositeLit, multiLine);
- mode := commaSep | commaTerm;
+ p.expr1(x.Type, token.HighestPrec, depth, compositeLit, multiLine)
+ mode := commaSep | commaTerm
if compositeLitBlank {
// add blank padding around composite literal
// contents for a less dense look
- mode |= blankStart | blankEnd;
+ mode |= blankStart | blankEnd
if x.Lbrace.Line < x.Rbrace.Line {
// add a blank before the opening { for multi-line composites
// TODO(gri): for now this decision is made by looking at the
p.print(blank)
}
}
- p.print(x.Lbrace, token.LBRACE);
- p.exprList(x.Lbrace, x.Elts, 1, mode, multiLine);
- p.print(x.Rbrace, token.RBRACE);
+ p.print(x.Lbrace, token.LBRACE)
+ p.exprList(x.Lbrace, x.Elts, 1, mode, multiLine)
+ p.print(x.Rbrace, token.RBRACE)
case *ast.Ellipsis:
p.print(token.ELLIPSIS)
case *ast.ArrayType:
- p.print(token.LBRACK);
+ p.print(token.LBRACK)
if x.Len != nil {
p.expr(x.Len, multiLine)
}
- p.print(token.RBRACK);
- optSemi = p.expr(x.Elt, multiLine);
+ p.print(token.RBRACK)
+ optSemi = p.expr(x.Elt, multiLine)
case *ast.StructType:
- p.print(token.STRUCT);
- p.fieldList(x.Lbrace, x.Fields, x.Rbrace, x.Incomplete, ctxt|structType);
- optSemi = true;
+ p.print(token.STRUCT)
+ p.fieldList(x.Lbrace, x.Fields, x.Rbrace, x.Incomplete, ctxt|structType)
+ optSemi = true
case *ast.FuncType:
- p.print(token.FUNC);
- optSemi = p.signature(x.Params, x.Results, multiLine);
+ p.print(token.FUNC)
+ optSemi = p.signature(x.Params, x.Results, multiLine)
case *ast.InterfaceType:
- p.print(token.INTERFACE);
- p.fieldList(x.Lbrace, x.Methods, x.Rbrace, x.Incomplete, ctxt);
- optSemi = true;
+ p.print(token.INTERFACE)
+ p.fieldList(x.Lbrace, x.Methods, x.Rbrace, x.Incomplete, ctxt)
+ optSemi = true
case *ast.MapType:
- p.print(token.MAP, token.LBRACK);
- p.expr(x.Key, multiLine);
- p.print(token.RBRACK);
- optSemi = p.expr(x.Value, multiLine);
+ p.print(token.MAP, token.LBRACK)
+ p.expr(x.Key, multiLine)
+ p.print(token.RBRACK)
+ optSemi = p.expr(x.Value, multiLine)
case *ast.ChanType:
switch x.Dir {
case ast.SEND:
p.print(token.CHAN, token.ARROW)
}
- p.print(blank);
- optSemi = p.expr(x.Value, multiLine);
+ p.print(blank)
+ optSemi = p.expr(x.Value, multiLine)
default:
panic("unreachable")
}
- return;
+ return
}
// Returns true if a separating semicolon is optional.
// Sets multiLine to true if the expression spans multiple lines.
func (p *printer) expr(x ast.Expr, multiLine *bool) (optSemi bool) {
- const depth = 1;
- return p.expr1(x, token.LowestPrec, depth, 0, multiLine);
+ const depth = 1
+ return p.expr1(x, token.LowestPrec, depth, 0, multiLine)
}
// ----------------------------------------------------------------------------
// Statements
-const maxStmtNewlines = 2 // maximum number of newlines between statements
+const maxStmtNewlines = 2 // maximum number of newlines between statements
// Print the statement list indented, but without a newline after the last statement.
// Extra line breaks between statements in the source are respected but at most one
if _indent > 0 {
p.print(indent)
}
- var multiLine bool;
+ var multiLine bool
for i, s := range list {
// _indent == 0 only for lists of switch/select case clauses;
// in those cases each clause is a new section
- p.linebreak(s.Pos().Line, 1, maxStmtNewlines, ignore, i == 0 || _indent == 0 || multiLine);
- multiLine = false;
+ p.linebreak(s.Pos().Line, 1, maxStmtNewlines, ignore, i == 0 || _indent == 0 || multiLine)
+ multiLine = false
if !p.stmt(s, &multiLine) && len(list) > 1 && p.Mode&NoSemis == 0 {
p.print(token.SEMICOLON)
}
} else {
p.print(s.Pos())
}
- p.print(token.LBRACE);
- p.stmtList(s.List, indent);
- p.linebreak(s.Rbrace.Line, 1, maxStmtNewlines, ignore, true);
- p.print(s.Rbrace, token.RBRACE);
+ p.print(token.LBRACE)
+ p.stmtList(s.List, indent)
+ p.linebreak(s.Rbrace.Line, 1, maxStmtNewlines, ignore, true)
+ p.print(s.Rbrace, token.RBRACE)
}
if px, hasParens := x.(*ast.ParenExpr); hasParens {
return stripParens(px.X)
}
- return x;
+ return x
}
func (p *printer) controlClause(isForStmt bool, init ast.Stmt, expr ast.Expr, post ast.Stmt) {
- p.print(blank);
- needsBlank := false;
+ p.print(blank)
+ needsBlank := false
if init == nil && post == nil {
// no semicolons required
if expr != nil {
- p.expr(stripParens(expr), ignoreMultiLine);
- needsBlank = true;
+ p.expr(stripParens(expr), ignoreMultiLine)
+ needsBlank = true
}
} else {
// all semicolons required
if init != nil {
p.stmt(init, ignoreMultiLine)
}
- p.print(token.SEMICOLON, blank);
+ p.print(token.SEMICOLON, blank)
if expr != nil {
- p.expr(stripParens(expr), ignoreMultiLine);
- needsBlank = true;
+ p.expr(stripParens(expr), ignoreMultiLine)
+ needsBlank = true
}
if isForStmt {
- p.print(token.SEMICOLON, blank);
- needsBlank = false;
+ p.print(token.SEMICOLON, blank)
+ needsBlank = false
if post != nil {
- p.stmt(post, ignoreMultiLine);
- needsBlank = true;
+ p.stmt(post, ignoreMultiLine)
+ needsBlank = true
}
}
}
// Returns true if a separating semicolon is optional.
// Sets multiLine to true if the statements spans multiple lines.
func (p *printer) stmt(stmt ast.Stmt, multiLine *bool) (optSemi bool) {
- p.print(stmt.Pos());
+ p.print(stmt.Pos())
switch s := stmt.(type) {
case *ast.BadStmt:
p.print("BadStmt")
case *ast.DeclStmt:
- p.decl(s.Decl, inStmtList, multiLine);
- optSemi = true; // decl prints terminating semicolon if necessary
+ p.decl(s.Decl, inStmtList, multiLine)
+ optSemi = true // decl prints terminating semicolon if necessary
case *ast.EmptyStmt:
// nothing to do
// a "correcting" unindent immediately following a line break
// is applied before the line break if there is no comment
// between (see writeWhitespace)
- p.print(unindent);
- p.expr(s.Label, multiLine);
- p.print(token.COLON, vtab, indent);
- p.linebreak(s.Stmt.Pos().Line, 0, 1, ignore, true);
- optSemi = p.stmt(s.Stmt, multiLine);
+ p.print(unindent)
+ p.expr(s.Label, multiLine)
+ p.print(token.COLON, vtab, indent)
+ p.linebreak(s.Stmt.Pos().Line, 0, 1, ignore, true)
+ optSemi = p.stmt(s.Stmt, multiLine)
case *ast.ExprStmt:
- const depth = 1;
- p.expr0(s.X, depth, multiLine);
+ const depth = 1
+ p.expr0(s.X, depth, multiLine)
case *ast.IncDecStmt:
- const depth = 1;
- p.expr0(s.X, depth+1, multiLine);
- p.print(s.Tok);
+ const depth = 1
+ p.expr0(s.X, depth+1, multiLine)
+ p.print(s.Tok)
case *ast.AssignStmt:
- var depth = 1;
+ var depth = 1
if len(s.Lhs) > 1 && len(s.Rhs) > 1 {
depth++
}
- p.exprList(s.Pos(), s.Lhs, depth, commaSep, multiLine);
- p.print(blank, s.TokPos, s.Tok);
- p.exprList(s.TokPos, s.Rhs, depth, blankStart|commaSep, multiLine);
+ p.exprList(s.Pos(), s.Lhs, depth, commaSep, multiLine)
+ p.print(blank, s.TokPos, s.Tok)
+ p.exprList(s.TokPos, s.Rhs, depth, blankStart|commaSep, multiLine)
case *ast.GoStmt:
- p.print(token.GO, blank);
- p.expr(s.Call, multiLine);
+ p.print(token.GO, blank)
+ p.expr(s.Call, multiLine)
case *ast.DeferStmt:
- p.print(token.DEFER, blank);
- p.expr(s.Call, multiLine);
+ p.print(token.DEFER, blank)
+ p.expr(s.Call, multiLine)
case *ast.ReturnStmt:
- p.print(token.RETURN);
+ p.print(token.RETURN)
if s.Results != nil {
p.exprList(s.Pos(), s.Results, 1, blankStart|commaSep, multiLine)
}
case *ast.BranchStmt:
- p.print(s.Tok);
+ p.print(s.Tok)
if s.Label != nil {
- p.print(blank);
- p.expr(s.Label, multiLine);
+ p.print(blank)
+ p.expr(s.Label, multiLine)
}
case *ast.BlockStmt:
- p.block(s, 1, false);
- *multiLine = true;
- optSemi = true;
+ p.block(s, 1, false)
+ *multiLine = true
+ optSemi = true
case *ast.IfStmt:
- p.print(token.IF);
- p.controlClause(false, s.Init, s.Cond, nil);
- p.block(s.Body, 1, true);
- *multiLine = true;
- optSemi = true;
+ p.print(token.IF)
+ p.controlClause(false, s.Init, s.Cond, nil)
+ p.block(s.Body, 1, true)
+ *multiLine = true
+ optSemi = true
if s.Else != nil {
- p.print(blank, token.ELSE, blank);
+ p.print(blank, token.ELSE, blank)
switch s.Else.(type) {
case *ast.BlockStmt, *ast.IfStmt:
optSemi = p.stmt(s.Else, ignoreMultiLine)
default:
- p.print(token.LBRACE, indent, formfeed);
- p.stmt(s.Else, ignoreMultiLine);
- p.print(unindent, formfeed, token.RBRACE);
+ p.print(token.LBRACE, indent, formfeed)
+ p.stmt(s.Else, ignoreMultiLine)
+ p.print(unindent, formfeed, token.RBRACE)
}
}
case *ast.CaseClause:
if s.Values != nil {
- p.print(token.CASE);
- p.exprList(s.Pos(), s.Values, 1, blankStart|commaSep, multiLine);
+ p.print(token.CASE)
+ p.exprList(s.Pos(), s.Values, 1, blankStart|commaSep, multiLine)
} else {
p.print(token.DEFAULT)
}
- p.print(s.Colon, token.COLON);
- p.stmtList(s.Body, 1);
- optSemi = true; // "block" without {}'s
+ p.print(s.Colon, token.COLON)
+ p.stmtList(s.Body, 1)
+ optSemi = true // "block" without {}'s
case *ast.SwitchStmt:
- p.print(token.SWITCH);
- p.controlClause(false, s.Init, s.Tag, nil);
- p.block(s.Body, 0, true);
- *multiLine = true;
- optSemi = true;
+ p.print(token.SWITCH)
+ p.controlClause(false, s.Init, s.Tag, nil)
+ p.block(s.Body, 0, true)
+ *multiLine = true
+ optSemi = true
case *ast.TypeCaseClause:
if s.Types != nil {
- p.print(token.CASE);
- p.exprList(s.Pos(), s.Types, 1, blankStart|commaSep, multiLine);
+ p.print(token.CASE)
+ p.exprList(s.Pos(), s.Types, 1, blankStart|commaSep, multiLine)
} else {
p.print(token.DEFAULT)
}
- p.print(s.Colon, token.COLON);
- p.stmtList(s.Body, 1);
- optSemi = true; // "block" without {}'s
+ p.print(s.Colon, token.COLON)
+ p.stmtList(s.Body, 1)
+ optSemi = true // "block" without {}'s
case *ast.TypeSwitchStmt:
- p.print(token.SWITCH);
+ p.print(token.SWITCH)
if s.Init != nil {
- p.print(blank);
- p.stmt(s.Init, ignoreMultiLine);
- p.print(token.SEMICOLON);
+ p.print(blank)
+ p.stmt(s.Init, ignoreMultiLine)
+ p.print(token.SEMICOLON)
}
- p.print(blank);
- p.stmt(s.Assign, ignoreMultiLine);
- p.print(blank);
- p.block(s.Body, 0, true);
- *multiLine = true;
- optSemi = true;
+ p.print(blank)
+ p.stmt(s.Assign, ignoreMultiLine)
+ p.print(blank)
+ p.block(s.Body, 0, true)
+ *multiLine = true
+ optSemi = true
case *ast.CommClause:
if s.Rhs != nil {
- p.print(token.CASE, blank);
+ p.print(token.CASE, blank)
if s.Lhs != nil {
- p.expr(s.Lhs, multiLine);
- p.print(blank, s.Tok, blank);
+ p.expr(s.Lhs, multiLine)
+ p.print(blank, s.Tok, blank)
}
- p.expr(s.Rhs, multiLine);
+ p.expr(s.Rhs, multiLine)
} else {
p.print(token.DEFAULT)
}
- p.print(s.Colon, token.COLON);
- p.stmtList(s.Body, 1);
- optSemi = true; // "block" without {}'s
+ p.print(s.Colon, token.COLON)
+ p.stmtList(s.Body, 1)
+ optSemi = true // "block" without {}'s
case *ast.SelectStmt:
- p.print(token.SELECT, blank);
- p.block(s.Body, 0, false);
- *multiLine = true;
- optSemi = true;
+ p.print(token.SELECT, blank)
+ p.block(s.Body, 0, false)
+ *multiLine = true
+ optSemi = true
case *ast.ForStmt:
- p.print(token.FOR);
- p.controlClause(true, s.Init, s.Cond, s.Post);
- p.block(s.Body, 1, true);
- *multiLine = true;
- optSemi = true;
+ p.print(token.FOR)
+ p.controlClause(true, s.Init, s.Cond, s.Post)
+ p.block(s.Body, 1, true)
+ *multiLine = true
+ optSemi = true
case *ast.RangeStmt:
- p.print(token.FOR, blank);
- p.expr(s.Key, multiLine);
+ p.print(token.FOR, blank)
+ p.expr(s.Key, multiLine)
if s.Value != nil {
- p.print(token.COMMA, blank);
- p.expr(s.Value, multiLine);
+ p.print(token.COMMA, blank)
+ p.expr(s.Value, multiLine)
}
- p.print(blank, s.TokPos, s.Tok, blank, token.RANGE, blank);
- p.expr(s.X, multiLine);
- p.print(blank);
- p.block(s.Body, 1, true);
- *multiLine = true;
- optSemi = true;
+ p.print(blank, s.TokPos, s.Tok, blank, token.RANGE, blank)
+ p.expr(s.X, multiLine)
+ p.print(blank)
+ p.block(s.Body, 1, true)
+ *multiLine = true
+ optSemi = true
default:
panic("unreachable")
}
- return;
+ return
}
type declContext uint
const (
- atTop declContext = iota;
- inGroup;
- inStmtList;
+ atTop declContext = iota
+ inGroup
+ inStmtList
)
// The parameter n is the number of specs in the group; context specifies
//
func (p *printer) spec(spec ast.Spec, n int, context declContext, multiLine *bool) {
var (
- optSemi bool; // true if a semicolon is optional
- comment *ast.CommentGroup; // a line comment, if any
- extraTabs int; // number of extra tabs before comment, if any
+ optSemi bool // true if a semicolon is optional
+ comment *ast.CommentGroup // a line comment, if any
+ extraTabs int // number of extra tabs before comment, if any
)
switch s := spec.(type) {
case *ast.ImportSpec:
- p.leadComment(s.Doc);
+ p.leadComment(s.Doc)
if s.Name != nil {
- p.expr(s.Name, multiLine);
- p.print(blank);
- p.moveCommentsAfter(s.Path[0].Pos());
+ p.expr(s.Name, multiLine)
+ p.print(blank)
+ p.moveCommentsAfter(s.Path[0].Pos())
}
- p.expr(&ast.StringList{s.Path}, multiLine);
- comment = s.Comment;
+ p.expr(&ast.StringList{s.Path}, multiLine)
+ comment = s.Comment
case *ast.ValueSpec:
- p.leadComment(s.Doc);
- p.identList(s.Names, multiLine); // always present
+ p.leadComment(s.Doc)
+ p.identList(s.Names, multiLine) // always present
if s.Values != nil {
p.moveCommentsAfter(s.Values[0].Pos())
} else if s.Type != nil {
}
if n == 1 {
if s.Type != nil {
- p.print(blank);
- optSemi = p.expr(s.Type, multiLine);
+ p.print(blank)
+ optSemi = p.expr(s.Type, multiLine)
}
if s.Values != nil {
- p.print(blank, token.ASSIGN);
- p.exprList(noPos, s.Values, 1, blankStart|commaSep, multiLine);
- optSemi = false;
+ p.print(blank, token.ASSIGN)
+ p.exprList(noPos, s.Values, 1, blankStart|commaSep, multiLine)
+ optSemi = false
}
} else {
- extraTabs = 2;
+ extraTabs = 2
if s.Type != nil || s.Values != nil {
p.print(vtab)
}
if s.Type != nil {
- optSemi = p.expr(s.Type, multiLine);
- extraTabs = 1;
+ optSemi = p.expr(s.Type, multiLine)
+ extraTabs = 1
}
if s.Values != nil {
- p.print(vtab);
- p.print(token.ASSIGN);
- p.exprList(noPos, s.Values, 1, blankStart|commaSep, multiLine);
- optSemi = false;
- extraTabs = 0;
+ p.print(vtab)
+ p.print(token.ASSIGN)
+ p.exprList(noPos, s.Values, 1, blankStart|commaSep, multiLine)
+ optSemi = false
+ extraTabs = 0
}
}
- comment = s.Comment;
+ comment = s.Comment
case *ast.TypeSpec:
- p.leadComment(s.Doc);
- p.expr(s.Name, multiLine);
- p.moveCommentsAfter(s.Type.Pos());
+ p.leadComment(s.Doc)
+ p.expr(s.Name, multiLine)
+ p.moveCommentsAfter(s.Type.Pos())
if n == 1 {
p.print(blank)
} else {
p.print(vtab)
}
- optSemi = p.expr(s.Type, multiLine);
- comment = s.Comment;
+ optSemi = p.expr(s.Type, multiLine)
+ comment = s.Comment
default:
panic("unreachable")
for ; extraTabs > 0; extraTabs-- {
p.print(vtab)
}
- p.lineComment(comment);
+ p.lineComment(comment)
}
}
// Sets multiLine to true if the declaration spans multiple lines.
func (p *printer) genDecl(d *ast.GenDecl, context declContext, multiLine *bool) {
- p.leadComment(d.Doc);
- p.print(d.Pos(), d.Tok, blank);
+ p.leadComment(d.Doc)
+ p.print(d.Pos(), d.Tok, blank)
if d.Lparen.IsValid() {
// group of parenthesized declarations
- p.print(d.Lparen, token.LPAREN);
+ p.print(d.Lparen, token.LPAREN)
if len(d.Specs) > 0 {
- p.print(indent, formfeed);
- var ml bool;
+ p.print(indent, formfeed)
+ var ml bool
for i, s := range d.Specs {
if i > 0 {
p.linebreak(s.Pos().Line, 1, 2, ignore, ml)
}
- ml = false;
- p.spec(s, len(d.Specs), inGroup, &ml);
+ ml = false
+ p.spec(s, len(d.Specs), inGroup, &ml)
}
- p.print(unindent, formfeed);
- *multiLine = true;
+ p.print(unindent, formfeed)
+ *multiLine = true
}
- p.print(d.Rparen, token.RPAREN);
+ p.print(d.Rparen, token.RPAREN)
} else {
// single declaration
// any control chars. Otherwise, the result is > maxSize.
//
func (p *printer) nodeSize(n ast.Node, maxSize int) (size int) {
- size = maxSize + 1; // assume n doesn't fit
+ size = maxSize + 1 // assume n doesn't fit
// nodeSize computation must be indendent of particular
// style so that we always get the same decision; print
// in RawFormat
- cfg := Config{Mode: RawFormat};
- var buf bytes.Buffer;
+ cfg := Config{Mode: RawFormat}
+ var buf bytes.Buffer
if _, err := cfg.Fprint(&buf, n); err != nil {
return
}
return
}
}
- size = buf.Len(); // n fits
+ size = buf.Len() // n fits
}
- return;
+ return
}
func (p *printer) isOneLineFunc(b *ast.BlockStmt, headerSize int) bool {
- const maxSize = 90; // adjust as appropriate, this is an approximate value
- bodySize := 0;
+ const maxSize = 90 // adjust as appropriate, this is an approximate value
+ bodySize := 0
switch {
case len(b.List) > 1 || p.commentBefore(b.Rbrace):
- return false // too many statements or there is a comment - all bets are off
+ return false // too many statements or there is a comment - all bets are off
case len(b.List) == 1:
bodySize = p.nodeSize(b.List[0], maxSize)
}
// require both headers and overall size to be not "too large"
- return headerSize <= maxSize/2 && headerSize+bodySize <= maxSize;
+ return headerSize <= maxSize/2 && headerSize+bodySize <= maxSize
}
}
if p.isOneLineFunc(b, headerSize) {
- sep := vtab;
+ sep := vtab
if isLit {
sep = blank
}
if len(b.List) > 0 {
- p.print(sep, b.Pos(), token.LBRACE, blank);
- p.stmt(b.List[0], ignoreMultiLine);
- p.print(blank, b.Rbrace, token.RBRACE);
+ p.print(sep, b.Pos(), token.LBRACE, blank)
+ p.stmt(b.List[0], ignoreMultiLine)
+ p.print(blank, b.Rbrace, token.RBRACE)
} else {
p.print(sep, b.Pos(), token.LBRACE, b.Rbrace, token.RBRACE)
}
- return;
+ return
}
- p.print(blank);
- p.block(b, 1, true);
- *multiLine = true;
+ p.print(blank)
+ p.block(b, 1, true)
+ *multiLine = true
}
if from.IsValid() && to.IsValid() && from.Line == to.Line {
return to.Column - from.Column
}
- return 1 << 30;
+ return 1 << 30
}
// Sets multiLine to true if the declaration spans multiple lines.
func (p *printer) funcDecl(d *ast.FuncDecl, multiLine *bool) {
- p.leadComment(d.Doc);
- p.print(d.Pos(), token.FUNC, blank);
+ p.leadComment(d.Doc)
+ p.print(d.Pos(), token.FUNC, blank)
if recv := d.Recv; recv != nil {
// method: print receiver
- p.print(token.LPAREN);
+ p.print(token.LPAREN)
if len(recv.Names) > 0 {
- p.expr(recv.Names[0], multiLine);
- p.print(blank);
+ p.expr(recv.Names[0], multiLine)
+ p.print(blank)
}
- p.expr(recv.Type, multiLine);
- p.print(token.RPAREN, blank);
+ p.expr(recv.Type, multiLine)
+ p.print(token.RPAREN, blank)
}
- p.expr(d.Name, multiLine);
- p.signature(d.Type.Params, d.Type.Results, multiLine);
- p.funcBody(d.Body, distance(d.Pos(), p.pos), false, multiLine);
+ p.expr(d.Name, multiLine)
+ p.signature(d.Type.Params, d.Type.Results, multiLine)
+ p.funcBody(d.Body, distance(d.Pos(), p.pos), false, multiLine)
}
// ----------------------------------------------------------------------------
// Files
-const maxDeclNewlines = 3 // maximum number of newlines between declarations
+const maxDeclNewlines = 3 // maximum number of newlines between declarations
func declToken(decl ast.Decl) (tok token.Token) {
- tok = token.ILLEGAL;
+ tok = token.ILLEGAL
switch d := decl.(type) {
case *ast.GenDecl:
tok = d.Tok
case *ast.FuncDecl:
tok = token.FUNC
}
- return;
+ return
}
func (p *printer) file(src *ast.File) {
- p.leadComment(src.Doc);
- p.print(src.Pos(), token.PACKAGE, blank);
- p.expr(src.Name, ignoreMultiLine);
+ p.leadComment(src.Doc)
+ p.print(src.Pos(), token.PACKAGE, blank)
+ p.expr(src.Name, ignoreMultiLine)
if len(src.Decls) > 0 {
- tok := token.ILLEGAL;
+ tok := token.ILLEGAL
for _, d := range src.Decls {
- prev := tok;
- tok = declToken(d);
+ prev := tok
+ tok = declToken(d)
// if the declaration token changed (e.g., from CONST to TYPE)
// print an empty line between top-level declarations
- min := 1;
+ min := 1
if prev != tok {
min = 2
}
- p.linebreak(d.Pos().Line, min, maxDeclNewlines, ignore, false);
- p.decl(d, atTop, ignoreMultiLine);
+ p.linebreak(d.Pos().Line, min, maxDeclNewlines, ignore, false)
+ p.decl(d, atTop, ignoreMultiLine)
}
}
- p.print(newline);
+ p.print(newline)
}
package printer
import (
- "bytes";
- "fmt";
- "go/ast";
- "go/token";
- "io";
- "os";
- "reflect";
- "runtime";
- "strings";
- "tabwriter";
+ "bytes"
+ "fmt"
+ "go/ast"
+ "go/token"
+ "io"
+ "os"
+ "reflect"
+ "runtime"
+ "strings"
+ "tabwriter"
)
const (
- debug = false; // enable for debugging
- maxNewlines = 3; // maximum vertical white space
+ debug = false // enable for debugging
+ maxNewlines = 3 // maximum vertical white space
)
type whiteSpace int
const (
- ignore = whiteSpace(0);
- blank = whiteSpace(' ');
- vtab = whiteSpace('\v');
- newline = whiteSpace('\n');
- formfeed = whiteSpace('\f');
- indent = whiteSpace('>');
- unindent = whiteSpace('<');
+ ignore = whiteSpace(0)
+ blank = whiteSpace(' ')
+ vtab = whiteSpace('\v')
+ newline = whiteSpace('\n')
+ formfeed = whiteSpace('\f')
+ indent = whiteSpace('>')
+ unindent = whiteSpace('<')
)
var (
- esc = []byte{tabwriter.Escape};
- htab = []byte{'\t'};
- htabs = [...]byte{'\t', '\t', '\t', '\t', '\t', '\t', '\t', '\t'};
- newlines = [...]byte{'\n', '\n', '\n', '\n', '\n', '\n', '\n', '\n'}; // more than maxNewlines
- formfeeds = [...]byte{'\f', '\f', '\f', '\f', '\f', '\f', '\f', '\f'}; // more than maxNewlines
-
- esc_quot = strings.Bytes("""); // shorter than """
- esc_apos = strings.Bytes("'"); // shorter than "'"
- esc_amp = strings.Bytes("&");
- esc_lt = strings.Bytes("<");
- esc_gt = strings.Bytes(">");
+ esc = []byte{tabwriter.Escape}
+ htab = []byte{'\t'}
+ htabs = [...]byte{'\t', '\t', '\t', '\t', '\t', '\t', '\t', '\t'}
+ newlines = [...]byte{'\n', '\n', '\n', '\n', '\n', '\n', '\n', '\n'} // more than maxNewlines
+ formfeeds = [...]byte{'\f', '\f', '\f', '\f', '\f', '\f', '\f', '\f'} // more than maxNewlines
+
+ esc_quot = strings.Bytes(""") // shorter than """
+ esc_apos = strings.Bytes("'") // shorter than "'"
+ esc_amp = strings.Bytes("&")
+ esc_lt = strings.Bytes("<")
+ esc_gt = strings.Bytes(">")
)
type printer struct {
// Configuration (does not change after initialization)
- output io.Writer;
- Config;
- errors chan os.Error;
+ output io.Writer
+ Config
+ errors chan os.Error
// Current state
- written int; // number of bytes written
- indent int; // current indentation
- escape bool; // true if in escape sequence
+ written int // number of bytes written
+ indent int // current indentation
+ escape bool // true if in escape sequence
// Buffered whitespace
- buffer []whiteSpace;
+ buffer []whiteSpace
// The (possibly estimated) position in the generated output;
// in AST space (i.e., pos is set whenever a token position is
// known accurately, and updated dependending on what has been
// written)
- pos token.Position;
+ pos token.Position
// The value of pos immediately after the last item has been
// written using writeItem.
- last token.Position;
+ last token.Position
// HTML support
- lastTaggedLine int; // last line for which a line tag was written
+ lastTaggedLine int // last line for which a line tag was written
// The list of comments; or nil.
- comment *ast.CommentGroup;
+ comment *ast.CommentGroup
}
func (p *printer) init(output io.Writer, cfg *Config) {
- p.output = output;
- p.Config = *cfg;
- p.errors = make(chan os.Error);
- p.buffer = make([]whiteSpace, 0, 16); // whitespace sequences are short
+ p.output = output
+ p.Config = *cfg
+ p.errors = make(chan os.Error)
+ p.buffer = make([]whiteSpace, 0, 16) // whitespace sequences are short
}
func (p *printer) internalError(msg ...) {
if debug {
- fmt.Print(p.pos.String() + ": ");
- fmt.Println(msg);
- panic();
+ fmt.Print(p.pos.String() + ": ")
+ fmt.Println(msg)
+ panic()
}
}
// write0 does not indent after newlines, and does not HTML-escape or update p.pos.
//
func (p *printer) write0(data []byte) {
- n, err := p.output.Write(data);
- p.written += n;
+ n, err := p.output.Write(data)
+ p.written += n
if err != nil {
- p.errors <- err;
- runtime.Goexit();
+ p.errors <- err
+ runtime.Goexit()
}
}
// escapes characters if GenHTML is set. It updates p.pos as a side-effect.
//
func (p *printer) write(data []byte) {
- i0 := 0;
+ i0 := 0
for i, b := range data {
switch b {
case '\n', '\f':
// write segment ending in b
- p.write0(data[i0 : i+1]);
+ p.write0(data[i0 : i+1])
// update p.pos
- p.pos.Offset += i + 1 - i0;
- p.pos.Line++;
- p.pos.Column = 1;
+ p.pos.Offset += i + 1 - i0
+ p.pos.Line++
+ p.pos.Column = 1
if !p.escape {
// write indentation
// use "hard" htabs - indentation columns
// must not be discarded by the tabwriter
- j := p.indent;
+ j := p.indent
for ; j > len(htabs); j -= len(htabs) {
p.write0(&htabs)
}
- p.write0(htabs[0:j]);
+ p.write0(htabs[0:j])
// update p.pos
- p.pos.Offset += p.indent;
- p.pos.Column += p.indent;
+ p.pos.Offset += p.indent
+ p.pos.Column += p.indent
}
// next segment start
- i0 = i + 1;
+ i0 = i + 1
case '"', '\'', '&', '<', '>':
if p.Mode&GenHTML != 0 {
// write segment ending in b
- p.write0(data[i0:i]);
+ p.write0(data[i0:i])
// write HTML-escaped b
- var esc []byte;
+ var esc []byte
switch b {
case '"':
esc = esc_quot
case '>':
esc = esc_gt
}
- p.write0(esc);
+ p.write0(esc)
// update p.pos
- d := i + 1 - i0;
- p.pos.Offset += d;
- p.pos.Column += d;
+ d := i + 1 - i0
+ p.pos.Offset += d
+ p.pos.Column += d
// next segment start
- i0 = i + 1;
+ i0 = i + 1
}
case tabwriter.Escape:
}
// write remaining segment
- p.write0(data[i0:]);
+ p.write0(data[i0:])
// update p.pos
- d := len(data) - i0;
- p.pos.Offset += d;
- p.pos.Column += d;
+ d := len(data) - i0
+ p.pos.Offset += d
+ p.pos.Column += d
}
if n > maxNewlines {
n = maxNewlines
}
- p.write(newlines[0:n]);
+ p.write(newlines[0:n])
}
}
if n > maxNewlines {
n = maxNewlines
}
- p.write(formfeeds[0:n]);
+ p.write(formfeeds[0:n])
}
}
if tag.Start != "" {
p.write0(strings.Bytes(tag.Start))
}
- p.write(data);
+ p.write(data)
// write end tag, if any
if tag.End != "" {
p.write0(strings.Bytes(tag.End))
// immediately following the data.
//
func (p *printer) writeItem(pos token.Position, data []byte, tag HTMLTag) {
- p.pos = pos;
+ p.pos = pos
if debug {
// do not update p.pos - use write0
p.write0(strings.Bytes(fmt.Sprintf("[%d:%d]", pos.Line, pos.Column)))
// TODO(gri): should write line tags on each line at the start
// will be more useful (e.g. to show line numbers)
if p.Styler != nil && pos.Line > p.lastTaggedLine {
- p.writeTaggedItem(p.Styler.LineTag(pos.Line));
- p.lastTaggedLine = pos.Line;
+ p.writeTaggedItem(p.Styler.LineTag(pos.Line))
+ p.lastTaggedLine = pos.Line
}
- p.writeTaggedItem(data, tag);
+ p.writeTaggedItem(data, tag)
} else {
p.write(data)
}
- p.last = p.pos;
+ p.last = p.pos
}
if pos.Line == p.last.Line {
// comment on the same line as last item:
// separate with at least one separator
- hasSep := false;
+ hasSep := false
if isFirst {
- j := 0;
+ j := 0
for i, ch := range p.buffer {
switch ch {
case blank:
// ignore any blanks before a comment
- p.buffer[i] = ignore;
- continue;
+ p.buffer[i] = ignore
+ continue
case vtab:
// respect existing tabs - important
// for proper formatting of commented structs
- hasSep = true;
- continue;
+ hasSep = true
+ continue
case indent:
// apply pending indentation
continue
}
- j = i;
- break;
+ j = i
+ break
}
- p.writeWhitespace(j);
+ p.writeWhitespace(j)
}
// make sure there is at least one separator
if !hasSep {
// comment on a different line:
// separate with at least one line break
if isFirst {
- j := 0;
+ j := 0
for i, ch := range p.buffer {
switch ch {
case blank, vtab:
// ignore any horizontal whitespace before line breaks
- p.buffer[i] = ignore;
- continue;
+ p.buffer[i] = ignore
+ continue
case indent:
// apply pending indentation
continue
// TODO(gri): may want to keep formfeed info in some cases
p.buffer[i] = ignore
}
- j = i;
- break;
+ j = i
+ break
}
- p.writeWhitespace(j);
+ p.writeWhitespace(j)
}
// use formfeeds to break columns before a comment;
// this is analogous to using formfeeds to separate
// individual lines of /*-style comments
- p.writeFormfeeds(pos.Line - p.last.Line);
+ p.writeFormfeeds(pos.Line - p.last.Line)
}
}
func (p *printer) writeCommentLine(comment *ast.Comment, pos token.Position, line []byte) {
// line must pass through unchanged, bracket it with tabwriter.Escape
- esc := []byte{tabwriter.Escape};
- line = bytes.Join([][]byte{esc, line, esc}, nil);
+ esc := []byte{tabwriter.Escape}
+ line = bytes.Join([][]byte{esc, line, esc}, nil)
// apply styler, if any
- var tag HTMLTag;
+ var tag HTMLTag
if p.Styler != nil {
line, tag = p.Styler.Comment(comment, line)
}
- p.writeItem(pos, line, tag);
+ p.writeItem(pos, line, tag)
}
// Split comment text into lines
func split(text []byte) [][]byte {
// count lines (comment text never ends in a newline)
- n := 1;
+ n := 1
for _, c := range text {
if c == '\n' {
n++
}
// split
- lines := make([][]byte, n);
- n = 0;
- i := 0;
+ lines := make([][]byte, n)
+ n = 0
+ i := 0
for j, c := range text {
if c == '\n' {
- lines[n] = text[i:j]; // exclude newline
- i = j + 1; // discard newline
- n++;
+ lines[n] = text[i:j] // exclude newline
+ i = j + 1 // discard newline
+ n++
}
}
- lines[n] = text[i:];
+ lines[n] = text[i:]
- return lines;
+ return lines
}
return false
}
}
- return true;
+ return true
}
func commonPrefix(a, b []byte) []byte {
- i := 0;
+ i := 0
for i < len(a) && i < len(b) && a[i] == b[i] && (a[i] <= ' ' || a[i] == '*') {
i++
}
- return a[0:i];
+ return a[0:i]
}
func stripCommonPrefix(lines [][]byte) {
if len(lines) < 2 {
- return // at most one line - nothing to do
+ return // at most one line - nothing to do
}
// The heuristic in this function tries to handle a few
// Compute maximum common white prefix of all but the first,
// last, and blank lines, and replace blank lines with empty
// lines (the first line starts with /* and has no prefix).
- var prefix []byte;
+ var prefix []byte
for i, line := range lines {
switch {
case i == 0 || i == len(lines)-1:
/*
* Check for vertical "line of stars" and correct prefix accordingly.
*/
- lineOfStars := false;
+ lineOfStars := false
if i := bytes.Index(prefix, []byte{'*'}); i >= 0 {
// Line of stars present.
if i > 0 && prefix[i-1] == ' ' {
- i-- // remove trailing blank from prefix so stars remain aligned
+ i-- // remove trailing blank from prefix so stars remain aligned
}
- prefix = prefix[0:i];
- lineOfStars = true;
+ prefix = prefix[0:i]
+ lineOfStars = true
} else {
// No line of stars present.
// Determine the white space on the first line after the /*
// the /* is a tab. If the first comment line is empty but
// for the opening /*, assume up to 3 blanks or a tab. This
// whitespace may be found as suffix in the common prefix.
- first := lines[0];
+ first := lines[0]
if isBlank(first[2:]) {
// no comment text on the first line:
// reduce prefix by up to 3 blanks or a tab
// if present - this keeps comment text indented
// relative to the /* and */'s if it was indented
// in the first place
- i := len(prefix);
+ i := len(prefix)
for n := 0; n < 3 && i > 0 && prefix[i-1] == ' '; n++ {
i--
}
if i == len(prefix) && i > 0 && prefix[i-1] == '\t' {
i--
}
- prefix = prefix[0:i];
+ prefix = prefix[0:i]
} else {
// comment text on the first line
- suffix := make([]byte, len(first));
- n := 2;
+ suffix := make([]byte, len(first))
+ n := 2
for n < len(first) && first[n] <= ' ' {
- suffix[n] = first[n];
- n++;
+ suffix[n] = first[n]
+ n++
}
if n > 2 && suffix[2] == '\t' {
// assume the '\t' compensates for the /*
suffix = suffix[2:n]
} else {
// otherwise assume two blanks
- suffix[0], suffix[1] = ' ', ' ';
- suffix = suffix[0:n];
+ suffix[0], suffix[1] = ' ', ' '
+ suffix = suffix[0:n]
}
// Shorten the computed common prefix by the length of
// suffix, if it is found as suffix of the prefix.
// Handle last line: If it only contains a closing */, align it
// with the opening /*, otherwise align the text with the other
// lines.
- last := lines[len(lines)-1];
- closing := []byte{'*', '/'};
- i := bytes.Index(last, closing);
+ last := lines[len(lines)-1]
+ closing := []byte{'*', '/'}
+ i := bytes.Index(last, closing)
if isBlank(last[0:i]) {
// last line only contains closing */
- var sep []byte;
+ var sep []byte
if lineOfStars {
// insert an aligning blank
sep = []byte{' '}
}
- lines[len(lines)-1] = bytes.Join([][]byte{prefix, closing}, sep);
+ lines[len(lines)-1] = bytes.Join([][]byte{prefix, closing}, sep)
} else {
// last line contains more comment text - assume
// it is aligned like the other lines
func (p *printer) writeComment(comment *ast.Comment) {
- text := comment.Text;
+ text := comment.Text
// shortcut common case of //-style comments
if text[1] == '/' {
- p.writeCommentLine(comment, comment.Pos(), text);
- return;
+ p.writeCommentLine(comment, comment.Pos(), text)
+ return
}
// for /*-style comments, print line by line and let the
// write function take care of the proper indentation
- lines := split(text);
- stripCommonPrefix(lines);
+ lines := split(text)
+ stripCommonPrefix(lines)
// write comment lines, separated by formfeed,
// without a line break after the last line
- linebreak := formfeeds[0:1];
- pos := comment.Pos();
+ linebreak := formfeeds[0:1]
+ pos := comment.Pos()
for i, line := range lines {
if i > 0 {
- p.write(linebreak);
- pos = p.pos;
+ p.write(linebreak)
+ pos = p.pos
}
if len(line) > 0 {
p.writeCommentLine(comment, pos, line)
}
}
}
- p.writeWhitespace(len(p.buffer));
+ p.writeWhitespace(len(p.buffer))
// make sure we have a line break
if needsLinebreak {
// token is a keyword or not.
//
func (p *printer) intersperseComments(next token.Position, isKeyword bool) {
- isFirst := true;
- needsLinebreak := false;
- var last *ast.Comment;
+ isFirst := true
+ needsLinebreak := false
+ var last *ast.Comment
for ; p.commentBefore(next); p.comment = p.comment.Next {
for _, c := range p.comment.List {
- p.writeCommentPrefix(c.Pos(), next, isFirst, isKeyword);
- isFirst = false;
- p.writeComment(c);
- needsLinebreak = c.Text[1] == '/';
- last = c;
+ p.writeCommentPrefix(c.Pos(), next, isFirst, isKeyword)
+ isFirst = false
+ p.writeComment(c)
+ needsLinebreak = c.Text[1] == '/'
+ last = c
}
}
if last != nil && !needsLinebreak && last.Pos().Line == next.Line {
// follows on the same line: separate with an extra blank
p.write([]byte{' '})
}
- p.writeCommentSuffix(needsLinebreak);
+ p.writeCommentSuffix(needsLinebreak)
}
// whiteWhitespace writes the first n whitespace entries.
func (p *printer) writeWhitespace(n int) {
// write entries
- var data [1]byte;
+ var data [1]byte
for i := 0; i < n; i++ {
switch ch := p.buffer[i]; ch {
case ignore:
case indent:
p.indent++
case unindent:
- p.indent--;
+ p.indent--
if p.indent < 0 {
- p.internalError("negative indentation:", p.indent);
- p.indent = 0;
+ p.internalError("negative indentation:", p.indent)
+ p.indent = 0
}
case newline, formfeed:
// A line break immediately followed by a "correcting"
// to a wide column may increase the indentation column
// of lines before the label; effectively leading to wrong
// indentation.
- p.buffer[i], p.buffer[i+1] = unindent, formfeed;
- i--; // do it again
- continue;
+ p.buffer[i], p.buffer[i+1] = unindent, formfeed
+ i-- // do it again
+ continue
}
- fallthrough;
+ fallthrough
default:
- data[0] = byte(ch);
- p.write(&data);
+ data[0] = byte(ch)
+ p.write(&data)
}
}
// shift remaining entries down
- i := 0;
+ i := 0
for ; n < len(p.buffer); n++ {
- p.buffer[i] = p.buffer[n];
- i++;
+ p.buffer[i] = p.buffer[n]
+ i++
}
- p.buffer = p.buffer[0:i];
+ p.buffer = p.buffer[0:i]
}
// printed, followed by the actual token.
//
func (p *printer) print(args ...) {
- v := reflect.NewValue(args).(*reflect.StructValue);
+ v := reflect.NewValue(args).(*reflect.StructValue)
for i := 0; i < v.NumField(); i++ {
- f := v.Field(i);
+ f := v.Field(i)
- next := p.pos; // estimated position of next item
- var data []byte;
- var tag HTMLTag;
- isKeyword := false;
+ next := p.pos // estimated position of next item
+ var data []byte
+ var tag HTMLTag
+ isKeyword := false
switch x := f.Interface().(type) {
case whiteSpace:
if x == ignore {
// LabeledStmt)
break
}
- i := len(p.buffer);
+ i := len(p.buffer)
if i == cap(p.buffer) {
// Whitespace sequences are very short so this should
// never happen. Handle gracefully (but possibly with
// bad comment placement) if it does happen.
- p.writeWhitespace(i);
- i = 0;
+ p.writeWhitespace(i)
+ i = 0
}
- p.buffer = p.buffer[0 : i+1];
- p.buffer[i] = x;
+ p.buffer = p.buffer[0 : i+1]
+ p.buffer[i] = x
case []byte:
// TODO(gri): remove this case once commentList
// handles comments correctly
// (note that valid Go programs cannot contain esc ('\xff')
// bytes since they do not appear in legal UTF-8 sequences)
// TODO(gri): this this more efficiently.
- data = strings.Bytes("\xff" + string(data) + "\xff");
+ data = strings.Bytes("\xff" + string(data) + "\xff")
case token.Token:
if p.Styler != nil {
data, tag = p.Styler.Token(x)
} else {
data = strings.Bytes(x.String())
}
- isKeyword = x.IsKeyword();
+ isKeyword = x.IsKeyword()
case token.Position:
if x.IsValid() {
- next = x // accurate position of next item
+ next = x // accurate position of next item
}
default:
panicln("print: unsupported argument type", f.Type().String())
}
- p.pos = next;
+ p.pos = next
if data != nil {
- p.flush(next, isKeyword);
+ p.flush(next, isKeyword)
// intersperse extra newlines if present in the source
// (don't do this in flush as it will cause extra newlines
// at the end of a file)
- p.writeNewlines(next.Line - p.pos.Line);
+ p.writeNewlines(next.Line - p.pos.Line)
- p.writeItem(next, data, tag);
+ p.writeItem(next, data, tag)
}
}
}
p.intersperseComments(next, isKeyword)
}
// write any leftover whitespace
- p.writeWhitespace(len(p.buffer));
+ p.writeWhitespace(len(p.buffer))
}
// is used).
//
type trimmer struct {
- output io.Writer;
- buf bytes.Buffer;
+ output io.Writer
+ buf bytes.Buffer
}
func (p *trimmer) Write(data []byte) (n int, err os.Error) {
// m < 0: no unwritten data except for whitespace
// m >= 0: data[m:n] unwritten and no whitespace
- m := 0;
+ m := 0
if p.buf.Len() > 0 {
m = -1
}
- var b byte;
+ var b byte
for n, b = range data {
switch b {
default:
if _, err = p.output.Write(p.buf.Bytes()); err != nil {
return
}
- p.buf.Reset();
- m = n;
+ p.buf.Reset()
+ m = n
}
case '\v':
- b = '\t'; // convert to htab
- fallthrough;
+ b = '\t' // convert to htab
+ fallthrough
case '\t', ' ', tabwriter.Escape:
// write any pending (non-whitespace) data
if _, err = p.output.Write(data[m:n]); err != nil {
return
}
- m = -1;
+ m = -1
}
// collect whitespace but discard tabrwiter.Escapes.
if b != tabwriter.Escape {
- p.buf.WriteByte(b) // WriteByte returns no errors
+ p.buf.WriteByte(b) // WriteByte returns no errors
}
case '\f', '\n':
// discard whitespace
- p.buf.Reset();
+ p.buf.Reset()
// write any pending (non-whitespace) data
if m >= 0 {
if _, err = p.output.Write(data[m:n]); err != nil {
return
}
- m = -1;
+ m = -1
}
// convert formfeed into newline
if _, err = p.output.Write(newlines[0:1]); err != nil {
}
}
}
- n = len(data);
+ n = len(data)
// write any pending non-whitespace
if m >= 0 {
}
}
- return;
+ return
}
// General printing is controlled with these Config.Mode flags.
const (
- GenHTML uint = 1 << iota; // generate HTML
- RawFormat; // do not use a tabwriter; if set, UseSpaces is ignored
- TabIndent; // use tabs for indentation independent of UseSpaces
- UseSpaces; // use spaces instead of tabs for alignment
- NoSemis; // don't print semicolons at the end of a line
+ GenHTML uint = 1 << iota // generate HTML
+ RawFormat // do not use a tabwriter; if set, UseSpaces is ignored
+ TabIndent // use tabs for indentation independent of UseSpaces
+ UseSpaces // use spaces instead of tabs for alignment
+ NoSemis // don't print semicolons at the end of a line
)
// An HTMLTag specifies a start and end tag.
type HTMLTag struct {
- Start, End string; // empty if tags are absent
+ Start, End string // empty if tags are absent
}
// A format consists of text and a (possibly empty) surrounding HTML tag.
//
type Styler interface {
- LineTag(line int) ([]byte, HTMLTag);
- Comment(c *ast.Comment, line []byte) ([]byte, HTMLTag);
- BasicLit(x *ast.BasicLit) ([]byte, HTMLTag);
- Ident(id *ast.Ident) ([]byte, HTMLTag);
- Token(tok token.Token) ([]byte, HTMLTag);
+ LineTag(line int) ([]byte, HTMLTag)
+ Comment(c *ast.Comment, line []byte) ([]byte, HTMLTag)
+ BasicLit(x *ast.BasicLit) ([]byte, HTMLTag)
+ Ident(id *ast.Ident) ([]byte, HTMLTag)
+ Token(tok token.Token) ([]byte, HTMLTag)
}
// A Config node controls the output of Fprint.
type Config struct {
- Mode uint; // default: 0
- Tabwidth int; // default: 8
- Styler Styler; // default: nil
+ Mode uint // default: 0
+ Tabwidth int // default: 8
+ Styler Styler // default: nil
}
// (Input to a tabwriter must be untrimmed since trailing tabs provide
// formatting information. The tabwriter could provide trimming
// functionality but no tabwriter is used when RawFormat is set.)
- output = &trimmer{output: output};
+ output = &trimmer{output: output}
// setup tabwriter if needed and redirect output
- var tw *tabwriter.Writer;
+ var tw *tabwriter.Writer
if cfg.Mode&RawFormat == 0 {
- minwidth := cfg.Tabwidth;
+ minwidth := cfg.Tabwidth
- padchar := byte('\t');
+ padchar := byte('\t')
if cfg.Mode&UseSpaces != 0 {
padchar = ' '
}
- twmode := tabwriter.DiscardEmptyColumns;
+ twmode := tabwriter.DiscardEmptyColumns
if cfg.Mode&GenHTML != 0 {
twmode |= tabwriter.FilterHTML
}
if cfg.Mode&TabIndent != 0 {
- minwidth = 0;
- twmode |= tabwriter.TabIndent;
+ minwidth = 0
+ twmode |= tabwriter.TabIndent
}
- tw = tabwriter.NewWriter(output, minwidth, cfg.Tabwidth, 1, padchar, twmode);
- output = tw;
+ tw = tabwriter.NewWriter(output, minwidth, cfg.Tabwidth, 1, padchar, twmode)
+ output = tw
}
// setup printer and print node
- var p printer;
- p.init(output, cfg);
+ var p printer
+ p.init(output, cfg)
go func() {
switch n := node.(type) {
case ast.Expr:
case ast.Decl:
p.decl(n, atTop, ignoreMultiLine)
case *ast.File:
- p.comment = n.Comments;
- p.file(n);
+ p.comment = n.Comments
+ p.file(n)
default:
- p.errors <- os.NewError(fmt.Sprintf("printer.Fprint: unsupported node type %T", n));
- runtime.Goexit();
+ p.errors <- os.NewError(fmt.Sprintf("printer.Fprint: unsupported node type %T", n))
+ runtime.Goexit()
}
- p.flush(token.Position{Offset: 1 << 30, Line: 1 << 30}, false); // flush to "infinity"
- p.errors <- nil; // no errors
- }();
- err := <-p.errors; // wait for completion of goroutine
+ p.flush(token.Position{Offset: 1 << 30, Line: 1 << 30}, false) // flush to "infinity"
+ p.errors <- nil // no errors
+ }()
+ err := <-p.errors // wait for completion of goroutine
// flush tabwriter, if any
if tw != nil {
- tw.Flush() // ignore errors
+ tw.Flush() // ignore errors
}
- return p.written, err;
+ return p.written, err
}
// It calls Config.Fprint with default settings.
//
func Fprint(output io.Writer, node interface{}) os.Error {
- _, err := (&Config{Tabwidth: 8}).Fprint(output, node); // don't care about number of bytes written
- return err;
+ _, err := (&Config{Tabwidth: 8}).Fprint(output, node) // don't care about number of bytes written
+ return err
}
package printer
import (
- "bytes";
- oldParser "exp/parser";
- "flag";
- "io/ioutil";
- "go/ast";
- "go/parser";
- "os";
- "path";
- "testing";
+ "bytes"
+ oldParser "exp/parser"
+ "flag"
+ "io/ioutil"
+ "go/ast"
+ "go/parser"
+ "os"
+ "path"
+ "testing"
)
const (
- dataDir = "testdata";
- tabwidth = 8;
+ dataDir = "testdata"
+ tabwidth = 8
)
func lineString(text []byte, i int) string {
- i0 := i;
+ i0 := i
for i < len(text) && text[i] != '\n' {
i++
}
- return string(text[i0:i]);
+ return string(text[i0:i])
}
type checkMode uint
const (
- export checkMode = 1 << iota;
- rawFormat;
- oldSyntax;
+ export checkMode = 1 << iota
+ rawFormat
+ oldSyntax
)
func check(t *testing.T, source, golden string, mode checkMode) {
// parse source
- var prog *ast.File;
- var err os.Error;
+ var prog *ast.File
+ var err os.Error
if mode&oldSyntax != 0 {
prog, err = oldParser.ParseFile(source, nil, parser.ParseComments)
} else {
prog, err = parser.ParseFile(source, nil, parser.ParseComments)
}
if err != nil {
- t.Error(err);
- return;
+ t.Error(err)
+ return
}
// filter exports if necessary
if mode&export != 0 {
- ast.FileExports(prog); // ignore result
- prog.Comments = nil; // don't print comments that are not in AST
+ ast.FileExports(prog) // ignore result
+ prog.Comments = nil // don't print comments that are not in AST
}
// determine printer configuration
- cfg := Config{Tabwidth: tabwidth};
+ cfg := Config{Tabwidth: tabwidth}
if mode&rawFormat != 0 {
cfg.Mode |= RawFormat
}
// format source
- var buf bytes.Buffer;
+ var buf bytes.Buffer
if _, err := cfg.Fprint(&buf, prog); err != nil {
t.Error(err)
}
- res := buf.Bytes();
+ res := buf.Bytes()
// update golden files if necessary
if *update {
if err := ioutil.WriteFile(golden, res, 0644); err != nil {
t.Error(err)
}
- return;
+ return
}
// get golden
- gld, err := ioutil.ReadFile(golden);
+ gld, err := ioutil.ReadFile(golden)
if err != nil {
- t.Error(err);
- return;
+ t.Error(err)
+ return
}
// compare lengths
// compare contents
for i, line, offs := 0, 1, 0; i < len(res) && i < len(gld); i++ {
- ch := res[i];
+ ch := res[i]
if ch != gld[i] {
- t.Errorf("%s:%d:%d: %s", source, line, i-offs+1, lineString(res, offs));
- t.Errorf("%s:%d:%d: %s", golden, line, i-offs+1, lineString(gld, offs));
- t.Error();
- return;
+ t.Errorf("%s:%d:%d: %s", source, line, i-offs+1, lineString(res, offs))
+ t.Errorf("%s:%d:%d: %s", golden, line, i-offs+1, lineString(gld, offs))
+ t.Error()
+ return
}
if ch == '\n' {
- line++;
- offs = i + 1;
+ line++
+ offs = i + 1
}
}
}
type entry struct {
- source, golden string;
- mode checkMode;
+ source, golden string
+ mode checkMode
}
// Use gotest -update to create/update the respective golden files.
func Test(t *testing.T) {
for _, e := range data {
- source := path.Join(dataDir, e.source);
- golden := path.Join(dataDir, e.golden);
- check(t, source, golden, e.mode|oldSyntax);
+ source := path.Join(dataDir, e.source)
+ golden := path.Join(dataDir, e.golden)
+ check(t, source, golden, e.mode|oldSyntax)
// TODO(gri) check that golden is idempotent
//check(t, golden, golden, e.mode);
}
package scanner
import (
- "container/vector";
- "fmt";
- "go/token";
- "io";
- "os";
- "sort";
+ "container/vector"
+ "fmt"
+ "go/token"
+ "io"
+ "os"
+ "sort"
)
// to the beginning of the offending token.
//
type ErrorHandler interface {
- Error(pos token.Position, msg string);
+ Error(pos token.Position, msg string)
}
// error handling is obtained.
//
type ErrorVector struct {
- errors vector.Vector;
+ errors vector.Vector
}
// Reset resets an ErrorVector to no errors.
-func (h *ErrorVector) Reset() { h.errors.Resize(0, 0) }
+func (h *ErrorVector) Reset() { h.errors.Resize(0, 0) }
// ErrorCount returns the number of errors collected.
-func (h *ErrorVector) ErrorCount() int { return h.errors.Len() }
+func (h *ErrorVector) ErrorCount() int { return h.errors.Len() }
// Within ErrorVector, an error is represented by an Error node. The
// token, and the error condition is described by Msg.
//
type Error struct {
- Pos token.Position;
- Msg string;
+ Pos token.Position
+ Msg string
}
// TODO(gri) reconsider the semantics of Position.IsValid
return e.Pos.String() + ": " + e.Msg
}
- return e.Msg;
+ return e.Msg
}
// ErrorList implements the sort Interface.
-func (p ErrorList) Len() int { return len(p) }
-func (p ErrorList) Swap(i, j int) { p[i], p[j] = p[j], p[i] }
+func (p ErrorList) Len() int { return len(p) }
+func (p ErrorList) Swap(i, j int) { p[i], p[j] = p[j], p[i] }
func (p ErrorList) Less(i, j int) bool {
- e := &p[i].Pos;
- f := &p[j].Pos;
+ e := &p[i].Pos
+ f := &p[j].Pos
// Note that it is not sufficient to simply compare file offsets because
// the offsets do not reflect modified line information (through //line
// comments).
return e.Column < f.Column
}
}
- return false;
+ return false
}
case 1:
return p[0].String()
}
- return fmt.Sprintf("%s (and %d more errors)", p[0].String(), len(p)-1);
+ return fmt.Sprintf("%s (and %d more errors)", p[0].String(), len(p)-1)
}
// returned by GetErrors.
//
const (
- Raw = iota; // leave error list unchanged
- Sorted; // sort error list by file, line, and column number
- NoMultiples; // sort error list and leave only the first error per line
+ Raw = iota // leave error list unchanged
+ Sorted // sort error list by file, line, and column number
+ NoMultiples // sort error list and leave only the first error per line
)
return nil
}
- list := make(ErrorList, h.errors.Len());
+ list := make(ErrorList, h.errors.Len())
for i := 0; i < h.errors.Len(); i++ {
list[i] = h.errors.At(i).(*Error)
}
}
if mode >= NoMultiples {
- var last token.Position; // initial last.Line is != any legal error line
- i := 0;
+ var last token.Position // initial last.Line is != any legal error line
+ i := 0
for _, e := range list {
if e.Pos.Filename != last.Filename || e.Pos.Line != last.Line {
- last = e.Pos;
- list[i] = e;
- i++;
+ last = e.Pos
+ list[i] = e
+ i++
}
}
- list = list[0:i];
+ list = list[0:i]
}
- return list;
+ return list
}
return nil
}
- return h.GetErrorList(mode);
+ return h.GetErrorList(mode)
}
package scanner
import (
- "bytes";
- "go/token";
- "strconv";
- "unicode";
- "utf8";
+ "bytes"
+ "go/token"
+ "strconv"
+ "unicode"
+ "utf8"
)
//
type Scanner struct {
// immutable state
- src []byte; // source
- err ErrorHandler; // error reporting; or nil
- mode uint; // scanning mode
+ src []byte // source
+ err ErrorHandler // error reporting; or nil
+ mode uint // scanning mode
// scanning state
- pos token.Position; // previous reading position (position before ch)
- offset int; // current reading offset (position after ch)
- ch int; // one char look-ahead
- insertSemi bool; // insert a semicolon before next newline
+ pos token.Position // previous reading position (position before ch)
+ offset int // current reading offset (position after ch)
+ ch int // one char look-ahead
+ insertSemi bool // insert a semicolon before next newline
// public state - ok to modify
- ErrorCount int; // number of errors encountered
+ ErrorCount int // number of errors encountered
}
//
func (S *Scanner) next() {
if S.offset < len(S.src) {
- S.pos.Offset = S.offset;
- S.pos.Column++;
- r, w := int(S.src[S.offset]), 1;
+ S.pos.Offset = S.offset
+ S.pos.Column++
+ r, w := int(S.src[S.offset]), 1
switch {
case r == '\n':
- S.pos.Line++;
- S.pos.Column = 0;
+ S.pos.Line++
+ S.pos.Column = 0
case r >= 0x80:
// not ASCII
r, w = utf8.DecodeRune(S.src[S.offset:])
}
- S.offset += w;
- S.ch = r;
+ S.offset += w
+ S.ch = r
} else {
- S.pos.Offset = len(S.src);
- S.ch = -1; // eof
+ S.pos.Offset = len(S.src)
+ S.ch = -1 // eof
}
}
// They control scanner behavior.
//
const (
- ScanComments = 1 << iota; // return comments as COMMENT tokens
- AllowIllegalChars; // do not report an error for illegal chars
- InsertSemis; // automatically insert semicolons
+ ScanComments = 1 << iota // return comments as COMMENT tokens
+ AllowIllegalChars // do not report an error for illegal chars
+ InsertSemis // automatically insert semicolons
)
//
func (S *Scanner) Init(filename string, src []byte, err ErrorHandler, mode uint) {
// Explicitly initialize all fields since a scanner may be reused.
- S.src = src;
- S.err = err;
- S.mode = mode;
- S.pos = token.Position{filename, 0, 1, 0};
- S.offset = 0;
- S.ErrorCount = 0;
- S.next();
+ S.src = src
+ S.err = err
+ S.mode = mode
+ S.pos = token.Position{filename, 0, 1, 0}
+ S.offset = 0
+ S.ErrorCount = 0
+ S.next()
}
func charString(ch int) string {
- var s string;
+ var s string
switch ch {
case -1:
return `EOF`
default:
s = string(ch)
}
- return "'" + s + "' (U+" + strconv.Itob(ch, 16) + ")";
+ return "'" + s + "' (U+" + strconv.Itob(ch, 16) + ")"
}
if S.err != nil {
S.err.Error(pos, msg)
}
- S.ErrorCount++;
+ S.ErrorCount++
}
if S.ch != ch {
S.error(S.pos, "expected "+charString(ch)+", found "+charString(S.ch))
}
- S.next(); // always make progress
+ S.next() // always make progress
}
-var prefix = []byte{'l', 'i', 'n', 'e', ' '} // "line "
+var prefix = []byte{'l', 'i', 'n', 'e', ' '} // "line "
func (S *Scanner) scanComment(pos token.Position) {
// first '/' already consumed
if S.ch == '/' {
//-style comment
for S.ch >= 0 {
- S.next();
+ S.next()
if S.ch == '\n' {
// '\n' is not part of the comment for purposes of scanning
// (the comment ends on the same line where it started)
if pos.Column == 1 {
- text := S.src[pos.Offset+2 : S.pos.Offset];
+ text := S.src[pos.Offset+2 : S.pos.Offset]
if bytes.HasPrefix(text, prefix) {
// comment starts at beginning of line with "//line ";
// get filename and line number, if any
- i := bytes.Index(text, []byte{':'});
+ i := bytes.Index(text, []byte{':'})
if i >= 0 {
if line, err := strconv.Atoi(string(text[i+1:])); err == nil && line > 0 {
// valid //line filename:line comment;
// update scanner position
- S.pos.Filename = string(text[len(prefix):i]);
- S.pos.Line = line;
+ S.pos.Filename = string(text[len(prefix):i])
+ S.pos.Line = line
}
}
}
}
- return;
+ return
}
}
} else {
/*-style comment */
- S.expect('*');
+ S.expect('*')
for S.ch >= 0 {
- ch := S.ch;
- S.next();
+ ch := S.ch
+ S.next()
if ch == '*' && S.ch == '/' {
- S.next();
- return;
+ S.next()
+ return
}
}
}
- S.error(pos, "comment not terminated");
+ S.error(pos, "comment not terminated")
}
// first '/' already consumed; assume S.ch == '/' || S.ch == '*'
// read ahead until a newline or non-comment token is found
- newline := false;
+ newline := false
for pos1 := pos; S.ch >= 0; {
if S.ch == '/' {
//-style comment always contains a newline
- newline = true;
- break;
+ newline = true
+ break
}
- S.scanComment(pos1);
+ S.scanComment(pos1)
if pos1.Line < S.pos.Line {
/*-style comment contained a newline */
- newline = true;
- break;
+ newline = true
+ break
}
- S.skipWhitespace();
+ S.skipWhitespace()
if S.ch == '\n' {
- newline = true;
- break;
+ newline = true
+ break
}
if S.ch != '/' {
// non-comment token
break
}
- pos1 = S.pos;
- S.next();
+ pos1 = S.pos
+ S.next()
if S.ch != '/' && S.ch != '*' {
// non-comment token
break
}
// reset position
- S.pos = pos;
- S.offset = pos.Offset + 1;
- S.ch = '/';
+ S.pos = pos
+ S.offset = pos.Offset + 1
+ S.ch = '/'
- return newline;
+ return newline
}
func (S *Scanner) scanIdentifier() token.Token {
- pos := S.pos.Offset;
+ pos := S.pos.Offset
for isLetter(S.ch) || isDigit(S.ch) {
S.next()
}
- return token.Lookup(S.src[pos:S.pos.Offset]);
+ return token.Lookup(S.src[pos:S.pos.Offset])
}
case 'A' <= ch && ch <= 'F':
return ch - 'A' + 10
}
- return 16; // larger than any legal digit val
+ return 16 // larger than any legal digit val
}
func (S *Scanner) scanNumber(seen_decimal_point bool) token.Token {
- tok := token.INT;
+ tok := token.INT
if seen_decimal_point {
- tok = token.FLOAT;
- S.scanMantissa(10);
- goto exponent;
+ tok = token.FLOAT
+ S.scanMantissa(10)
+ goto exponent
}
if S.ch == '0' {
// int or float
- S.next();
+ S.next()
if S.ch == 'x' || S.ch == 'X' {
// hexadecimal int
- S.next();
- S.scanMantissa(16);
+ S.next()
+ S.scanMantissa(16)
} else {
// octal int or float
- S.scanMantissa(8);
+ S.scanMantissa(8)
if digitVal(S.ch) < 10 || S.ch == '.' || S.ch == 'e' || S.ch == 'E' {
// float
- tok = token.FLOAT;
- goto mantissa;
+ tok = token.FLOAT
+ goto mantissa
}
// octal int
}
- goto exit;
+ goto exit
}
mantissa:
// decimal int or float
- S.scanMantissa(10);
+ S.scanMantissa(10)
if S.ch == '.' {
// float
- tok = token.FLOAT;
- S.next();
- S.scanMantissa(10);
+ tok = token.FLOAT
+ S.next()
+ S.scanMantissa(10)
}
exponent:
if S.ch == 'e' || S.ch == 'E' {
// float
- tok = token.FLOAT;
- S.next();
+ tok = token.FLOAT
+ S.next()
if S.ch == '-' || S.ch == '+' {
S.next()
}
- S.scanMantissa(10);
+ S.scanMantissa(10)
}
exit:
- return tok;
+ return tok
}
func (S *Scanner) scanDigits(base, length int) {
for length > 0 && digitVal(S.ch) < base {
- S.next();
- length--;
+ S.next()
+ length--
}
if length > 0 {
S.error(S.pos, "illegal char escape")
func (S *Scanner) scanEscape(quote int) {
- pos := S.pos;
- ch := S.ch;
- S.next();
+ pos := S.pos
+ ch := S.ch
+ S.next()
switch ch {
case 'a', 'b', 'f', 'n', 'r', 't', 'v', '\\', quote:
// nothing to do
case '0', '1', '2', '3', '4', '5', '6', '7':
- S.scanDigits(8, 3-1) // 1 char read already
+ S.scanDigits(8, 3-1) // 1 char read already
case 'x':
S.scanDigits(16, 2)
case 'u':
func (S *Scanner) scanChar(pos token.Position) {
// '\'' already consumed
- n := 0;
+ n := 0
for S.ch != '\'' {
- ch := S.ch;
- n++;
- S.next();
+ ch := S.ch
+ n++
+ S.next()
if ch == '\n' || ch < 0 {
- S.error(pos, "character literal not terminated");
- n = 1;
- break;
+ S.error(pos, "character literal not terminated")
+ n = 1
+ break
}
if ch == '\\' {
S.scanEscape('\'')
}
}
- S.next();
+ S.next()
if n != 1 {
S.error(pos, "illegal character literal")
// '"' already consumed
for S.ch != '"' {
- ch := S.ch;
- S.next();
+ ch := S.ch
+ S.next()
if ch == '\n' || ch < 0 {
- S.error(pos, "string not terminated");
- break;
+ S.error(pos, "string not terminated")
+ break
}
if ch == '\\' {
S.scanEscape('"')
}
}
- S.next();
+ S.next()
}
// '`' already consumed
for S.ch != '`' {
- ch := S.ch;
- S.next();
+ ch := S.ch
+ S.next()
if ch < 0 {
- S.error(pos, "string not terminated");
- break;
+ S.error(pos, "string not terminated")
+ break
}
}
- S.next();
+ S.next()
}
func (S *Scanner) switch2(tok0, tok1 token.Token) token.Token {
if S.ch == '=' {
- S.next();
- return tok1;
+ S.next()
+ return tok1
}
- return tok0;
+ return tok0
}
func (S *Scanner) switch3(tok0, tok1 token.Token, ch2 int, tok2 token.Token) token.Token {
if S.ch == '=' {
- S.next();
- return tok1;
+ S.next()
+ return tok1
}
if S.ch == ch2 {
- S.next();
- return tok2;
+ S.next()
+ return tok2
}
- return tok0;
+ return tok0
}
func (S *Scanner) switch4(tok0, tok1 token.Token, ch2 int, tok2, tok3 token.Token) token.Token {
if S.ch == '=' {
- S.next();
- return tok1;
+ S.next()
+ return tok1
}
if S.ch == ch2 {
- S.next();
+ S.next()
if S.ch == '=' {
- S.next();
- return tok3;
+ S.next()
+ return tok3
}
- return tok2;
+ return tok2
}
- return tok0;
+ return tok0
}
//
func (S *Scanner) Scan() (pos token.Position, tok token.Token, lit []byte) {
scanAgain:
- S.skipWhitespace();
+ S.skipWhitespace()
// current token start
- insertSemi := false;
- pos, tok = S.pos, token.ILLEGAL;
+ insertSemi := false
+ pos, tok = S.pos, token.ILLEGAL
// determine token value
switch ch := S.ch; {
case isLetter(ch):
- tok = S.scanIdentifier();
+ tok = S.scanIdentifier()
switch tok {
case token.IDENT, token.BREAK, token.CONTINUE, token.FALLTHROUGH, token.RETURN:
insertSemi = true
}
case digitVal(ch) < 10:
- insertSemi = true;
- tok = S.scanNumber(false);
+ insertSemi = true
+ tok = S.scanNumber(false)
default:
- S.next(); // always make progress
+ S.next() // always make progress
switch ch {
case -1:
tok = token.EOF
// we only reach here of S.insertSemi was
// set in the first place and exited early
// from S.skipWhitespace()
- S.insertSemi = false; // newline consumed
- return pos, token.SEMICOLON, semicolon;
+ S.insertSemi = false // newline consumed
+ return pos, token.SEMICOLON, semicolon
case '"':
- insertSemi = true;
- tok = token.STRING;
- S.scanString(pos);
+ insertSemi = true
+ tok = token.STRING
+ S.scanString(pos)
case '\'':
- insertSemi = true;
- tok = token.CHAR;
- S.scanChar(pos);
+ insertSemi = true
+ tok = token.CHAR
+ S.scanChar(pos)
case '`':
- insertSemi = true;
- tok = token.STRING;
- S.scanRawString(pos);
+ insertSemi = true
+ tok = token.STRING
+ S.scanRawString(pos)
case ':':
tok = S.switch2(token.COLON, token.DEFINE)
case '.':
if digitVal(S.ch) < 10 {
- insertSemi = true;
- tok = S.scanNumber(true);
+ insertSemi = true
+ tok = S.scanNumber(true)
} else if S.ch == '.' {
- S.next();
+ S.next()
if S.ch == '.' {
- S.next();
- tok = token.ELLIPSIS;
+ S.next()
+ tok = token.ELLIPSIS
}
} else {
tok = token.PERIOD
case '(':
tok = token.LPAREN
case ')':
- insertSemi = true;
- tok = token.RPAREN;
+ insertSemi = true
+ tok = token.RPAREN
case '[':
tok = token.LBRACK
case ']':
- insertSemi = true;
- tok = token.RBRACK;
+ insertSemi = true
+ tok = token.RBRACK
case '{':
tok = token.LBRACE
case '}':
- insertSemi = true;
- tok = token.RBRACE;
+ insertSemi = true
+ tok = token.RBRACE
case '+':
- tok = S.switch3(token.ADD, token.ADD_ASSIGN, '+', token.INC);
+ tok = S.switch3(token.ADD, token.ADD_ASSIGN, '+', token.INC)
if tok == token.INC {
insertSemi = true
}
case '-':
- tok = S.switch3(token.SUB, token.SUB_ASSIGN, '-', token.DEC);
+ tok = S.switch3(token.SUB, token.SUB_ASSIGN, '-', token.DEC)
if tok == token.DEC {
insertSemi = true
}
if S.ch == '/' || S.ch == '*' {
// comment
if S.insertSemi && S.findNewline(pos) {
- S.insertSemi = false; // newline consumed
- return pos, token.SEMICOLON, semicolon;
+ S.insertSemi = false // newline consumed
+ return pos, token.SEMICOLON, semicolon
}
- S.scanComment(pos);
+ S.scanComment(pos)
if S.mode&ScanComments == 0 {
// skip comment
- S.insertSemi = false; // newline consumed
- goto scanAgain;
+ S.insertSemi = false // newline consumed
+ goto scanAgain
}
- tok = token.COMMENT;
+ tok = token.COMMENT
} else {
tok = S.switch2(token.QUO, token.QUO_ASSIGN)
}
tok = S.switch2(token.XOR, token.XOR_ASSIGN)
case '<':
if S.ch == '-' {
- S.next();
- tok = token.ARROW;
+ S.next()
+ tok = token.ARROW
} else {
tok = S.switch4(token.LSS, token.LEQ, '<', token.SHL, token.SHL_ASSIGN)
}
tok = S.switch2(token.NOT, token.NEQ)
case '&':
if S.ch == '^' {
- S.next();
- tok = S.switch2(token.AND_NOT, token.AND_NOT_ASSIGN);
+ S.next()
+ tok = S.switch2(token.AND_NOT, token.AND_NOT_ASSIGN)
} else {
tok = S.switch3(token.AND, token.AND_ASSIGN, '&', token.LAND)
}
if S.mode&AllowIllegalChars == 0 {
S.error(pos, "illegal character "+charString(ch))
}
- insertSemi = S.insertSemi; // preserve insertSemi info
+ insertSemi = S.insertSemi // preserve insertSemi info
}
}
if S.mode&InsertSemis != 0 {
S.insertSemi = insertSemi
}
- return pos, tok, S.src[pos.Offset:S.pos.Offset];
+ return pos, tok, S.src[pos.Offset:S.pos.Offset]
}
// of errors encountered.
//
func Tokenize(filename string, src []byte, err ErrorHandler, mode uint, f func(pos token.Position, tok token.Token, lit []byte) bool) int {
- var s Scanner;
- s.Init(filename, src, err, mode);
+ var s Scanner
+ s.Init(filename, src, err, mode)
for f(s.Scan()) {
// action happens in f
}
- return s.ErrorCount;
+ return s.ErrorCount
}
package scanner
import (
- "go/token";
- "os";
- "strings";
- "testing";
+ "go/token"
+ "os"
+ "strings"
+ "testing"
)
const /* class */ (
- special = iota;
- literal;
- operator;
- keyword;
+ special = iota
+ literal
+ operator
+ keyword
)
case tok.IsKeyword():
return keyword
}
- return special;
+ return special
}
type elt struct {
- tok token.Token;
- lit string;
- class int;
+ tok token.Token
+ lit string
+ class int
}
}
-const whitespace = " \t \n\n\n" // to separate tokens
+const whitespace = " \t \n\n\n" // to separate tokens
type TestErrorHandler struct {
- t *testing.T;
+ t *testing.T
}
func (h *TestErrorHandler) Error(pos token.Position, msg string) {
func NewlineCount(s string) int {
- n := 0;
+ n := 0
for i := 0; i < len(s); i++ {
if s[i] == '\n' {
n++
}
}
- return n;
+ return n
}
// Verify that calling Scan() provides the correct results.
func TestScan(t *testing.T) {
// make source
- var src string;
+ var src string
for _, e := range tokens {
src += e.lit + whitespace
}
- whitespace_linecount := NewlineCount(whitespace);
+ whitespace_linecount := NewlineCount(whitespace)
// verify scan
- index := 0;
- epos := token.Position{"", 0, 1, 1};
+ index := 0
+ epos := token.Position{"", 0, 1, 1}
nerrors := Tokenize("", strings.Bytes(src), &TestErrorHandler{t}, ScanComments,
func(pos token.Position, tok token.Token, litb []byte) bool {
- e := elt{token.EOF, "", special};
+ e := elt{token.EOF, "", special}
if index < len(tokens) {
e = tokens[index]
}
- lit := string(litb);
+ lit := string(litb)
if tok == token.EOF {
- lit = "<EOF>";
- epos.Column = 0;
+ lit = "<EOF>"
+ epos.Column = 0
}
- checkPos(t, lit, pos, epos);
+ checkPos(t, lit, pos, epos)
if tok != e.tok {
t.Errorf("bad token for %q: got %s, expected %s", lit, tok.String(), e.tok.String())
}
if tokenclass(tok) != e.class {
t.Errorf("bad class for %q: got %d, expected %d", lit, tokenclass(tok), e.class)
}
- epos.Offset += len(lit) + len(whitespace);
- epos.Line += NewlineCount(lit) + whitespace_linecount;
+ epos.Offset += len(lit) + len(whitespace)
+ epos.Line += NewlineCount(lit) + whitespace_linecount
if tok == token.COMMENT && litb[1] == '/' {
// correct for unaccounted '/n' in //-style comment
- epos.Offset++;
- epos.Line++;
+ epos.Offset++
+ epos.Line++
}
- index++;
- return tok != token.EOF;
- });
+ index++
+ return tok != token.EOF
+ })
if nerrors != 0 {
t.Errorf("found %d errors", nerrors)
}
func checkSemi(t *testing.T, line string, mode uint) {
- var S Scanner;
- S.Init("TestSemis", strings.Bytes(line), nil, mode);
- pos, tok, lit := S.Scan();
+ var S Scanner
+ S.Init("TestSemis", strings.Bytes(line), nil, mode)
+ pos, tok, lit := S.Scan()
for tok != token.EOF {
if tok == token.ILLEGAL {
// next token must be a semicolon
- offs := pos.Offset + 1;
- pos, tok, lit = S.Scan();
+ offs := pos.Offset + 1
+ pos, tok, lit = S.Scan()
if tok == token.SEMICOLON {
if pos.Offset != offs {
t.Errorf("bad offset for %q: got %d, expected %d", line, pos.Offset, offs)
} else if tok == token.SEMICOLON {
t.Errorf("bad token for %q: got ;, expected no ;", line)
}
- pos, tok, lit = S.Scan();
+ pos, tok, lit = S.Scan()
}
}
type seg struct {
- srcline string; // a line of source text
- filename string; // filename for current token
- line int; // line number for current token
+ srcline string // a line of source text
+ filename string // filename for current token
+ line int // line number for current token
}
// exactly one token per line since the test consumes one token per segment
seg{" line1", "TestLineComments", 1},
seg{"\nline2", "TestLineComments", 2},
- seg{"\nline3 //line File1.go:100", "TestLineComments", 3}, // bad line comment, ignored
+ seg{"\nline3 //line File1.go:100", "TestLineComments", 3}, // bad line comment, ignored
seg{"\nline4", "TestLineComments", 4},
seg{"\n//line File1.go:100\n line100", "File1.go", 100},
seg{"\n//line File2.go:200\n line200", "File2.go", 200},
seg{"\n//line :1\n line1", "", 1},
seg{"\n//line foo:42\n line42", "foo", 42},
- seg{"\n //line foo:42\n line44", "foo", 44}, // bad line comment, ignored
- seg{"\n//line foo 42\n line46", "foo", 46}, // bad line comment, ignored
- seg{"\n//line foo:42 extra text\n line48", "foo", 48}, // bad line comment, ignored
+ seg{"\n //line foo:42\n line44", "foo", 44}, // bad line comment, ignored
+ seg{"\n//line foo 42\n line46", "foo", 46}, // bad line comment, ignored
+ seg{"\n//line foo:42 extra text\n line48", "foo", 48}, // bad line comment, ignored
seg{"\n//line foo:42\n line42", "foo", 42},
seg{"\n//line foo:42\n line42", "foo", 42},
seg{"\n//line File1.go:100\n line100", "File1.go", 100},
// Verify that comments of the form "//line filename:line" are interpreted correctly.
func TestLineComments(t *testing.T) {
// make source
- var src string;
+ var src string
for _, e := range segments {
src += e.srcline
}
// verify scan
- var S Scanner;
- S.Init("TestLineComments", strings.Bytes(src), nil, 0);
+ var S Scanner
+ S.Init("TestLineComments", strings.Bytes(src), nil, 0)
for _, s := range segments {
- pos, _, lit := S.Scan();
- checkPos(t, string(lit), pos, token.Position{s.filename, pos.Offset, s.line, pos.Column});
+ pos, _, lit := S.Scan()
+ checkPos(t, string(lit), pos, token.Position{s.filename, pos.Offset, s.line, pos.Column})
}
if S.ErrorCount != 0 {
// Verify that initializing the same scanner more then once works correctly.
func TestInit(t *testing.T) {
- var s Scanner;
+ var s Scanner
// 1st init
- s.Init("", strings.Bytes("if true { }"), nil, 0);
- s.Scan(); // if
- s.Scan(); // true
- _, tok, _ := s.Scan(); // {
+ s.Init("", strings.Bytes("if true { }"), nil, 0)
+ s.Scan() // if
+ s.Scan() // true
+ _, tok, _ := s.Scan() // {
if tok != token.LBRACE {
t.Errorf("bad token: got %s, expected %s", tok.String(), token.LBRACE)
}
// 2nd init
- s.Init("", strings.Bytes("go true { ]"), nil, 0);
- _, tok, _ = s.Scan(); // go
+ s.Init("", strings.Bytes("go true { ]"), nil, 0)
+ _, tok, _ = s.Scan() // go
if tok != token.GO {
t.Errorf("bad token: got %s, expected %s", tok.String(), token.GO)
}
func TestIllegalChars(t *testing.T) {
- var s Scanner;
+ var s Scanner
- const src = "*?*$*@*";
- s.Init("", strings.Bytes(src), &TestErrorHandler{t}, AllowIllegalChars);
+ const src = "*?*$*@*"
+ s.Init("", strings.Bytes(src), &TestErrorHandler{t}, AllowIllegalChars)
for offs, ch := range src {
- pos, tok, lit := s.Scan();
+ pos, tok, lit := s.Scan()
if pos.Offset != offs {
t.Errorf("bad position for %s: got %d, expected %d", string(lit), pos.Offset, offs)
}
func TestStdErrorHander(t *testing.T) {
- const src = "@\n" + // illegal character, cause an error
- "@ @\n" + // two errors on the same line
+ const src = "@\n" + // illegal character, cause an error
+ "@ @\n" + // two errors on the same line
"//line File2:20\n" +
- "@\n" + // different file, but same line
+ "@\n" + // different file, but same line
"//line File2:1\n" +
- "@ @\n" + // same file, decreasing line number
+ "@ @\n" + // same file, decreasing line number
"//line File1:1\n" +
- "@ @ @"; // original file, line 1 again
+ "@ @ @" // original file, line 1 again
- v := new(ErrorVector);
+ v := new(ErrorVector)
nerrors := Tokenize("File1", strings.Bytes(src), v, 0,
func(pos token.Position, tok token.Token, litb []byte) bool {
return tok != token.EOF
- });
+ })
- list := v.GetErrorList(Raw);
+ list := v.GetErrorList(Raw)
if len(list) != 9 {
- t.Errorf("found %d raw errors, expected 9", len(list));
- PrintError(os.Stderr, list);
+ t.Errorf("found %d raw errors, expected 9", len(list))
+ PrintError(os.Stderr, list)
}
- list = v.GetErrorList(Sorted);
+ list = v.GetErrorList(Sorted)
if len(list) != 9 {
- t.Errorf("found %d sorted errors, expected 9", len(list));
- PrintError(os.Stderr, list);
+ t.Errorf("found %d sorted errors, expected 9", len(list))
+ PrintError(os.Stderr, list)
}
- list = v.GetErrorList(NoMultiples);
+ list = v.GetErrorList(NoMultiples)
if len(list) != 4 {
- t.Errorf("found %d one-per-line errors, expected 4", len(list));
- PrintError(os.Stderr, list);
+ t.Errorf("found %d one-per-line errors, expected 4", len(list))
+ PrintError(os.Stderr, list)
}
if v.ErrorCount() != nerrors {
package token
import (
- "fmt";
- "strconv";
+ "fmt"
+ "strconv"
)
// The list of tokens.
const (
// Special tokens
- ILLEGAL Token = iota;
- EOF;
- COMMENT;
+ ILLEGAL Token = iota
+ EOF
+ COMMENT
- literal_beg;
+ literal_beg
// Identifiers and basic type literals
// (these tokens stand for classes of literals)
- IDENT; // main
- INT; // 12345
- FLOAT; // 123.45
- CHAR; // 'a'
- STRING; // "abc"
- literal_end;
-
- operator_beg;
+ IDENT // main
+ INT // 12345
+ FLOAT // 123.45
+ CHAR // 'a'
+ STRING // "abc"
+ literal_end
+
+ operator_beg
// Operators and delimiters
- ADD; // +
- SUB; // -
- MUL; // *
- QUO; // /
- REM; // %
-
- AND; // &
- OR; // |
- XOR; // ^
- SHL; // <<
- SHR; // >>
- AND_NOT; // &^
-
- ADD_ASSIGN; // +=
- SUB_ASSIGN; // -=
- MUL_ASSIGN; // *=
- QUO_ASSIGN; // /=
- REM_ASSIGN; // %=
-
- AND_ASSIGN; // &=
- OR_ASSIGN; // |=
- XOR_ASSIGN; // ^=
- SHL_ASSIGN; // <<=
- SHR_ASSIGN; // >>=
- AND_NOT_ASSIGN; // &^=
-
- LAND; // &&
- LOR; // ||
- ARROW; // <-
- INC; // ++
- DEC; // --
-
- EQL; // ==
- LSS; // <
- GTR; // >
- ASSIGN; // =
- NOT; // !
-
- NEQ; // !=
- LEQ; // <=
- GEQ; // >=
- DEFINE; // :=
- ELLIPSIS; // ...
-
- LPAREN; // (
- LBRACK; // [
- LBRACE; // {
- COMMA; // ,
- PERIOD; // .
-
- RPAREN; // )
- RBRACK; // ]
- RBRACE; // }
- SEMICOLON; // ;
- COLON; // :
- operator_end;
-
- keyword_beg;
+ ADD // +
+ SUB // -
+ MUL // *
+ QUO // /
+ REM // %
+
+ AND // &
+ OR // |
+ XOR // ^
+ SHL // <<
+ SHR // >>
+ AND_NOT // &^
+
+ ADD_ASSIGN // +=
+ SUB_ASSIGN // -=
+ MUL_ASSIGN // *=
+ QUO_ASSIGN // /=
+ REM_ASSIGN // %=
+
+ AND_ASSIGN // &=
+ OR_ASSIGN // |=
+ XOR_ASSIGN // ^=
+ SHL_ASSIGN // <<=
+ SHR_ASSIGN // >>=
+ AND_NOT_ASSIGN // &^=
+
+ LAND // &&
+ LOR // ||
+ ARROW // <-
+ INC // ++
+ DEC // --
+
+ EQL // ==
+ LSS // <
+ GTR // >
+ ASSIGN // =
+ NOT // !
+
+ NEQ // !=
+ LEQ // <=
+ GEQ // >=
+ DEFINE // :=
+ ELLIPSIS // ...
+
+ LPAREN // (
+ LBRACK // [
+ LBRACE // {
+ COMMA // ,
+ PERIOD // .
+
+ RPAREN // )
+ RBRACK // ]
+ RBRACE // }
+ SEMICOLON // ;
+ COLON // :
+ operator_end
+
+ keyword_beg
// Keywords
- BREAK;
- CASE;
- CHAN;
- CONST;
- CONTINUE;
-
- DEFAULT;
- DEFER;
- ELSE;
- FALLTHROUGH;
- FOR;
-
- FUNC;
- GO;
- GOTO;
- IF;
- IMPORT;
-
- INTERFACE;
- MAP;
- PACKAGE;
- RANGE;
- RETURN;
-
- SELECT;
- STRUCT;
- SWITCH;
- TYPE;
- VAR;
- keyword_end;
+ BREAK
+ CASE
+ CHAN
+ CONST
+ CONTINUE
+
+ DEFAULT
+ DEFER
+ ELSE
+ FALLTHROUGH
+ FOR
+
+ FUNC
+ GO
+ GOTO
+ IF
+ IMPORT
+
+ INTERFACE
+ MAP
+ PACKAGE
+ RANGE
+ RETURN
+
+ SELECT
+ STRUCT
+ SWITCH
+ TYPE
+ VAR
+ keyword_end
)
if str, exists := tokens[tok]; exists {
return str
}
- return "token(" + strconv.Itoa(int(tok)) + ")";
+ return "token(" + strconv.Itoa(int(tok)) + ")"
}
// selector, indexing, and other operator and delimiter tokens.
//
const (
- LowestPrec = 0; // non-operators
- UnaryPrec = 7;
- HighestPrec = 8;
+ LowestPrec = 0 // non-operators
+ UnaryPrec = 7
+ HighestPrec = 8
)
case MUL, QUO, REM, SHL, SHR, AND, AND_NOT:
return 6
}
- return LowestPrec;
+ return LowestPrec
}
var keywords map[string]Token
func init() {
- keywords = make(map[string]Token);
+ keywords = make(map[string]Token)
for i := keyword_beg + 1; i < keyword_end; i++ {
keywords[tokens[i]] = i
}
if tok, is_keyword := keywords[string(ident)]; is_keyword {
return tok
}
- return IDENT;
+ return IDENT
}
// IsLiteral returns true for tokens corresponding to identifiers
// and basic type literals; returns false otherwise.
//
-func (tok Token) IsLiteral() bool { return literal_beg < tok && tok < literal_end }
+func (tok Token) IsLiteral() bool { return literal_beg < tok && tok < literal_end }
// IsOperator returns true for tokens corresponding to operators and
// delimiters; returns false otherwise.
//
-func (tok Token) IsOperator() bool { return operator_beg < tok && tok < operator_end }
+func (tok Token) IsOperator() bool { return operator_beg < tok && tok < operator_end }
// IsKeyword returns true for tokens corresponding to keywords;
// returns false otherwise.
//
-func (tok Token) IsKeyword() bool { return keyword_beg < tok && tok < keyword_end }
+func (tok Token) IsKeyword() bool { return keyword_beg < tok && tok < keyword_end }
// Token source positions are represented by a Position value.
// A Position is valid if the line number is > 0.
//
type Position struct {
- Filename string; // filename, if any
- Offset int; // byte offset, starting at 0
- Line int; // line number, starting at 1
- Column int; // column number, starting at 1 (character count)
+ Filename string // filename, if any
+ Offset int // byte offset, starting at 0
+ Line int // line number, starting at 1
+ Column int // column number, starting at 1 (character count)
}
// Pos is an accessor method for anonymous Position fields.
// It returns its receiver.
//
-func (pos *Position) Pos() Position { return *pos }
+func (pos *Position) Pos() Position { return *pos }
// IsValid returns true if the position is valid.
-func (pos *Position) IsValid() bool { return pos.Line > 0 }
+func (pos *Position) IsValid() bool { return pos.Line > 0 }
func (pos Position) String() string {
- s := pos.Filename;
+ s := pos.Filename
if pos.IsValid() {
if s != "" {
s += ":"
}
- s += fmt.Sprintf("%d:%d", pos.Line, pos.Column);
+ s += fmt.Sprintf("%d:%d", pos.Line, pos.Column)
}
if s == "" {
s = "???"
}
- return s;
+ return s
}
package gob
import (
- "bytes";
- "math";
- "os";
- "reflect";
- "strings";
- "testing";
- "unsafe";
+ "bytes"
+ "math"
+ "os"
+ "reflect"
+ "strings"
+ "testing"
+ "unsafe"
)
// Guarantee encoding format by comparing some encodings to hand-written values
type EncodeT struct {
- x uint64;
- b []byte;
+ x uint64
+ b []byte
}
var encodeT = []EncodeT{
// Test basic encode/decode routines for unsigned integers
func TestUintCodec(t *testing.T) {
- b := new(bytes.Buffer);
- encState := new(encoderState);
- encState.b = b;
+ b := new(bytes.Buffer)
+ encState := new(encoderState)
+ encState.b = b
for _, tt := range encodeT {
- b.Reset();
- encodeUint(encState, tt.x);
+ b.Reset()
+ encodeUint(encState, tt.x)
if encState.err != nil {
t.Error("encodeUint:", tt.x, encState.err)
}
t.Errorf("encodeUint: %#x encode: expected % x got % x", tt.x, tt.b, b.Bytes())
}
}
- decState := newDecodeState(b);
+ decState := newDecodeState(b)
for u := uint64(0); ; u = (u + 1) * 7 {
- b.Reset();
- encodeUint(encState, u);
+ b.Reset()
+ encodeUint(encState, u)
if encState.err != nil {
t.Error("encodeUint:", u, encState.err)
}
- v := decodeUint(decState);
+ v := decodeUint(decState)
if decState.err != nil {
t.Error("DecodeUint:", u, decState.err)
}
}
func verifyInt(i int64, t *testing.T) {
- var b = new(bytes.Buffer);
- encState := new(encoderState);
- encState.b = b;
- encodeInt(encState, i);
+ var b = new(bytes.Buffer)
+ encState := new(encoderState)
+ encState.b = b
+ encodeInt(encState, i)
if encState.err != nil {
t.Error("encodeInt:", i, encState.err)
}
- decState := newDecodeState(b);
- decState.buf = make([]byte, 8);
- j := decodeInt(decState);
+ decState := newDecodeState(b)
+ decState.buf = make([]byte, 8)
+ j := decodeInt(decState)
if decState.err != nil {
t.Error("DecodeInt:", i, decState.err)
}
func TestIntCodec(t *testing.T) {
for u := uint64(0); ; u = (u + 1) * 7 {
// Do positive and negative values
- i := int64(u);
- verifyInt(i, t);
- verifyInt(-i, t);
- verifyInt(^i, t);
+ i := int64(u)
+ verifyInt(i, t)
+ verifyInt(-i, t)
+ verifyInt(^i, t)
if u&(1<<63) != 0 {
break
}
}
- verifyInt(-1<<63, t); // a tricky case
+ verifyInt(-1<<63, t) // a tricky case
}
// The result of encoding a true boolean with field number 7
var bytesResult = []byte{0x07, 0x05, 'h', 'e', 'l', 'l', 'o'}
func newencoderState(b *bytes.Buffer) *encoderState {
- b.Reset();
- state := new(encoderState);
- state.b = b;
- state.fieldnum = -1;
- return state;
+ b.Reset()
+ state := new(encoderState)
+ state.b = b
+ state.fieldnum = -1
+ return state
}
// Test instruction execution for encoding.
// Do not run the machine yet; instead do individual instructions crafted by hand.
func TestScalarEncInstructions(t *testing.T) {
- var b = new(bytes.Buffer);
+ var b = new(bytes.Buffer)
// bool
{
- data := struct{ a bool }{true};
- instr := &encInstr{encBool, 6, 0, 0};
- state := newencoderState(b);
- instr.op(instr, state, unsafe.Pointer(&data));
+ data := struct{ a bool }{true}
+ instr := &encInstr{encBool, 6, 0, 0}
+ state := newencoderState(b)
+ instr.op(instr, state, unsafe.Pointer(&data))
if !bytes.Equal(boolResult, b.Bytes()) {
t.Errorf("bool enc instructions: expected % x got % x", boolResult, b.Bytes())
}
// int
{
- b.Reset();
- data := struct{ a int }{17};
- instr := &encInstr{encInt, 6, 0, 0};
- state := newencoderState(b);
- instr.op(instr, state, unsafe.Pointer(&data));
+ b.Reset()
+ data := struct{ a int }{17}
+ instr := &encInstr{encInt, 6, 0, 0}
+ state := newencoderState(b)
+ instr.op(instr, state, unsafe.Pointer(&data))
if !bytes.Equal(signedResult, b.Bytes()) {
t.Errorf("int enc instructions: expected % x got % x", signedResult, b.Bytes())
}
// uint
{
- b.Reset();
- data := struct{ a uint }{17};
- instr := &encInstr{encUint, 6, 0, 0};
- state := newencoderState(b);
- instr.op(instr, state, unsafe.Pointer(&data));
+ b.Reset()
+ data := struct{ a uint }{17}
+ instr := &encInstr{encUint, 6, 0, 0}
+ state := newencoderState(b)
+ instr.op(instr, state, unsafe.Pointer(&data))
if !bytes.Equal(unsignedResult, b.Bytes()) {
t.Errorf("uint enc instructions: expected % x got % x", unsignedResult, b.Bytes())
}
// int8
{
- b.Reset();
- data := struct{ a int8 }{17};
- instr := &encInstr{encInt8, 6, 0, 0};
- state := newencoderState(b);
- instr.op(instr, state, unsafe.Pointer(&data));
+ b.Reset()
+ data := struct{ a int8 }{17}
+ instr := &encInstr{encInt8, 6, 0, 0}
+ state := newencoderState(b)
+ instr.op(instr, state, unsafe.Pointer(&data))
if !bytes.Equal(signedResult, b.Bytes()) {
t.Errorf("int8 enc instructions: expected % x got % x", signedResult, b.Bytes())
}
// uint8
{
- b.Reset();
- data := struct{ a uint8 }{17};
- instr := &encInstr{encUint8, 6, 0, 0};
- state := newencoderState(b);
- instr.op(instr, state, unsafe.Pointer(&data));
+ b.Reset()
+ data := struct{ a uint8 }{17}
+ instr := &encInstr{encUint8, 6, 0, 0}
+ state := newencoderState(b)
+ instr.op(instr, state, unsafe.Pointer(&data))
if !bytes.Equal(unsignedResult, b.Bytes()) {
t.Errorf("uint8 enc instructions: expected % x got % x", unsignedResult, b.Bytes())
}
// int16
{
- b.Reset();
- data := struct{ a int16 }{17};
- instr := &encInstr{encInt16, 6, 0, 0};
- state := newencoderState(b);
- instr.op(instr, state, unsafe.Pointer(&data));
+ b.Reset()
+ data := struct{ a int16 }{17}
+ instr := &encInstr{encInt16, 6, 0, 0}
+ state := newencoderState(b)
+ instr.op(instr, state, unsafe.Pointer(&data))
if !bytes.Equal(signedResult, b.Bytes()) {
t.Errorf("int16 enc instructions: expected % x got % x", signedResult, b.Bytes())
}
// uint16
{
- b.Reset();
- data := struct{ a uint16 }{17};
- instr := &encInstr{encUint16, 6, 0, 0};
- state := newencoderState(b);
- instr.op(instr, state, unsafe.Pointer(&data));
+ b.Reset()
+ data := struct{ a uint16 }{17}
+ instr := &encInstr{encUint16, 6, 0, 0}
+ state := newencoderState(b)
+ instr.op(instr, state, unsafe.Pointer(&data))
if !bytes.Equal(unsignedResult, b.Bytes()) {
t.Errorf("uint16 enc instructions: expected % x got % x", unsignedResult, b.Bytes())
}
// int32
{
- b.Reset();
- data := struct{ a int32 }{17};
- instr := &encInstr{encInt32, 6, 0, 0};
- state := newencoderState(b);
- instr.op(instr, state, unsafe.Pointer(&data));
+ b.Reset()
+ data := struct{ a int32 }{17}
+ instr := &encInstr{encInt32, 6, 0, 0}
+ state := newencoderState(b)
+ instr.op(instr, state, unsafe.Pointer(&data))
if !bytes.Equal(signedResult, b.Bytes()) {
t.Errorf("int32 enc instructions: expected % x got % x", signedResult, b.Bytes())
}
// uint32
{
- b.Reset();
- data := struct{ a uint32 }{17};
- instr := &encInstr{encUint32, 6, 0, 0};
- state := newencoderState(b);
- instr.op(instr, state, unsafe.Pointer(&data));
+ b.Reset()
+ data := struct{ a uint32 }{17}
+ instr := &encInstr{encUint32, 6, 0, 0}
+ state := newencoderState(b)
+ instr.op(instr, state, unsafe.Pointer(&data))
if !bytes.Equal(unsignedResult, b.Bytes()) {
t.Errorf("uint32 enc instructions: expected % x got % x", unsignedResult, b.Bytes())
}
// int64
{
- b.Reset();
- data := struct{ a int64 }{17};
- instr := &encInstr{encInt64, 6, 0, 0};
- state := newencoderState(b);
- instr.op(instr, state, unsafe.Pointer(&data));
+ b.Reset()
+ data := struct{ a int64 }{17}
+ instr := &encInstr{encInt64, 6, 0, 0}
+ state := newencoderState(b)
+ instr.op(instr, state, unsafe.Pointer(&data))
if !bytes.Equal(signedResult, b.Bytes()) {
t.Errorf("int64 enc instructions: expected % x got % x", signedResult, b.Bytes())
}
// uint64
{
- b.Reset();
- data := struct{ a uint64 }{17};
- instr := &encInstr{encUint64, 6, 0, 0};
- state := newencoderState(b);
- instr.op(instr, state, unsafe.Pointer(&data));
+ b.Reset()
+ data := struct{ a uint64 }{17}
+ instr := &encInstr{encUint64, 6, 0, 0}
+ state := newencoderState(b)
+ instr.op(instr, state, unsafe.Pointer(&data))
if !bytes.Equal(unsignedResult, b.Bytes()) {
t.Errorf("uint64 enc instructions: expected % x got % x", unsignedResult, b.Bytes())
}
// float
{
- b.Reset();
- data := struct{ a float }{17};
- instr := &encInstr{encFloat, 6, 0, 0};
- state := newencoderState(b);
- instr.op(instr, state, unsafe.Pointer(&data));
+ b.Reset()
+ data := struct{ a float }{17}
+ instr := &encInstr{encFloat, 6, 0, 0}
+ state := newencoderState(b)
+ instr.op(instr, state, unsafe.Pointer(&data))
if !bytes.Equal(floatResult, b.Bytes()) {
t.Errorf("float enc instructions: expected % x got % x", floatResult, b.Bytes())
}
// float32
{
- b.Reset();
- data := struct{ a float32 }{17};
- instr := &encInstr{encFloat32, 6, 0, 0};
- state := newencoderState(b);
- instr.op(instr, state, unsafe.Pointer(&data));
+ b.Reset()
+ data := struct{ a float32 }{17}
+ instr := &encInstr{encFloat32, 6, 0, 0}
+ state := newencoderState(b)
+ instr.op(instr, state, unsafe.Pointer(&data))
if !bytes.Equal(floatResult, b.Bytes()) {
t.Errorf("float32 enc instructions: expected % x got % x", floatResult, b.Bytes())
}
// float64
{
- b.Reset();
- data := struct{ a float64 }{17};
- instr := &encInstr{encFloat64, 6, 0, 0};
- state := newencoderState(b);
- instr.op(instr, state, unsafe.Pointer(&data));
+ b.Reset()
+ data := struct{ a float64 }{17}
+ instr := &encInstr{encFloat64, 6, 0, 0}
+ state := newencoderState(b)
+ instr.op(instr, state, unsafe.Pointer(&data))
if !bytes.Equal(floatResult, b.Bytes()) {
t.Errorf("float64 enc instructions: expected % x got % x", floatResult, b.Bytes())
}
// bytes == []uint8
{
- b.Reset();
- data := struct{ a []byte }{strings.Bytes("hello")};
- instr := &encInstr{encUint8Array, 6, 0, 0};
- state := newencoderState(b);
- instr.op(instr, state, unsafe.Pointer(&data));
+ b.Reset()
+ data := struct{ a []byte }{strings.Bytes("hello")}
+ instr := &encInstr{encUint8Array, 6, 0, 0}
+ state := newencoderState(b)
+ instr.op(instr, state, unsafe.Pointer(&data))
if !bytes.Equal(bytesResult, b.Bytes()) {
t.Errorf("bytes enc instructions: expected % x got % x", bytesResult, b.Bytes())
}
// string
{
- b.Reset();
- data := struct{ a string }{"hello"};
- instr := &encInstr{encString, 6, 0, 0};
- state := newencoderState(b);
- instr.op(instr, state, unsafe.Pointer(&data));
+ b.Reset()
+ data := struct{ a string }{"hello"}
+ instr := &encInstr{encString, 6, 0, 0}
+ state := newencoderState(b)
+ instr.op(instr, state, unsafe.Pointer(&data))
if !bytes.Equal(bytesResult, b.Bytes()) {
t.Errorf("string enc instructions: expected % x got % x", bytesResult, b.Bytes())
}
}
func execDec(typ string, instr *decInstr, state *decodeState, t *testing.T, p unsafe.Pointer) {
- v := int(decodeUint(state));
+ v := int(decodeUint(state))
if state.err != nil {
t.Fatalf("decoding %s field: %v", typ, state.err)
}
if v+state.fieldnum != 6 {
t.Fatalf("decoding field number %d, got %d", 6, v+state.fieldnum)
}
- instr.op(instr, state, decIndirect(p, instr.indir));
- state.fieldnum = 6;
+ instr.op(instr, state, decIndirect(p, instr.indir))
+ state.fieldnum = 6
}
func newDecodeStateFromData(data []byte) *decodeState {
- state := newDecodeState(bytes.NewBuffer(data));
- state.fieldnum = -1;
- return state;
+ state := newDecodeState(bytes.NewBuffer(data))
+ state.fieldnum = -1
+ return state
}
// Test instruction execution for decoding.
// Do not run the machine yet; instead do individual instructions crafted by hand.
func TestScalarDecInstructions(t *testing.T) {
- ovfl := os.ErrorString("overflow");
+ ovfl := os.ErrorString("overflow")
// bool
{
var data struct {
- a bool;
+ a bool
}
- instr := &decInstr{decBool, 6, 0, 0, ovfl};
- state := newDecodeStateFromData(boolResult);
- execDec("bool", instr, state, t, unsafe.Pointer(&data));
+ instr := &decInstr{decBool, 6, 0, 0, ovfl}
+ state := newDecodeStateFromData(boolResult)
+ execDec("bool", instr, state, t, unsafe.Pointer(&data))
if data.a != true {
t.Errorf("bool a = %v not true", data.a)
}
// int
{
var data struct {
- a int;
+ a int
}
- instr := &decInstr{decOpMap[valueKind(data.a)], 6, 0, 0, ovfl};
- state := newDecodeStateFromData(signedResult);
- execDec("int", instr, state, t, unsafe.Pointer(&data));
+ instr := &decInstr{decOpMap[valueKind(data.a)], 6, 0, 0, ovfl}
+ state := newDecodeStateFromData(signedResult)
+ execDec("int", instr, state, t, unsafe.Pointer(&data))
if data.a != 17 {
t.Errorf("int a = %v not 17", data.a)
}
// uint
{
var data struct {
- a uint;
+ a uint
}
- instr := &decInstr{decOpMap[valueKind(data.a)], 6, 0, 0, ovfl};
- state := newDecodeStateFromData(unsignedResult);
- execDec("uint", instr, state, t, unsafe.Pointer(&data));
+ instr := &decInstr{decOpMap[valueKind(data.a)], 6, 0, 0, ovfl}
+ state := newDecodeStateFromData(unsignedResult)
+ execDec("uint", instr, state, t, unsafe.Pointer(&data))
if data.a != 17 {
t.Errorf("uint a = %v not 17", data.a)
}
// int8
{
var data struct {
- a int8;
+ a int8
}
- instr := &decInstr{decInt8, 6, 0, 0, ovfl};
- state := newDecodeStateFromData(signedResult);
- execDec("int8", instr, state, t, unsafe.Pointer(&data));
+ instr := &decInstr{decInt8, 6, 0, 0, ovfl}
+ state := newDecodeStateFromData(signedResult)
+ execDec("int8", instr, state, t, unsafe.Pointer(&data))
if data.a != 17 {
t.Errorf("int8 a = %v not 17", data.a)
}
// uint8
{
var data struct {
- a uint8;
+ a uint8
}
- instr := &decInstr{decUint8, 6, 0, 0, ovfl};
- state := newDecodeStateFromData(unsignedResult);
- execDec("uint8", instr, state, t, unsafe.Pointer(&data));
+ instr := &decInstr{decUint8, 6, 0, 0, ovfl}
+ state := newDecodeStateFromData(unsignedResult)
+ execDec("uint8", instr, state, t, unsafe.Pointer(&data))
if data.a != 17 {
t.Errorf("uint8 a = %v not 17", data.a)
}
// int16
{
var data struct {
- a int16;
+ a int16
}
- instr := &decInstr{decInt16, 6, 0, 0, ovfl};
- state := newDecodeStateFromData(signedResult);
- execDec("int16", instr, state, t, unsafe.Pointer(&data));
+ instr := &decInstr{decInt16, 6, 0, 0, ovfl}
+ state := newDecodeStateFromData(signedResult)
+ execDec("int16", instr, state, t, unsafe.Pointer(&data))
if data.a != 17 {
t.Errorf("int16 a = %v not 17", data.a)
}
// uint16
{
var data struct {
- a uint16;
+ a uint16
}
- instr := &decInstr{decUint16, 6, 0, 0, ovfl};
- state := newDecodeStateFromData(unsignedResult);
- execDec("uint16", instr, state, t, unsafe.Pointer(&data));
+ instr := &decInstr{decUint16, 6, 0, 0, ovfl}
+ state := newDecodeStateFromData(unsignedResult)
+ execDec("uint16", instr, state, t, unsafe.Pointer(&data))
if data.a != 17 {
t.Errorf("uint16 a = %v not 17", data.a)
}
// int32
{
var data struct {
- a int32;
+ a int32
}
- instr := &decInstr{decInt32, 6, 0, 0, ovfl};
- state := newDecodeStateFromData(signedResult);
- execDec("int32", instr, state, t, unsafe.Pointer(&data));
+ instr := &decInstr{decInt32, 6, 0, 0, ovfl}
+ state := newDecodeStateFromData(signedResult)
+ execDec("int32", instr, state, t, unsafe.Pointer(&data))
if data.a != 17 {
t.Errorf("int32 a = %v not 17", data.a)
}
// uint32
{
var data struct {
- a uint32;
+ a uint32
}
- instr := &decInstr{decUint32, 6, 0, 0, ovfl};
- state := newDecodeStateFromData(unsignedResult);
- execDec("uint32", instr, state, t, unsafe.Pointer(&data));
+ instr := &decInstr{decUint32, 6, 0, 0, ovfl}
+ state := newDecodeStateFromData(unsignedResult)
+ execDec("uint32", instr, state, t, unsafe.Pointer(&data))
if data.a != 17 {
t.Errorf("uint32 a = %v not 17", data.a)
}
// uintptr
{
var data struct {
- a uintptr;
+ a uintptr
}
- instr := &decInstr{decOpMap[valueKind(data.a)], 6, 0, 0, ovfl};
- state := newDecodeStateFromData(unsignedResult);
- execDec("uintptr", instr, state, t, unsafe.Pointer(&data));
+ instr := &decInstr{decOpMap[valueKind(data.a)], 6, 0, 0, ovfl}
+ state := newDecodeStateFromData(unsignedResult)
+ execDec("uintptr", instr, state, t, unsafe.Pointer(&data))
if data.a != 17 {
t.Errorf("uintptr a = %v not 17", data.a)
}
// int64
{
var data struct {
- a int64;
+ a int64
}
- instr := &decInstr{decInt64, 6, 0, 0, ovfl};
- state := newDecodeStateFromData(signedResult);
- execDec("int64", instr, state, t, unsafe.Pointer(&data));
+ instr := &decInstr{decInt64, 6, 0, 0, ovfl}
+ state := newDecodeStateFromData(signedResult)
+ execDec("int64", instr, state, t, unsafe.Pointer(&data))
if data.a != 17 {
t.Errorf("int64 a = %v not 17", data.a)
}
// uint64
{
var data struct {
- a uint64;
+ a uint64
}
- instr := &decInstr{decUint64, 6, 0, 0, ovfl};
- state := newDecodeStateFromData(unsignedResult);
- execDec("uint64", instr, state, t, unsafe.Pointer(&data));
+ instr := &decInstr{decUint64, 6, 0, 0, ovfl}
+ state := newDecodeStateFromData(unsignedResult)
+ execDec("uint64", instr, state, t, unsafe.Pointer(&data))
if data.a != 17 {
t.Errorf("uint64 a = %v not 17", data.a)
}
// float
{
var data struct {
- a float;
+ a float
}
- instr := &decInstr{decOpMap[valueKind(data.a)], 6, 0, 0, ovfl};
- state := newDecodeStateFromData(floatResult);
- execDec("float", instr, state, t, unsafe.Pointer(&data));
+ instr := &decInstr{decOpMap[valueKind(data.a)], 6, 0, 0, ovfl}
+ state := newDecodeStateFromData(floatResult)
+ execDec("float", instr, state, t, unsafe.Pointer(&data))
if data.a != 17 {
t.Errorf("float a = %v not 17", data.a)
}
// float32
{
var data struct {
- a float32;
+ a float32
}
- instr := &decInstr{decFloat32, 6, 0, 0, ovfl};
- state := newDecodeStateFromData(floatResult);
- execDec("float32", instr, state, t, unsafe.Pointer(&data));
+ instr := &decInstr{decFloat32, 6, 0, 0, ovfl}
+ state := newDecodeStateFromData(floatResult)
+ execDec("float32", instr, state, t, unsafe.Pointer(&data))
if data.a != 17 {
t.Errorf("float32 a = %v not 17", data.a)
}
// float64
{
var data struct {
- a float64;
+ a float64
}
- instr := &decInstr{decFloat64, 6, 0, 0, ovfl};
- state := newDecodeStateFromData(floatResult);
- execDec("float64", instr, state, t, unsafe.Pointer(&data));
+ instr := &decInstr{decFloat64, 6, 0, 0, ovfl}
+ state := newDecodeStateFromData(floatResult)
+ execDec("float64", instr, state, t, unsafe.Pointer(&data))
if data.a != 17 {
t.Errorf("float64 a = %v not 17", data.a)
}
// bytes == []uint8
{
var data struct {
- a []byte;
+ a []byte
}
- instr := &decInstr{decUint8Array, 6, 0, 0, ovfl};
- state := newDecodeStateFromData(bytesResult);
- execDec("bytes", instr, state, t, unsafe.Pointer(&data));
+ instr := &decInstr{decUint8Array, 6, 0, 0, ovfl}
+ state := newDecodeStateFromData(bytesResult)
+ execDec("bytes", instr, state, t, unsafe.Pointer(&data))
if string(data.a) != "hello" {
t.Errorf(`bytes a = %q not "hello"`, string(data.a))
}
// string
{
var data struct {
- a string;
+ a string
}
- instr := &decInstr{decString, 6, 0, 0, ovfl};
- state := newDecodeStateFromData(bytesResult);
- execDec("bytes", instr, state, t, unsafe.Pointer(&data));
+ instr := &decInstr{decString, 6, 0, 0, ovfl}
+ state := newDecodeStateFromData(bytesResult)
+ execDec("bytes", instr, state, t, unsafe.Pointer(&data))
if data.a != "hello" {
t.Errorf(`bytes a = %q not "hello"`, data.a)
}
func TestEndToEnd(t *testing.T) {
type T2 struct {
- t string;
+ t string
}
- s1 := "string1";
- s2 := "string2";
+ s1 := "string1"
+ s2 := "string2"
type T1 struct {
- a, b, c int;
- n *[3]float;
- strs *[2]string;
- int64s *[]int64;
- s string;
- y []byte;
- t *T2;
+ a, b, c int
+ n *[3]float
+ strs *[2]string
+ int64s *[]int64
+ s string
+ y []byte
+ t *T2
}
t1 := &T1{
a: 17,
s: "Now is the time",
y: strings.Bytes("hello, sailor"),
t: &T2{"this is T2"},
- };
- b := new(bytes.Buffer);
- err := NewEncoder(b).Encode(t1);
+ }
+ b := new(bytes.Buffer)
+ err := NewEncoder(b).Encode(t1)
if err != nil {
t.Error("encode:", err)
}
- var _t1 T1;
- err = NewDecoder(b).Decode(&_t1);
+ var _t1 T1
+ err = NewDecoder(b).Decode(&_t1)
if err != nil {
t.Fatal("decode:", err)
}
func TestOverflow(t *testing.T) {
type inputT struct {
- maxi int64;
- mini int64;
- maxu uint64;
- maxf float64;
- minf float64;
- }
- var it inputT;
- var err os.Error;
- b := new(bytes.Buffer);
- enc := NewEncoder(b);
- dec := NewDecoder(b);
+ maxi int64
+ mini int64
+ maxu uint64
+ maxf float64
+ minf float64
+ }
+ var it inputT
+ var err os.Error
+ b := new(bytes.Buffer)
+ enc := NewEncoder(b)
+ dec := NewDecoder(b)
// int8
- b.Reset();
+ b.Reset()
it = inputT{
maxi: math.MaxInt8 + 1,
- };
+ }
type outi8 struct {
- maxi int8;
- mini int8;
+ maxi int8
+ mini int8
}
- var o1 outi8;
- enc.Encode(it);
- err = dec.Decode(&o1);
+ var o1 outi8
+ enc.Encode(it)
+ err = dec.Decode(&o1)
if err == nil || err.String() != `value for "maxi" out of range` {
t.Error("wrong overflow error for int8:", err)
}
it = inputT{
mini: math.MinInt8 - 1,
- };
- b.Reset();
- enc.Encode(it);
- err = dec.Decode(&o1);
+ }
+ b.Reset()
+ enc.Encode(it)
+ err = dec.Decode(&o1)
if err == nil || err.String() != `value for "mini" out of range` {
t.Error("wrong underflow error for int8:", err)
}
// int16
- b.Reset();
+ b.Reset()
it = inputT{
maxi: math.MaxInt16 + 1,
- };
+ }
type outi16 struct {
- maxi int16;
- mini int16;
+ maxi int16
+ mini int16
}
- var o2 outi16;
- enc.Encode(it);
- err = dec.Decode(&o2);
+ var o2 outi16
+ enc.Encode(it)
+ err = dec.Decode(&o2)
if err == nil || err.String() != `value for "maxi" out of range` {
t.Error("wrong overflow error for int16:", err)
}
it = inputT{
mini: math.MinInt16 - 1,
- };
- b.Reset();
- enc.Encode(it);
- err = dec.Decode(&o2);
+ }
+ b.Reset()
+ enc.Encode(it)
+ err = dec.Decode(&o2)
if err == nil || err.String() != `value for "mini" out of range` {
t.Error("wrong underflow error for int16:", err)
}
// int32
- b.Reset();
+ b.Reset()
it = inputT{
maxi: math.MaxInt32 + 1,
- };
+ }
type outi32 struct {
- maxi int32;
- mini int32;
+ maxi int32
+ mini int32
}
- var o3 outi32;
- enc.Encode(it);
- err = dec.Decode(&o3);
+ var o3 outi32
+ enc.Encode(it)
+ err = dec.Decode(&o3)
if err == nil || err.String() != `value for "maxi" out of range` {
t.Error("wrong overflow error for int32:", err)
}
it = inputT{
mini: math.MinInt32 - 1,
- };
- b.Reset();
- enc.Encode(it);
- err = dec.Decode(&o3);
+ }
+ b.Reset()
+ enc.Encode(it)
+ err = dec.Decode(&o3)
if err == nil || err.String() != `value for "mini" out of range` {
t.Error("wrong underflow error for int32:", err)
}
// uint8
- b.Reset();
+ b.Reset()
it = inputT{
maxu: math.MaxUint8 + 1,
- };
+ }
type outu8 struct {
- maxu uint8;
+ maxu uint8
}
- var o4 outu8;
- enc.Encode(it);
- err = dec.Decode(&o4);
+ var o4 outu8
+ enc.Encode(it)
+ err = dec.Decode(&o4)
if err == nil || err.String() != `value for "maxu" out of range` {
t.Error("wrong overflow error for uint8:", err)
}
// uint16
- b.Reset();
+ b.Reset()
it = inputT{
maxu: math.MaxUint16 + 1,
- };
+ }
type outu16 struct {
- maxu uint16;
+ maxu uint16
}
- var o5 outu16;
- enc.Encode(it);
- err = dec.Decode(&o5);
+ var o5 outu16
+ enc.Encode(it)
+ err = dec.Decode(&o5)
if err == nil || err.String() != `value for "maxu" out of range` {
t.Error("wrong overflow error for uint16:", err)
}
// uint32
- b.Reset();
+ b.Reset()
it = inputT{
maxu: math.MaxUint32 + 1,
- };
+ }
type outu32 struct {
- maxu uint32;
+ maxu uint32
}
- var o6 outu32;
- enc.Encode(it);
- err = dec.Decode(&o6);
+ var o6 outu32
+ enc.Encode(it)
+ err = dec.Decode(&o6)
if err == nil || err.String() != `value for "maxu" out of range` {
t.Error("wrong overflow error for uint32:", err)
}
// float32
- b.Reset();
+ b.Reset()
it = inputT{
maxf: math.MaxFloat32 * 2,
- };
+ }
type outf32 struct {
- maxf float32;
- minf float32;
+ maxf float32
+ minf float32
}
- var o7 outf32;
- enc.Encode(it);
- err = dec.Decode(&o7);
+ var o7 outf32
+ enc.Encode(it)
+ err = dec.Decode(&o7)
if err == nil || err.String() != `value for "maxf" out of range` {
t.Error("wrong overflow error for float32:", err)
}
func TestNesting(t *testing.T) {
type RT struct {
- a string;
- next *RT;
- }
- rt := new(RT);
- rt.a = "level1";
- rt.next = new(RT);
- rt.next.a = "level2";
- b := new(bytes.Buffer);
- NewEncoder(b).Encode(rt);
- var drt RT;
- dec := NewDecoder(b);
- err := dec.Decode(&drt);
+ a string
+ next *RT
+ }
+ rt := new(RT)
+ rt.a = "level1"
+ rt.next = new(RT)
+ rt.next.a = "level2"
+ b := new(bytes.Buffer)
+ NewEncoder(b).Encode(rt)
+ var drt RT
+ dec := NewDecoder(b)
+ err := dec.Decode(&drt)
if err != nil {
t.Errorf("decoder error:", err)
}
// These three structures have the same data with different indirections
type T0 struct {
- a int;
- b int;
- c int;
- d int;
+ a int
+ b int
+ c int
+ d int
}
type T1 struct {
- a int;
- b *int;
- c **int;
- d ***int;
+ a int
+ b *int
+ c **int
+ d ***int
}
type T2 struct {
- a ***int;
- b **int;
- c *int;
- d int;
+ a ***int
+ b **int
+ c *int
+ d int
}
func TestAutoIndirection(t *testing.T) {
// First transfer t1 into t0
- var t1 T1;
- t1.a = 17;
- t1.b = new(int);
- *t1.b = 177;
- t1.c = new(*int);
- *t1.c = new(int);
- **t1.c = 1777;
- t1.d = new(**int);
- *t1.d = new(*int);
- **t1.d = new(int);
- ***t1.d = 17777;
- b := new(bytes.Buffer);
- enc := NewEncoder(b);
- enc.Encode(t1);
- dec := NewDecoder(b);
- var t0 T0;
- dec.Decode(&t0);
+ var t1 T1
+ t1.a = 17
+ t1.b = new(int)
+ *t1.b = 177
+ t1.c = new(*int)
+ *t1.c = new(int)
+ **t1.c = 1777
+ t1.d = new(**int)
+ *t1.d = new(*int)
+ **t1.d = new(int)
+ ***t1.d = 17777
+ b := new(bytes.Buffer)
+ enc := NewEncoder(b)
+ enc.Encode(t1)
+ dec := NewDecoder(b)
+ var t0 T0
+ dec.Decode(&t0)
if t0.a != 17 || t0.b != 177 || t0.c != 1777 || t0.d != 17777 {
t.Errorf("t1->t0: expected {17 177 1777 17777}; got %v", t0)
}
// Now transfer t2 into t0
- var t2 T2;
- t2.d = 17777;
- t2.c = new(int);
- *t2.c = 1777;
- t2.b = new(*int);
- *t2.b = new(int);
- **t2.b = 177;
- t2.a = new(**int);
- *t2.a = new(*int);
- **t2.a = new(int);
- ***t2.a = 17;
- b.Reset();
- enc.Encode(t2);
- t0 = T0{};
- dec.Decode(&t0);
+ var t2 T2
+ t2.d = 17777
+ t2.c = new(int)
+ *t2.c = 1777
+ t2.b = new(*int)
+ *t2.b = new(int)
+ **t2.b = 177
+ t2.a = new(**int)
+ *t2.a = new(*int)
+ **t2.a = new(int)
+ ***t2.a = 17
+ b.Reset()
+ enc.Encode(t2)
+ t0 = T0{}
+ dec.Decode(&t0)
if t0.a != 17 || t0.b != 177 || t0.c != 1777 || t0.d != 17777 {
t.Errorf("t2->t0 expected {17 177 1777 17777}; got %v", t0)
}
// Now transfer t0 into t1
- t0 = T0{17, 177, 1777, 17777};
- b.Reset();
- enc.Encode(t0);
- t1 = T1{};
- dec.Decode(&t1);
+ t0 = T0{17, 177, 1777, 17777}
+ b.Reset()
+ enc.Encode(t0)
+ t1 = T1{}
+ dec.Decode(&t1)
if t1.a != 17 || *t1.b != 177 || **t1.c != 1777 || ***t1.d != 17777 {
t.Errorf("t0->t1 expected {17 177 1777 17777}; got {%d %d %d %d}", t1.a, *t1.b, **t1.c, ***t1.d)
}
// Now transfer t0 into t2
- b.Reset();
- enc.Encode(t0);
- t2 = T2{};
- dec.Decode(&t2);
+ b.Reset()
+ enc.Encode(t0)
+ t2 = T2{}
+ dec.Decode(&t2)
if ***t2.a != 17 || **t2.b != 177 || *t2.c != 1777 || t2.d != 17777 {
t.Errorf("t0->t2 expected {17 177 1777 17777}; got {%d %d %d %d}", ***t2.a, **t2.b, *t2.c, t2.d)
}
// Now do t2 again but without pre-allocated pointers.
- b.Reset();
- enc.Encode(t0);
- ***t2.a = 0;
- **t2.b = 0;
- *t2.c = 0;
- t2.d = 0;
- dec.Decode(&t2);
+ b.Reset()
+ enc.Encode(t0)
+ ***t2.a = 0
+ **t2.b = 0
+ *t2.c = 0
+ t2.d = 0
+ dec.Decode(&t2)
if ***t2.a != 17 || **t2.b != 177 || *t2.c != 1777 || t2.d != 17777 {
t.Errorf("t0->t2 expected {17 177 1777 17777}; got {%d %d %d %d}", ***t2.a, **t2.b, *t2.c, t2.d)
}
}
type RT0 struct {
- a int;
- b string;
- c float;
+ a int
+ b string
+ c float
}
type RT1 struct {
- c float;
- b string;
- a int;
- notSet string;
+ c float
+ b string
+ a int
+ notSet string
}
func TestReorderedFields(t *testing.T) {
- var rt0 RT0;
- rt0.a = 17;
- rt0.b = "hello";
- rt0.c = 3.14159;
- b := new(bytes.Buffer);
- NewEncoder(b).Encode(rt0);
- dec := NewDecoder(b);
- var rt1 RT1;
+ var rt0 RT0
+ rt0.a = 17
+ rt0.b = "hello"
+ rt0.c = 3.14159
+ b := new(bytes.Buffer)
+ NewEncoder(b).Encode(rt0)
+ dec := NewDecoder(b)
+ var rt1 RT1
// Wire type is RT0, local type is RT1.
- err := dec.Decode(&rt1);
+ err := dec.Decode(&rt1)
if err != nil {
t.Error("decode error:", err)
}
// Like an RT0 but with fields we'll ignore on the decode side.
type IT0 struct {
- a int64;
- b string;
- ignore_d []int;
- ignore_e [3]float;
- ignore_f bool;
- ignore_g string;
- ignore_h []byte;
- ignore_i *RT1;
- c float;
+ a int64
+ b string
+ ignore_d []int
+ ignore_e [3]float
+ ignore_f bool
+ ignore_g string
+ ignore_h []byte
+ ignore_i *RT1
+ c float
}
func TestIgnoredFields(t *testing.T) {
- var it0 IT0;
- it0.a = 17;
- it0.b = "hello";
- it0.c = 3.14159;
- it0.ignore_d = []int{1, 2, 3};
- it0.ignore_e[0] = 1.0;
- it0.ignore_e[1] = 2.0;
- it0.ignore_e[2] = 3.0;
- it0.ignore_f = true;
- it0.ignore_g = "pay no attention";
- it0.ignore_h = strings.Bytes("to the curtain");
- it0.ignore_i = &RT1{3.1, "hi", 7, "hello"};
-
- b := new(bytes.Buffer);
- NewEncoder(b).Encode(it0);
- dec := NewDecoder(b);
- var rt1 RT1;
+ var it0 IT0
+ it0.a = 17
+ it0.b = "hello"
+ it0.c = 3.14159
+ it0.ignore_d = []int{1, 2, 3}
+ it0.ignore_e[0] = 1.0
+ it0.ignore_e[1] = 2.0
+ it0.ignore_e[2] = 3.0
+ it0.ignore_f = true
+ it0.ignore_g = "pay no attention"
+ it0.ignore_h = strings.Bytes("to the curtain")
+ it0.ignore_i = &RT1{3.1, "hi", 7, "hello"}
+
+ b := new(bytes.Buffer)
+ NewEncoder(b).Encode(it0)
+ dec := NewDecoder(b)
+ var rt1 RT1
// Wire type is IT0, local type is RT1.
- err := dec.Decode(&rt1);
+ err := dec.Decode(&rt1)
if err != nil {
t.Error("error: ", err)
}
}
type Bad0 struct {
- inter interface{};
- c float;
+ inter interface{}
+ c float
}
func TestInvalidField(t *testing.T) {
- var bad0 Bad0;
- bad0.inter = 17;
- b := new(bytes.Buffer);
- err := encode(b, &bad0);
+ var bad0 Bad0
+ bad0.inter = 17
+ b := new(bytes.Buffer)
+ err := encode(b, &bad0)
if err == nil {
t.Error("expected error; got none")
} else if strings.Index(err.String(), "interface") < 0 {
// the allocations in this file that use unsafe.Pointer.
import (
- "bytes";
- "io";
- "math";
- "os";
- "reflect";
- "runtime";
- "unsafe";
+ "bytes"
+ "io"
+ "math"
+ "os"
+ "reflect"
+ "runtime"
+ "unsafe"
)
var (
- errBadUint = os.ErrorString("gob: encoded unsigned integer out of range");
- errBadType = os.ErrorString("gob: unknown type id or corrupted data");
- errRange = os.ErrorString("gob: internal error: field numbers out of bounds");
- errNotStruct = os.ErrorString("gob: TODO: can only handle structs");
+ errBadUint = os.ErrorString("gob: encoded unsigned integer out of range")
+ errBadType = os.ErrorString("gob: unknown type id or corrupted data")
+ errRange = os.ErrorString("gob: internal error: field numbers out of bounds")
+ errNotStruct = os.ErrorString("gob: TODO: can only handle structs")
)
// The global execution state of an instance of the decoder.
type decodeState struct {
- b *bytes.Buffer;
- err os.Error;
- fieldnum int; // the last field number read.
- buf []byte;
+ b *bytes.Buffer
+ err os.Error
+ fieldnum int // the last field number read.
+ buf []byte
}
func newDecodeState(b *bytes.Buffer) *decodeState {
- d := new(decodeState);
- d.b = b;
- d.buf = make([]byte, uint64Size);
- return d;
+ d := new(decodeState)
+ d.b = b
+ d.buf = make([]byte, uint64Size)
+ return d
}
func overflow(name string) os.ErrorString {
// decodeUintReader reads an encoded unsigned integer from an io.Reader.
// Used only by the Decoder to read the message length.
func decodeUintReader(r io.Reader, buf []byte) (x uint64, err os.Error) {
- _, err = r.Read(buf[0:1]);
+ _, err = r.Read(buf[0:1])
if err != nil {
return
}
- b := buf[0];
+ b := buf[0]
if b <= 0x7f {
return uint64(b), nil
}
- nb := -int(int8(b));
+ nb := -int(int8(b))
if nb > uint64Size {
- err = errBadUint;
- return;
+ err = errBadUint
+ return
}
- var n int;
- n, err = io.ReadFull(r, buf[0:nb]);
+ var n int
+ n, err = io.ReadFull(r, buf[0:nb])
if err != nil {
if err == os.EOF {
err = io.ErrUnexpectedEOF
}
- return;
+ return
}
// Could check that the high byte is zero but it's not worth it.
for i := 0; i < n; i++ {
- x <<= 8;
- x |= uint64(buf[i]);
+ x <<= 8
+ x |= uint64(buf[i])
}
- return;
+ return
}
// decodeUint reads an encoded unsigned integer from state.r.
if state.err != nil {
return
}
- var b uint8;
- b, state.err = state.b.ReadByte();
- if b <= 0x7f { // includes state.err != nil
+ var b uint8
+ b, state.err = state.b.ReadByte()
+ if b <= 0x7f { // includes state.err != nil
return uint64(b)
}
- nb := -int(int8(b));
+ nb := -int(int8(b))
if nb > uint64Size {
- state.err = errBadUint;
- return;
+ state.err = errBadUint
+ return
}
- var n int;
- n, state.err = state.b.Read(state.buf[0:nb]);
+ var n int
+ n, state.err = state.b.Read(state.buf[0:nb])
// Don't need to check error; it's safe to loop regardless.
// Could check that the high byte is zero but it's not worth it.
for i := 0; i < n; i++ {
- x <<= 8;
- x |= uint64(state.buf[i]);
+ x <<= 8
+ x |= uint64(state.buf[i])
}
- return x;
+ return x
}
// decodeInt reads an encoded signed integer from state.r.
// Sets state.err. If state.err is already non-nil, it does nothing.
// Does not check for overflow.
func decodeInt(state *decodeState) int64 {
- x := decodeUint(state);
+ x := decodeUint(state)
if state.err != nil {
return 0
}
if x&1 != 0 {
return ^int64(x >> 1)
}
- return int64(x >> 1);
+ return int64(x >> 1)
}
type decOp func(i *decInstr, state *decodeState, p unsafe.Pointer)
// The 'instructions' of the decoding machine
type decInstr struct {
- op decOp;
- field int; // field number of the wire type
- indir int; // how many pointer indirections to reach the value in the struct
- offset uintptr; // offset in the structure of the field to encode
- ovfl os.ErrorString; // error message for overflow/underflow (for arrays, of the elements)
+ op decOp
+ field int // field number of the wire type
+ indir int // how many pointer indirections to reach the value in the struct
+ offset uintptr // offset in the structure of the field to encode
+ ovfl os.ErrorString // error message for overflow/underflow (for arrays, of the elements)
}
// Since the encoder writes no zeros, if we arrive at a decoder we have
// Allocation required
*(*unsafe.Pointer)(p) = unsafe.Pointer(new(unsafe.Pointer))
}
- p = *(*unsafe.Pointer)(p);
+ p = *(*unsafe.Pointer)(p)
}
- return p;
+ return p
}
func ignoreUint(i *decInstr, state *decodeState, p unsafe.Pointer) {
if *(*unsafe.Pointer)(p) == nil {
*(*unsafe.Pointer)(p) = unsafe.Pointer(new(bool))
}
- p = *(*unsafe.Pointer)(p);
+ p = *(*unsafe.Pointer)(p)
}
- *(*bool)(p) = decodeInt(state) != 0;
+ *(*bool)(p) = decodeInt(state) != 0
}
func decInt8(i *decInstr, state *decodeState, p unsafe.Pointer) {
if *(*unsafe.Pointer)(p) == nil {
*(*unsafe.Pointer)(p) = unsafe.Pointer(new(int8))
}
- p = *(*unsafe.Pointer)(p);
+ p = *(*unsafe.Pointer)(p)
}
- v := decodeInt(state);
+ v := decodeInt(state)
if v < math.MinInt8 || math.MaxInt8 < v {
state.err = i.ovfl
} else {
if *(*unsafe.Pointer)(p) == nil {
*(*unsafe.Pointer)(p) = unsafe.Pointer(new(uint8))
}
- p = *(*unsafe.Pointer)(p);
+ p = *(*unsafe.Pointer)(p)
}
- v := decodeUint(state);
+ v := decodeUint(state)
if math.MaxUint8 < v {
state.err = i.ovfl
} else {
if *(*unsafe.Pointer)(p) == nil {
*(*unsafe.Pointer)(p) = unsafe.Pointer(new(int16))
}
- p = *(*unsafe.Pointer)(p);
+ p = *(*unsafe.Pointer)(p)
}
- v := decodeInt(state);
+ v := decodeInt(state)
if v < math.MinInt16 || math.MaxInt16 < v {
state.err = i.ovfl
} else {
if *(*unsafe.Pointer)(p) == nil {
*(*unsafe.Pointer)(p) = unsafe.Pointer(new(uint16))
}
- p = *(*unsafe.Pointer)(p);
+ p = *(*unsafe.Pointer)(p)
}
- v := decodeUint(state);
+ v := decodeUint(state)
if math.MaxUint16 < v {
state.err = i.ovfl
} else {
if *(*unsafe.Pointer)(p) == nil {
*(*unsafe.Pointer)(p) = unsafe.Pointer(new(int32))
}
- p = *(*unsafe.Pointer)(p);
+ p = *(*unsafe.Pointer)(p)
}
- v := decodeInt(state);
+ v := decodeInt(state)
if v < math.MinInt32 || math.MaxInt32 < v {
state.err = i.ovfl
} else {
if *(*unsafe.Pointer)(p) == nil {
*(*unsafe.Pointer)(p) = unsafe.Pointer(new(uint32))
}
- p = *(*unsafe.Pointer)(p);
+ p = *(*unsafe.Pointer)(p)
}
- v := decodeUint(state);
+ v := decodeUint(state)
if math.MaxUint32 < v {
state.err = i.ovfl
} else {
if *(*unsafe.Pointer)(p) == nil {
*(*unsafe.Pointer)(p) = unsafe.Pointer(new(int64))
}
- p = *(*unsafe.Pointer)(p);
+ p = *(*unsafe.Pointer)(p)
}
- *(*int64)(p) = int64(decodeInt(state));
+ *(*int64)(p) = int64(decodeInt(state))
}
func decUint64(i *decInstr, state *decodeState, p unsafe.Pointer) {
if *(*unsafe.Pointer)(p) == nil {
*(*unsafe.Pointer)(p) = unsafe.Pointer(new(uint64))
}
- p = *(*unsafe.Pointer)(p);
+ p = *(*unsafe.Pointer)(p)
}
- *(*uint64)(p) = uint64(decodeUint(state));
+ *(*uint64)(p) = uint64(decodeUint(state))
}
// Floating-point numbers are transmitted as uint64s holding the bits
// (for example) transmit more compactly. This routine does the
// unswizzling.
func floatFromBits(u uint64) float64 {
- var v uint64;
+ var v uint64
for i := 0; i < 8; i++ {
- v <<= 8;
- v |= u & 0xFF;
- u >>= 8;
+ v <<= 8
+ v |= u & 0xFF
+ u >>= 8
}
- return math.Float64frombits(v);
+ return math.Float64frombits(v)
}
func decFloat32(i *decInstr, state *decodeState, p unsafe.Pointer) {
if *(*unsafe.Pointer)(p) == nil {
*(*unsafe.Pointer)(p) = unsafe.Pointer(new(float32))
}
- p = *(*unsafe.Pointer)(p);
+ p = *(*unsafe.Pointer)(p)
}
- v := floatFromBits(decodeUint(state));
- av := v;
+ v := floatFromBits(decodeUint(state))
+ av := v
if av < 0 {
av = -av
}
- if math.MaxFloat32 < av { // underflow is OK
+ if math.MaxFloat32 < av { // underflow is OK
state.err = i.ovfl
} else {
*(*float32)(p) = float32(v)
if *(*unsafe.Pointer)(p) == nil {
*(*unsafe.Pointer)(p) = unsafe.Pointer(new(float64))
}
- p = *(*unsafe.Pointer)(p);
+ p = *(*unsafe.Pointer)(p)
}
- *(*float64)(p) = floatFromBits(uint64(decodeUint(state)));
+ *(*float64)(p) = floatFromBits(uint64(decodeUint(state)))
}
// uint8 arrays are encoded as an unsigned count followed by the raw bytes.
if *(*unsafe.Pointer)(p) == nil {
*(*unsafe.Pointer)(p) = unsafe.Pointer(new([]uint8))
}
- p = *(*unsafe.Pointer)(p);
+ p = *(*unsafe.Pointer)(p)
}
- b := make([]uint8, decodeUint(state));
- state.b.Read(b);
- *(*[]uint8)(p) = b;
+ b := make([]uint8, decodeUint(state))
+ state.b.Read(b)
+ *(*[]uint8)(p) = b
}
// Strings are encoded as an unsigned count followed by the raw bytes.
if *(*unsafe.Pointer)(p) == nil {
*(*unsafe.Pointer)(p) = unsafe.Pointer(new([]byte))
}
- p = *(*unsafe.Pointer)(p);
+ p = *(*unsafe.Pointer)(p)
}
- b := make([]byte, decodeUint(state));
- state.b.Read(b);
- *(*string)(p) = string(b);
+ b := make([]byte, decodeUint(state))
+ state.b.Read(b)
+ *(*string)(p) = string(b)
}
func ignoreUint8Array(i *decInstr, state *decodeState, p unsafe.Pointer) {
- b := make([]byte, decodeUint(state));
- state.b.Read(b);
+ b := make([]byte, decodeUint(state))
+ state.b.Read(b)
}
// Execution engine
// The encoder engine is an array of instructions indexed by field number of the incoming
// decoder. It is executed with random access according to field number.
type decEngine struct {
- instr []decInstr;
- numInstr int; // the number of active instructions
+ instr []decInstr
+ numInstr int // the number of active instructions
}
func decodeStruct(engine *decEngine, rtyp *reflect.StructType, b *bytes.Buffer, p uintptr, indir int) os.Error {
if indir > 0 {
- up := unsafe.Pointer(p);
+ up := unsafe.Pointer(p)
if indir > 1 {
up = decIndirect(up, indir)
}
// Allocate object.
*(*unsafe.Pointer)(up) = unsafe.New((*runtime.StructType)(unsafe.Pointer(rtyp)))
}
- p = *(*uintptr)(up);
+ p = *(*uintptr)(up)
}
- state := newDecodeState(b);
- state.fieldnum = -1;
- basep := p;
+ state := newDecodeState(b)
+ state.fieldnum = -1
+ basep := p
for state.err == nil {
- delta := int(decodeUint(state));
+ delta := int(decodeUint(state))
if delta < 0 {
- state.err = os.ErrorString("gob decode: corrupted data: negative delta");
- break;
+ state.err = os.ErrorString("gob decode: corrupted data: negative delta")
+ break
}
- if state.err != nil || delta == 0 { // struct terminator is zero delta fieldnum
+ if state.err != nil || delta == 0 { // struct terminator is zero delta fieldnum
break
}
- fieldnum := state.fieldnum + delta;
+ fieldnum := state.fieldnum + delta
if fieldnum >= len(engine.instr) {
- state.err = errRange;
- break;
+ state.err = errRange
+ break
}
- instr := &engine.instr[fieldnum];
- p := unsafe.Pointer(basep + instr.offset);
+ instr := &engine.instr[fieldnum]
+ p := unsafe.Pointer(basep + instr.offset)
if instr.indir > 1 {
p = decIndirect(p, instr.indir)
}
- instr.op(instr, state, p);
- state.fieldnum = fieldnum;
+ instr.op(instr, state, p)
+ state.fieldnum = fieldnum
}
- return state.err;
+ return state.err
}
func ignoreStruct(engine *decEngine, b *bytes.Buffer) os.Error {
- state := newDecodeState(b);
- state.fieldnum = -1;
+ state := newDecodeState(b)
+ state.fieldnum = -1
for state.err == nil {
- delta := int(decodeUint(state));
+ delta := int(decodeUint(state))
if delta < 0 {
- state.err = os.ErrorString("gob ignore decode: corrupted data: negative delta");
- break;
+ state.err = os.ErrorString("gob ignore decode: corrupted data: negative delta")
+ break
}
- if state.err != nil || delta == 0 { // struct terminator is zero delta fieldnum
+ if state.err != nil || delta == 0 { // struct terminator is zero delta fieldnum
break
}
- fieldnum := state.fieldnum + delta;
+ fieldnum := state.fieldnum + delta
if fieldnum >= len(engine.instr) {
- state.err = errRange;
- break;
+ state.err = errRange
+ break
}
- instr := &engine.instr[fieldnum];
- instr.op(instr, state, unsafe.Pointer(nil));
- state.fieldnum = fieldnum;
+ instr := &engine.instr[fieldnum]
+ instr.op(instr, state, unsafe.Pointer(nil))
+ state.fieldnum = fieldnum
}
- return state.err;
+ return state.err
}
func decodeArrayHelper(state *decodeState, p uintptr, elemOp decOp, elemWid uintptr, length, elemIndir int, ovfl os.ErrorString) os.Error {
- instr := &decInstr{elemOp, 0, elemIndir, 0, ovfl};
+ instr := &decInstr{elemOp, 0, elemIndir, 0, ovfl}
for i := 0; i < length && state.err == nil; i++ {
- up := unsafe.Pointer(p);
+ up := unsafe.Pointer(p)
if elemIndir > 1 {
up = decIndirect(up, elemIndir)
}
- elemOp(instr, state, up);
- p += uintptr(elemWid);
+ elemOp(instr, state, up)
+ p += uintptr(elemWid)
}
- return state.err;
+ return state.err
}
func decodeArray(atyp *reflect.ArrayType, state *decodeState, p uintptr, elemOp decOp, elemWid uintptr, length, indir, elemIndir int, ovfl os.ErrorString) os.Error {
if indir > 0 {
- up := unsafe.Pointer(p);
+ up := unsafe.Pointer(p)
if *(*unsafe.Pointer)(up) == nil {
// Allocate object.
*(*unsafe.Pointer)(up) = unsafe.New(atyp)
}
- p = *(*uintptr)(up);
+ p = *(*uintptr)(up)
}
if n := decodeUint(state); n != uint64(length) {
return os.ErrorString("gob: length mismatch in decodeArray")
}
- return decodeArrayHelper(state, p, elemOp, elemWid, length, elemIndir, ovfl);
+ return decodeArrayHelper(state, p, elemOp, elemWid, length, elemIndir, ovfl)
}
func ignoreArrayHelper(state *decodeState, elemOp decOp, length int) os.Error {
- instr := &decInstr{elemOp, 0, 0, 0, os.ErrorString("no error")};
+ instr := &decInstr{elemOp, 0, 0, 0, os.ErrorString("no error")}
for i := 0; i < length && state.err == nil; i++ {
elemOp(instr, state, nil)
}
- return state.err;
+ return state.err
}
func ignoreArray(state *decodeState, elemOp decOp, length int) os.Error {
if n := decodeUint(state); n != uint64(length) {
return os.ErrorString("gob: length mismatch in ignoreArray")
}
- return ignoreArrayHelper(state, elemOp, length);
+ return ignoreArrayHelper(state, elemOp, length)
}
func decodeSlice(atyp *reflect.SliceType, state *decodeState, p uintptr, elemOp decOp, elemWid uintptr, indir, elemIndir int, ovfl os.ErrorString) os.Error {
- n := int(uintptr(decodeUint(state)));
+ n := int(uintptr(decodeUint(state)))
if indir > 0 {
- up := unsafe.Pointer(p);
+ up := unsafe.Pointer(p)
if *(*unsafe.Pointer)(up) == nil {
// Allocate the slice header.
*(*unsafe.Pointer)(up) = unsafe.Pointer(new([]unsafe.Pointer))
}
- p = *(*uintptr)(up);
+ p = *(*uintptr)(up)
}
// Allocate storage for the slice elements, that is, the underlying array.
// Always write a header at p.
- hdrp := (*reflect.SliceHeader)(unsafe.Pointer(p));
- hdrp.Data = uintptr(unsafe.NewArray(atyp.Elem(), n));
- hdrp.Len = n;
- hdrp.Cap = n;
- return decodeArrayHelper(state, hdrp.Data, elemOp, elemWid, n, elemIndir, ovfl);
+ hdrp := (*reflect.SliceHeader)(unsafe.Pointer(p))
+ hdrp.Data = uintptr(unsafe.NewArray(atyp.Elem(), n))
+ hdrp.Len = n
+ hdrp.Cap = n
+ return decodeArrayHelper(state, hdrp.Data, elemOp, elemWid, n, elemIndir, ovfl)
}
func ignoreSlice(state *decodeState, elemOp decOp) os.Error {
// Return the decoding op for the base type under rt and
// the indirection count to reach it.
func (dec *Decoder) decOpFor(wireId typeId, rt reflect.Type, name string) (decOp, int, os.Error) {
- typ, indir := indirect(rt);
- op, ok := decOpMap[reflect.Typeof(typ)];
+ typ, indir := indirect(rt)
+ op, ok := decOpMap[reflect.Typeof(typ)]
if !ok {
// Special cases
switch t := typ.(type) {
case *reflect.SliceType:
- name = "element of " + name;
+ name = "element of " + name
if _, ok := t.Elem().(*reflect.Uint8Type); ok {
- op = decUint8Array;
- break;
+ op = decUint8Array
+ break
}
- var elemId typeId;
+ var elemId typeId
if tt, ok := builtinIdToType[wireId]; ok {
elemId = tt.(*sliceType).Elem
} else {
elemId = dec.wireType[wireId].slice.Elem
}
- elemOp, elemIndir, err := dec.decOpFor(elemId, t.Elem(), name);
+ elemOp, elemIndir, err := dec.decOpFor(elemId, t.Elem(), name)
if err != nil {
return nil, 0, err
}
- ovfl := overflow(name);
+ ovfl := overflow(name)
op = func(i *decInstr, state *decodeState, p unsafe.Pointer) {
state.err = decodeSlice(t, state, uintptr(p), elemOp, t.Elem().Size(), i.indir, elemIndir, ovfl)
- };
+ }
case *reflect.ArrayType:
- name = "element of " + name;
- elemId := wireId.gobType().(*arrayType).Elem;
- elemOp, elemIndir, err := dec.decOpFor(elemId, t.Elem(), name);
+ name = "element of " + name
+ elemId := wireId.gobType().(*arrayType).Elem
+ elemOp, elemIndir, err := dec.decOpFor(elemId, t.Elem(), name)
if err != nil {
return nil, 0, err
}
- ovfl := overflow(name);
+ ovfl := overflow(name)
op = func(i *decInstr, state *decodeState, p unsafe.Pointer) {
state.err = decodeArray(t, state, uintptr(p), elemOp, t.Elem().Size(), t.Len(), i.indir, elemIndir, ovfl)
- };
+ }
case *reflect.StructType:
// Generate a closure that calls out to the engine for the nested type.
- enginePtr, err := dec.getDecEnginePtr(wireId, typ);
+ enginePtr, err := dec.getDecEnginePtr(wireId, typ)
if err != nil {
return nil, 0, err
}
op = func(i *decInstr, state *decodeState, p unsafe.Pointer) {
// indirect through enginePtr to delay evaluation for recursive structs
state.err = decodeStruct(*enginePtr, t, state.b, uintptr(p), i.indir)
- };
+ }
}
}
if op == nil {
return nil, 0, os.ErrorString("gob: decode can't handle type " + rt.String())
}
- return op, indir, nil;
+ return op, indir, nil
}
// Return the decoding op for a field that has no destination.
func (dec *Decoder) decIgnoreOpFor(wireId typeId) (decOp, os.Error) {
- op, ok := decIgnoreOpMap[wireId];
+ op, ok := decIgnoreOpMap[wireId]
if !ok {
// Special cases
switch t := wireId.gobType().(type) {
case *sliceType:
- elemId := wireId.gobType().(*sliceType).Elem;
- elemOp, err := dec.decIgnoreOpFor(elemId);
+ elemId := wireId.gobType().(*sliceType).Elem
+ elemOp, err := dec.decIgnoreOpFor(elemId)
if err != nil {
return nil, err
}
op = func(i *decInstr, state *decodeState, p unsafe.Pointer) {
state.err = ignoreSlice(state, elemOp)
- };
+ }
case *arrayType:
- elemId := wireId.gobType().(*arrayType).Elem;
- elemOp, err := dec.decIgnoreOpFor(elemId);
+ elemId := wireId.gobType().(*arrayType).Elem
+ elemOp, err := dec.decIgnoreOpFor(elemId)
if err != nil {
return nil, err
}
op = func(i *decInstr, state *decodeState, p unsafe.Pointer) {
state.err = ignoreArray(state, elemOp, t.Len)
- };
+ }
case *structType:
// Generate a closure that calls out to the engine for the nested type.
- enginePtr, err := dec.getIgnoreEnginePtr(wireId);
+ enginePtr, err := dec.getIgnoreEnginePtr(wireId)
if err != nil {
return nil, err
}
op = func(i *decInstr, state *decodeState, p unsafe.Pointer) {
// indirect through enginePtr to delay evaluation for recursive structs
state.err = ignoreStruct(*enginePtr, state.b)
- };
+ }
}
}
if op == nil {
return nil, os.ErrorString("ignore can't handle type " + wireId.string())
}
- return op, nil;
+ return op, nil
}
// Are these two gob Types compatible?
func (dec *Decoder) compatibleType(fr reflect.Type, fw typeId) bool {
for {
if pt, ok := fr.(*reflect.PtrType); ok {
- fr = pt.Elem();
- continue;
+ fr = pt.Elem()
+ continue
}
- break;
+ break
}
switch t := fr.(type) {
default:
case *reflect.StringType:
return fw == tString
case *reflect.ArrayType:
- aw, ok := fw.gobType().(*arrayType);
- return ok && t.Len() == aw.Len && dec.compatibleType(t.Elem(), aw.Elem);
+ aw, ok := fw.gobType().(*arrayType)
+ return ok && t.Len() == aw.Len && dec.compatibleType(t.Elem(), aw.Elem)
case *reflect.SliceType:
// Is it an array of bytes?
- et := t.Elem();
+ et := t.Elem()
if _, ok := et.(*reflect.Uint8Type); ok {
return fw == tBytes
}
// Extract and compare element types.
- var sw *sliceType;
+ var sw *sliceType
if tt, ok := builtinIdToType[fw]; ok {
sw = tt.(*sliceType)
} else {
sw = dec.wireType[fw].slice
}
- elem, _ := indirect(t.Elem());
- return sw != nil && dec.compatibleType(elem, sw.Elem);
+ elem, _ := indirect(t.Elem())
+ return sw != nil && dec.compatibleType(elem, sw.Elem)
case *reflect.StructType:
return true
}
- return true;
+ return true
}
func (dec *Decoder) compileDec(remoteId typeId, rt reflect.Type) (engine *decEngine, err os.Error) {
- srt, ok1 := rt.(*reflect.StructType);
- var wireStruct *structType;
+ srt, ok1 := rt.(*reflect.StructType)
+ var wireStruct *structType
// Builtin types can come from global pool; the rest must be defined by the decoder
if t, ok := builtinIdToType[remoteId]; ok {
wireStruct = t.(*structType)
} else {
- w, ok2 := dec.wireType[remoteId];
+ w, ok2 := dec.wireType[remoteId]
if !ok1 || !ok2 {
return nil, errNotStruct
}
- wireStruct = w.strct;
+ wireStruct = w.strct
}
- engine = new(decEngine);
- engine.instr = make([]decInstr, len(wireStruct.field));
+ engine = new(decEngine)
+ engine.instr = make([]decInstr, len(wireStruct.field))
// Loop over the fields of the wire type.
for fieldnum := 0; fieldnum < len(wireStruct.field); fieldnum++ {
- wireField := wireStruct.field[fieldnum];
+ wireField := wireStruct.field[fieldnum]
// Find the field of the local type with the same name.
- localField, present := srt.FieldByName(wireField.name);
- ovfl := overflow(wireField.name);
+ localField, present := srt.FieldByName(wireField.name)
+ ovfl := overflow(wireField.name)
// TODO(r): anonymous names
if !present {
- op, err := dec.decIgnoreOpFor(wireField.id);
+ op, err := dec.decIgnoreOpFor(wireField.id)
if err != nil {
return nil, err
}
- engine.instr[fieldnum] = decInstr{op, fieldnum, 0, 0, ovfl};
- continue;
+ engine.instr[fieldnum] = decInstr{op, fieldnum, 0, 0, ovfl}
+ continue
}
if !dec.compatibleType(localField.Type, wireField.id) {
- details := " (" + wireField.id.string() + " incompatible with " + localField.Type.String() + ") in type " + remoteId.Name();
- return nil, os.ErrorString("gob: wrong type for field " + wireField.name + details);
+ details := " (" + wireField.id.string() + " incompatible with " + localField.Type.String() + ") in type " + remoteId.Name()
+ return nil, os.ErrorString("gob: wrong type for field " + wireField.name + details)
}
- op, indir, err := dec.decOpFor(wireField.id, localField.Type, localField.Name);
+ op, indir, err := dec.decOpFor(wireField.id, localField.Type, localField.Name)
if err != nil {
return nil, err
}
- engine.instr[fieldnum] = decInstr{op, fieldnum, indir, uintptr(localField.Offset), ovfl};
- engine.numInstr++;
+ engine.instr[fieldnum] = decInstr{op, fieldnum, indir, uintptr(localField.Offset), ovfl}
+ engine.numInstr++
}
- return;
+ return
}
func (dec *Decoder) getDecEnginePtr(remoteId typeId, rt reflect.Type) (enginePtr **decEngine, err os.Error) {
- decoderMap, ok := dec.decoderCache[rt];
+ decoderMap, ok := dec.decoderCache[rt]
if !ok {
- decoderMap = make(map[typeId]**decEngine);
- dec.decoderCache[rt] = decoderMap;
+ decoderMap = make(map[typeId]**decEngine)
+ dec.decoderCache[rt] = decoderMap
}
if enginePtr, ok = decoderMap[remoteId]; !ok {
// To handle recursive types, mark this engine as underway before compiling.
- enginePtr = new(*decEngine);
- decoderMap[remoteId] = enginePtr;
- *enginePtr, err = dec.compileDec(remoteId, rt);
+ enginePtr = new(*decEngine)
+ decoderMap[remoteId] = enginePtr
+ *enginePtr, err = dec.compileDec(remoteId, rt)
if err != nil {
decoderMap[remoteId] = nil, false
}
}
- return;
+ return
}
// When ignoring data, in effect we compile it into this type
var emptyStructType = reflect.Typeof(emptyStruct{})
func (dec *Decoder) getIgnoreEnginePtr(wireId typeId) (enginePtr **decEngine, err os.Error) {
- var ok bool;
+ var ok bool
if enginePtr, ok = dec.ignorerCache[wireId]; !ok {
// To handle recursive types, mark this engine as underway before compiling.
- enginePtr = new(*decEngine);
- dec.ignorerCache[wireId] = enginePtr;
- *enginePtr, err = dec.compileDec(wireId, emptyStructType);
+ enginePtr = new(*decEngine)
+ dec.ignorerCache[wireId] = enginePtr
+ *enginePtr, err = dec.compileDec(wireId, emptyStructType)
if err != nil {
dec.ignorerCache[wireId] = nil, false
}
}
- return;
+ return
}
func (dec *Decoder) decode(wireId typeId, e interface{}) os.Error {
// Dereference down to the underlying struct type.
- rt, indir := indirect(reflect.Typeof(e));
- st, ok := rt.(*reflect.StructType);
+ rt, indir := indirect(reflect.Typeof(e))
+ st, ok := rt.(*reflect.StructType)
if !ok {
return os.ErrorString("gob: decode can't handle " + rt.String())
}
- enginePtr, err := dec.getDecEnginePtr(wireId, rt);
+ enginePtr, err := dec.getDecEnginePtr(wireId, rt)
if err != nil {
return err
}
- engine := *enginePtr;
+ engine := *enginePtr
if engine.numInstr == 0 && st.NumField() > 0 && len(wireId.gobType().(*structType).field) > 0 {
- name := rt.Name();
- return os.ErrorString("gob: type mismatch: no fields matched compiling decoder for " + name);
+ name := rt.Name()
+ return os.ErrorString("gob: type mismatch: no fields matched compiling decoder for " + name)
}
- return decodeStruct(engine, st, dec.state.b, uintptr(reflect.NewValue(e).Addr()), indir);
+ return decodeStruct(engine, st, dec.state.b, uintptr(reflect.NewValue(e).Addr()), indir)
}
func init() {
// We assume that the size of float is sufficient to tell us whether it is
// equivalent to float32 or to float64. This is very unlikely to be wrong.
- var op decOp;
+ var op decOp
switch unsafe.Sizeof(float(0)) {
case unsafe.Sizeof(float32(0)):
op = decFloat32
default:
panic("gob: unknown size of float", unsafe.Sizeof(float(0)))
}
- decOpMap[valueKind(float(0))] = op;
+ decOpMap[valueKind(float(0))] = op
// A similar assumption about int and uint. Also assume int and uint have the same size.
- var uop decOp;
+ var uop decOp
switch unsafe.Sizeof(int(0)) {
case unsafe.Sizeof(int32(0)):
- op = decInt32;
- uop = decUint32;
+ op = decInt32
+ uop = decUint32
case unsafe.Sizeof(int64(0)):
- op = decInt64;
- uop = decUint64;
+ op = decInt64
+ uop = decUint64
default:
panic("gob: unknown size of int/uint", unsafe.Sizeof(int(0)))
}
- decOpMap[valueKind(int(0))] = op;
- decOpMap[valueKind(uint(0))] = uop;
+ decOpMap[valueKind(int(0))] = op
+ decOpMap[valueKind(uint(0))] = uop
// Finally uintptr
switch unsafe.Sizeof(uintptr(0)) {
default:
panic("gob: unknown size of uintptr", unsafe.Sizeof(uintptr(0)))
}
- decOpMap[valueKind(uintptr(0))] = uop;
+ decOpMap[valueKind(uintptr(0))] = uop
}
package gob
import (
- "bytes";
- "io";
- "os";
- "reflect";
- "sync";
+ "bytes"
+ "io"
+ "os"
+ "reflect"
+ "sync"
)
// A Decoder manages the receipt of type and data information read from the
// remote side of a connection.
type Decoder struct {
- mutex sync.Mutex; // each item must be received atomically
- r io.Reader; // source of the data
- wireType map[typeId]*wireType; // map from remote ID to local description
- decoderCache map[reflect.Type]map[typeId]**decEngine; // cache of compiled engines
- ignorerCache map[typeId]**decEngine; // ditto for ignored objects
- state *decodeState; // reads data from in-memory buffer
- countState *decodeState; // reads counts from wire
- buf []byte;
- countBuf [9]byte; // counts may be uint64s (unlikely!), require 9 bytes
+ mutex sync.Mutex // each item must be received atomically
+ r io.Reader // source of the data
+ wireType map[typeId]*wireType // map from remote ID to local description
+ decoderCache map[reflect.Type]map[typeId]**decEngine // cache of compiled engines
+ ignorerCache map[typeId]**decEngine // ditto for ignored objects
+ state *decodeState // reads data from in-memory buffer
+ countState *decodeState // reads counts from wire
+ buf []byte
+ countBuf [9]byte // counts may be uint64s (unlikely!), require 9 bytes
}
// NewDecoder returns a new decoder that reads from the io.Reader.
func NewDecoder(r io.Reader) *Decoder {
- dec := new(Decoder);
- dec.r = r;
- dec.wireType = make(map[typeId]*wireType);
- dec.state = newDecodeState(nil); // buffer set in Decode(); rest is unimportant
- dec.decoderCache = make(map[reflect.Type]map[typeId]**decEngine);
- dec.ignorerCache = make(map[typeId]**decEngine);
+ dec := new(Decoder)
+ dec.r = r
+ dec.wireType = make(map[typeId]*wireType)
+ dec.state = newDecodeState(nil) // buffer set in Decode(); rest is unimportant
+ dec.decoderCache = make(map[reflect.Type]map[typeId]**decEngine)
+ dec.ignorerCache = make(map[typeId]**decEngine)
- return dec;
+ return dec
}
func (dec *Decoder) recvType(id typeId) {
// Have we already seen this type? That's an error
if _, alreadySeen := dec.wireType[id]; alreadySeen {
- dec.state.err = os.ErrorString("gob: duplicate type received");
- return;
+ dec.state.err = os.ErrorString("gob: duplicate type received")
+ return
}
// Type:
- wire := new(wireType);
- dec.state.err = dec.decode(tWireType, wire);
+ wire := new(wireType)
+ dec.state.err = dec.decode(tWireType, wire)
// Remember we've seen this type.
- dec.wireType[id] = wire;
+ dec.wireType[id] = wire
}
// Decode reads the next value from the connection and stores
// If e represents a value, the answer won't get back to the
// caller. Make sure it's a pointer.
if _, ok := reflect.Typeof(e).(*reflect.PtrType); !ok {
- dec.state.err = os.ErrorString("gob: attempt to decode into a non-pointer");
- return dec.state.err;
+ dec.state.err = os.ErrorString("gob: attempt to decode into a non-pointer")
+ return dec.state.err
}
// Make sure we're single-threaded through here.
- dec.mutex.Lock();
- defer dec.mutex.Unlock();
+ dec.mutex.Lock()
+ defer dec.mutex.Unlock()
- dec.state.err = nil;
+ dec.state.err = nil
for {
// Read a count.
- var nbytes uint64;
- nbytes, dec.state.err = decodeUintReader(dec.r, dec.countBuf[0:]);
+ var nbytes uint64
+ nbytes, dec.state.err = decodeUintReader(dec.r, dec.countBuf[0:])
if dec.state.err != nil {
break
}
if nbytes > uint64(len(dec.buf)) {
dec.buf = make([]byte, nbytes+1000)
}
- dec.state.b = bytes.NewBuffer(dec.buf[0:nbytes]);
+ dec.state.b = bytes.NewBuffer(dec.buf[0:nbytes])
// Read the data
- _, dec.state.err = io.ReadFull(dec.r, dec.buf[0:nbytes]);
+ _, dec.state.err = io.ReadFull(dec.r, dec.buf[0:nbytes])
if dec.state.err != nil {
if dec.state.err == os.EOF {
dec.state.err = io.ErrUnexpectedEOF
}
- break;
+ break
}
// Receive a type id.
- id := typeId(decodeInt(dec.state));
+ id := typeId(decodeInt(dec.state))
if dec.state.err != nil {
break
}
// Is it a new type?
- if id < 0 { // 0 is the error state, handled above
+ if id < 0 { // 0 is the error state, handled above
// If the id is negative, we have a type.
- dec.recvType(-id);
+ dec.recvType(-id)
if dec.state.err != nil {
break
}
- continue;
+ continue
}
// No, it's a value.
// Make sure the type has been defined already.
- _, ok := dec.wireType[id];
+ _, ok := dec.wireType[id]
if !ok {
- dec.state.err = errBadType;
- break;
+ dec.state.err = errBadType
+ break
}
- dec.state.err = dec.decode(id, e);
- break;
+ dec.state.err = dec.decode(id, e)
+ break
}
- return dec.state.err;
+ return dec.state.err
}
package gob
import (
- "bytes";
- "io";
- "math";
- "os";
- "reflect";
- "unsafe";
+ "bytes"
+ "io"
+ "math"
+ "os"
+ "reflect"
+ "unsafe"
)
const uint64Size = unsafe.Sizeof(uint64(0))
// number is initialized to -1 so 0 comes out as delta(1). A delta of
// 0 terminates the structure.
type encoderState struct {
- b *bytes.Buffer;
- err os.Error; // error encountered during encoding;
- fieldnum int; // the last field number written.
- buf [1 + uint64Size]byte; // buffer used by the encoder; here to avoid allocation.
+ b *bytes.Buffer
+ err os.Error // error encountered during encoding;
+ fieldnum int // the last field number written.
+ buf [1 + uint64Size]byte // buffer used by the encoder; here to avoid allocation.
}
// Unsigned integers have a two-state encoding. If the number is less
return
}
if x <= 0x7F {
- state.err = state.b.WriteByte(uint8(x));
- return;
+ state.err = state.b.WriteByte(uint8(x))
+ return
}
- var n, m int;
- m = uint64Size;
+ var n, m int
+ m = uint64Size
for n = 1; x > 0; n++ {
- state.buf[m] = uint8(x & 0xFF);
- x >>= 8;
- m--;
+ state.buf[m] = uint8(x & 0xFF)
+ x >>= 8
+ m--
}
- state.buf[m] = uint8(-(n - 1));
- n, state.err = state.b.Write(state.buf[m : uint64Size+1]);
+ state.buf[m] = uint8(-(n - 1))
+ n, state.err = state.b.Write(state.buf[m : uint64Size+1])
}
// encodeInt writes an encoded signed integer to state.w.
// The low bit of the encoding says whether to bit complement the (other bits of the) uint to recover the int.
// Sets state.err. If state.err is already non-nil, it does nothing.
func encodeInt(state *encoderState, i int64) {
- var x uint64;
+ var x uint64
if i < 0 {
x = uint64(^i<<1) | 1
} else {
x = uint64(i << 1)
}
- encodeUint(state, uint64(x));
+ encodeUint(state, uint64(x))
}
type encOp func(i *encInstr, state *encoderState, p unsafe.Pointer)
// The 'instructions' of the encoding machine
type encInstr struct {
- op encOp;
- field int; // field number
- indir int; // how many pointer indirections to reach the value in the struct
- offset uintptr; // offset in the structure of the field to encode
+ op encOp
+ field int // field number
+ indir int // how many pointer indirections to reach the value in the struct
+ offset uintptr // offset in the structure of the field to encode
}
// Emit a field number and update the state to record its value for delta encoding.
// If the instruction pointer is nil, do nothing
func (state *encoderState) update(instr *encInstr) {
if instr != nil {
- encodeUint(state, uint64(instr.field-state.fieldnum));
- state.fieldnum = instr.field;
+ encodeUint(state, uint64(instr.field-state.fieldnum))
+ state.fieldnum = instr.field
}
}
func encIndirect(p unsafe.Pointer, indir int) unsafe.Pointer {
for ; indir > 0; indir-- {
- p = *(*unsafe.Pointer)(p);
+ p = *(*unsafe.Pointer)(p)
if p == nil {
return unsafe.Pointer(nil)
}
}
- return p;
+ return p
}
func encBool(i *encInstr, state *encoderState, p unsafe.Pointer) {
- b := *(*bool)(p);
+ b := *(*bool)(p)
if b {
- state.update(i);
- encodeUint(state, 1);
+ state.update(i)
+ encodeUint(state, 1)
}
}
func encInt(i *encInstr, state *encoderState, p unsafe.Pointer) {
- v := int64(*(*int)(p));
+ v := int64(*(*int)(p))
if v != 0 {
- state.update(i);
- encodeInt(state, v);
+ state.update(i)
+ encodeInt(state, v)
}
}
func encUint(i *encInstr, state *encoderState, p unsafe.Pointer) {
- v := uint64(*(*uint)(p));
+ v := uint64(*(*uint)(p))
if v != 0 {
- state.update(i);
- encodeUint(state, v);
+ state.update(i)
+ encodeUint(state, v)
}
}
func encInt8(i *encInstr, state *encoderState, p unsafe.Pointer) {
- v := int64(*(*int8)(p));
+ v := int64(*(*int8)(p))
if v != 0 {
- state.update(i);
- encodeInt(state, v);
+ state.update(i)
+ encodeInt(state, v)
}
}
func encUint8(i *encInstr, state *encoderState, p unsafe.Pointer) {
- v := uint64(*(*uint8)(p));
+ v := uint64(*(*uint8)(p))
if v != 0 {
- state.update(i);
- encodeUint(state, v);
+ state.update(i)
+ encodeUint(state, v)
}
}
func encInt16(i *encInstr, state *encoderState, p unsafe.Pointer) {
- v := int64(*(*int16)(p));
+ v := int64(*(*int16)(p))
if v != 0 {
- state.update(i);
- encodeInt(state, v);
+ state.update(i)
+ encodeInt(state, v)
}
}
func encUint16(i *encInstr, state *encoderState, p unsafe.Pointer) {
- v := uint64(*(*uint16)(p));
+ v := uint64(*(*uint16)(p))
if v != 0 {
- state.update(i);
- encodeUint(state, v);
+ state.update(i)
+ encodeUint(state, v)
}
}
func encInt32(i *encInstr, state *encoderState, p unsafe.Pointer) {
- v := int64(*(*int32)(p));
+ v := int64(*(*int32)(p))
if v != 0 {
- state.update(i);
- encodeInt(state, v);
+ state.update(i)
+ encodeInt(state, v)
}
}
func encUint32(i *encInstr, state *encoderState, p unsafe.Pointer) {
- v := uint64(*(*uint32)(p));
+ v := uint64(*(*uint32)(p))
if v != 0 {
- state.update(i);
- encodeUint(state, v);
+ state.update(i)
+ encodeUint(state, v)
}
}
func encInt64(i *encInstr, state *encoderState, p unsafe.Pointer) {
- v := *(*int64)(p);
+ v := *(*int64)(p)
if v != 0 {
- state.update(i);
- encodeInt(state, v);
+ state.update(i)
+ encodeInt(state, v)
}
}
func encUint64(i *encInstr, state *encoderState, p unsafe.Pointer) {
- v := *(*uint64)(p);
+ v := *(*uint64)(p)
if v != 0 {
- state.update(i);
- encodeUint(state, v);
+ state.update(i)
+ encodeUint(state, v)
}
}
func encUintptr(i *encInstr, state *encoderState, p unsafe.Pointer) {
- v := uint64(*(*uintptr)(p));
+ v := uint64(*(*uintptr)(p))
if v != 0 {
- state.update(i);
- encodeUint(state, v);
+ state.update(i)
+ encodeUint(state, v)
}
}
// (for example) transmit more compactly. This routine does the
// swizzling.
func floatBits(f float64) uint64 {
- u := math.Float64bits(f);
- var v uint64;
+ u := math.Float64bits(f)
+ var v uint64
for i := 0; i < 8; i++ {
- v <<= 8;
- v |= u & 0xFF;
- u >>= 8;
+ v <<= 8
+ v |= u & 0xFF
+ u >>= 8
}
- return v;
+ return v
}
func encFloat(i *encInstr, state *encoderState, p unsafe.Pointer) {
- f := float(*(*float)(p));
+ f := float(*(*float)(p))
if f != 0 {
- v := floatBits(float64(f));
- state.update(i);
- encodeUint(state, v);
+ v := floatBits(float64(f))
+ state.update(i)
+ encodeUint(state, v)
}
}
func encFloat32(i *encInstr, state *encoderState, p unsafe.Pointer) {
- f := float32(*(*float32)(p));
+ f := float32(*(*float32)(p))
if f != 0 {
- v := floatBits(float64(f));
- state.update(i);
- encodeUint(state, v);
+ v := floatBits(float64(f))
+ state.update(i)
+ encodeUint(state, v)
}
}
func encFloat64(i *encInstr, state *encoderState, p unsafe.Pointer) {
- f := *(*float64)(p);
+ f := *(*float64)(p)
if f != 0 {
- state.update(i);
- v := floatBits(f);
- encodeUint(state, v);
+ state.update(i)
+ v := floatBits(f)
+ encodeUint(state, v)
}
}
// Byte arrays are encoded as an unsigned count followed by the raw bytes.
func encUint8Array(i *encInstr, state *encoderState, p unsafe.Pointer) {
- b := *(*[]byte)(p);
+ b := *(*[]byte)(p)
if len(b) > 0 {
- state.update(i);
- encodeUint(state, uint64(len(b)));
- state.b.Write(b);
+ state.update(i)
+ encodeUint(state, uint64(len(b)))
+ state.b.Write(b)
}
}
// Strings are encoded as an unsigned count followed by the raw bytes.
func encString(i *encInstr, state *encoderState, p unsafe.Pointer) {
- s := *(*string)(p);
+ s := *(*string)(p)
if len(s) > 0 {
- state.update(i);
- encodeUint(state, uint64(len(s)));
- io.WriteString(state.b, s);
+ state.update(i)
+ encodeUint(state, uint64(len(s)))
+ io.WriteString(state.b, s)
}
}
// The encoder engine is an array of instructions indexed by field number of the encoding
// data, typically a struct. It is executed top to bottom, walking the struct.
type encEngine struct {
- instr []encInstr;
+ instr []encInstr
}
func encodeStruct(engine *encEngine, b *bytes.Buffer, basep uintptr) os.Error {
- state := new(encoderState);
- state.b = b;
- state.fieldnum = -1;
+ state := new(encoderState)
+ state.b = b
+ state.fieldnum = -1
for i := 0; i < len(engine.instr); i++ {
- instr := &engine.instr[i];
- p := unsafe.Pointer(basep + instr.offset);
+ instr := &engine.instr[i]
+ p := unsafe.Pointer(basep + instr.offset)
if instr.indir > 0 {
if p = encIndirect(p, instr.indir); p == nil {
continue
}
}
- instr.op(instr, state, p);
+ instr.op(instr, state, p)
if state.err != nil {
break
}
}
- return state.err;
+ return state.err
}
func encodeArray(b *bytes.Buffer, p uintptr, op encOp, elemWid uintptr, length int, elemIndir int) os.Error {
- state := new(encoderState);
- state.b = b;
- state.fieldnum = -1;
- encodeUint(state, uint64(length));
+ state := new(encoderState)
+ state.b = b
+ state.fieldnum = -1
+ encodeUint(state, uint64(length))
for i := 0; i < length && state.err == nil; i++ {
- elemp := p;
- up := unsafe.Pointer(elemp);
+ elemp := p
+ up := unsafe.Pointer(elemp)
if elemIndir > 0 {
if up = encIndirect(up, elemIndir); up == nil {
- state.err = os.ErrorString("gob: encodeArray: nil element");
- break;
+ state.err = os.ErrorString("gob: encodeArray: nil element")
+ break
}
- elemp = uintptr(up);
+ elemp = uintptr(up)
}
- op(nil, state, unsafe.Pointer(elemp));
- p += uintptr(elemWid);
+ op(nil, state, unsafe.Pointer(elemp))
+ p += uintptr(elemWid)
}
- return state.err;
+ return state.err
}
var encOpMap = map[reflect.Type]encOp{
// Return the encoding op for the base type under rt and
// the indirection count to reach it.
func encOpFor(rt reflect.Type) (encOp, int, os.Error) {
- typ, indir := indirect(rt);
- op, ok := encOpMap[reflect.Typeof(typ)];
+ typ, indir := indirect(rt)
+ op, ok := encOpMap[reflect.Typeof(typ)]
if !ok {
- typ, _ := indirect(rt);
+ typ, _ := indirect(rt)
// Special cases
switch t := typ.(type) {
case *reflect.SliceType:
if _, ok := t.Elem().(*reflect.Uint8Type); ok {
- op = encUint8Array;
- break;
+ op = encUint8Array
+ break
}
// Slices have a header; we decode it to find the underlying array.
- elemOp, indir, err := encOpFor(t.Elem());
+ elemOp, indir, err := encOpFor(t.Elem())
if err != nil {
return nil, 0, err
}
op = func(i *encInstr, state *encoderState, p unsafe.Pointer) {
- slice := (*reflect.SliceHeader)(p);
+ slice := (*reflect.SliceHeader)(p)
if slice.Len == 0 {
return
}
- state.update(i);
- state.err = encodeArray(state.b, slice.Data, elemOp, t.Elem().Size(), int(slice.Len), indir);
- };
+ state.update(i)
+ state.err = encodeArray(state.b, slice.Data, elemOp, t.Elem().Size(), int(slice.Len), indir)
+ }
case *reflect.ArrayType:
// True arrays have size in the type.
- elemOp, indir, err := encOpFor(t.Elem());
+ elemOp, indir, err := encOpFor(t.Elem())
if err != nil {
return nil, 0, err
}
op = func(i *encInstr, state *encoderState, p unsafe.Pointer) {
- state.update(i);
- state.err = encodeArray(state.b, uintptr(p), elemOp, t.Elem().Size(), t.Len(), indir);
- };
+ state.update(i)
+ state.err = encodeArray(state.b, uintptr(p), elemOp, t.Elem().Size(), t.Len(), indir)
+ }
case *reflect.StructType:
// Generate a closure that calls out to the engine for the nested type.
- _, err := getEncEngine(typ);
+ _, err := getEncEngine(typ)
if err != nil {
return nil, 0, err
}
- info := mustGetTypeInfo(typ);
+ info := mustGetTypeInfo(typ)
op = func(i *encInstr, state *encoderState, p unsafe.Pointer) {
- state.update(i);
+ state.update(i)
// indirect through info to delay evaluation for recursive structs
- state.err = encodeStruct(info.encoder, state.b, uintptr(p));
- };
+ state.err = encodeStruct(info.encoder, state.b, uintptr(p))
+ }
}
}
if op == nil {
return op, indir, os.ErrorString("gob enc: can't happen: encode type" + rt.String())
}
- return op, indir, nil;
+ return op, indir, nil
}
// The local Type was compiled from the actual value, so we know it's compatible.
func compileEnc(rt reflect.Type) (*encEngine, os.Error) {
- srt, ok := rt.(*reflect.StructType);
+ srt, ok := rt.(*reflect.StructType)
if !ok {
panicln("can't happen: non-struct")
}
- engine := new(encEngine);
- engine.instr = make([]encInstr, srt.NumField()+1); // +1 for terminator
+ engine := new(encEngine)
+ engine.instr = make([]encInstr, srt.NumField()+1) // +1 for terminator
for fieldnum := 0; fieldnum < srt.NumField(); fieldnum++ {
- f := srt.Field(fieldnum);
- op, indir, err := encOpFor(f.Type);
+ f := srt.Field(fieldnum)
+ op, indir, err := encOpFor(f.Type)
if err != nil {
return nil, err
}
- engine.instr[fieldnum] = encInstr{op, fieldnum, indir, uintptr(f.Offset)};
+ engine.instr[fieldnum] = encInstr{op, fieldnum, indir, uintptr(f.Offset)}
}
- engine.instr[srt.NumField()] = encInstr{encStructTerminator, 0, 0, 0};
- return engine, nil;
+ engine.instr[srt.NumField()] = encInstr{encStructTerminator, 0, 0, 0}
+ return engine, nil
}
// typeLock must be held (or we're in initialization and guaranteed single-threaded).
// The reflection type must have all its indirections processed out.
func getEncEngine(rt reflect.Type) (*encEngine, os.Error) {
- info, err := getTypeInfo(rt);
+ info, err := getTypeInfo(rt)
if err != nil {
return nil, err
}
if info.encoder == nil {
// mark this engine as underway before compiling to handle recursive types.
- info.encoder = new(encEngine);
- info.encoder, err = compileEnc(rt);
+ info.encoder = new(encEngine)
+ info.encoder, err = compileEnc(rt)
}
- return info.encoder, err;
+ return info.encoder, err
}
func encode(b *bytes.Buffer, e interface{}) os.Error {
// Dereference down to the underlying object.
- rt, indir := indirect(reflect.Typeof(e));
- v := reflect.NewValue(e);
+ rt, indir := indirect(reflect.Typeof(e))
+ v := reflect.NewValue(e)
for i := 0; i < indir; i++ {
v = reflect.Indirect(v)
}
if _, ok := v.(*reflect.StructValue); !ok {
return os.ErrorString("gob: encode can't handle " + v.Type().String())
}
- typeLock.Lock();
- engine, err := getEncEngine(rt);
- typeLock.Unlock();
+ typeLock.Lock()
+ engine, err := getEncEngine(rt)
+ typeLock.Unlock()
if err != nil {
return err
}
- return encodeStruct(engine, b, v.Addr());
+ return encodeStruct(engine, b, v.Addr())
}
package gob
import (
- "bytes";
- "io";
- "os";
- "reflect";
- "sync";
+ "bytes"
+ "io"
+ "os"
+ "reflect"
+ "sync"
)
// An Encoder manages the transmission of type and data information to the
// other side of a connection.
type Encoder struct {
- mutex sync.Mutex; // each item must be sent atomically
- w io.Writer; // where to send the data
- sent map[reflect.Type]typeId; // which types we've already sent
- state *encoderState; // so we can encode integers, strings directly
- countState *encoderState; // stage for writing counts
- buf []byte; // for collecting the output.
+ mutex sync.Mutex // each item must be sent atomically
+ w io.Writer // where to send the data
+ sent map[reflect.Type]typeId // which types we've already sent
+ state *encoderState // so we can encode integers, strings directly
+ countState *encoderState // stage for writing counts
+ buf []byte // for collecting the output.
}
// NewEncoder returns a new encoder that will transmit on the io.Writer.
func NewEncoder(w io.Writer) *Encoder {
- enc := new(Encoder);
- enc.w = w;
- enc.sent = make(map[reflect.Type]typeId);
- enc.state = new(encoderState);
- enc.state.b = new(bytes.Buffer); // the rest isn't important; all we need is buffer and writer
- enc.countState = new(encoderState);
- enc.countState.b = new(bytes.Buffer); // the rest isn't important; all we need is buffer and writer
- return enc;
+ enc := new(Encoder)
+ enc.w = w
+ enc.sent = make(map[reflect.Type]typeId)
+ enc.state = new(encoderState)
+ enc.state.b = new(bytes.Buffer) // the rest isn't important; all we need is buffer and writer
+ enc.countState = new(encoderState)
+ enc.countState.b = new(bytes.Buffer) // the rest isn't important; all we need is buffer and writer
+ return enc
}
func (enc *Encoder) badType(rt reflect.Type) {
}
func (enc *Encoder) setError(err os.Error) {
- if enc.state.err == nil { // remember the first.
+ if enc.state.err == nil { // remember the first.
enc.state.err = err
}
- enc.state.b.Reset();
+ enc.state.b.Reset()
}
// Send the data item preceded by a unsigned count of its length.
func (enc *Encoder) send() {
// Encode the length.
- encodeUint(enc.countState, uint64(enc.state.b.Len()));
+ encodeUint(enc.countState, uint64(enc.state.b.Len()))
// Build the buffer.
- countLen := enc.countState.b.Len();
- total := countLen + enc.state.b.Len();
+ countLen := enc.countState.b.Len()
+ total := countLen + enc.state.b.Len()
if total > len(enc.buf) {
- enc.buf = make([]byte, total+1000) // extra for growth
+ enc.buf = make([]byte, total+1000) // extra for growth
}
// Place the length before the data.
// TODO(r): avoid the extra copy here.
- enc.countState.b.Read(enc.buf[0:countLen]);
+ enc.countState.b.Read(enc.buf[0:countLen])
// Now the data.
- enc.state.b.Read(enc.buf[countLen:total]);
+ enc.state.b.Read(enc.buf[countLen:total])
// Write the data.
- _, err := enc.w.Write(enc.buf[0:total]);
+ _, err := enc.w.Write(enc.buf[0:total])
if err != nil {
enc.setError(err)
}
func (enc *Encoder) sendType(origt reflect.Type) {
// Drill down to the base type.
- rt, _ := indirect(origt);
+ rt, _ := indirect(origt)
// We only send structs - everything else is basic or an error
switch rt := rt.(type) {
return
}
// Otherwise we do send.
- break;
+ break
// Struct types are not sent, only their element types.
case *reflect.StructType:
break
case *reflect.ChanType, *reflect.FuncType, *reflect.MapType, *reflect.InterfaceType:
// Probably a bad field in a struct.
- enc.badType(rt);
- return;
+ enc.badType(rt)
+ return
}
// Have we already sent this type? This time we ask about the base type.
}
// Need to send it.
- typeLock.Lock();
- info, err := getTypeInfo(rt);
- typeLock.Unlock();
+ typeLock.Lock()
+ info, err := getTypeInfo(rt)
+ typeLock.Unlock()
if err != nil {
- enc.setError(err);
- return;
+ enc.setError(err)
+ return
}
// Send the pair (-id, type)
// Id:
- encodeInt(enc.state, -int64(info.id));
+ encodeInt(enc.state, -int64(info.id))
// Type:
- encode(enc.state.b, info.wire);
- enc.send();
+ encode(enc.state.b, info.wire)
+ enc.send()
if enc.state.err != nil {
return
}
// Remember we've sent this type.
- enc.sent[rt] = info.id;
+ enc.sent[rt] = info.id
// Remember we've sent the top-level, possibly indirect type too.
- enc.sent[origt] = info.id;
+ enc.sent[origt] = info.id
// Now send the inner types
switch st := rt.(type) {
case *reflect.StructType:
case reflect.ArrayOrSliceType:
enc.sendType(st.Elem())
}
- return;
+ return
}
// Encode transmits the data item represented by the empty interface value,
func (enc *Encoder) Encode(e interface{}) os.Error {
// Make sure we're single-threaded through here, so multiple
// goroutines can share an encoder.
- enc.mutex.Lock();
- defer enc.mutex.Unlock();
+ enc.mutex.Lock()
+ defer enc.mutex.Unlock()
- enc.state.err = nil;
- rt, _ := indirect(reflect.Typeof(e));
+ enc.state.err = nil
+ rt, _ := indirect(reflect.Typeof(e))
// Must be a struct
if _, ok := rt.(*reflect.StructType); !ok {
- enc.badType(rt);
- return enc.state.err;
+ enc.badType(rt)
+ return enc.state.err
}
// Sanity check only: encoder should never come in with data present.
if enc.state.b.Len() > 0 || enc.countState.b.Len() > 0 {
- enc.state.err = os.ErrorString("encoder: buffer not empty");
- return enc.state.err;
+ enc.state.err = os.ErrorString("encoder: buffer not empty")
+ return enc.state.err
}
// Make sure the type is known to the other side.
// First, have we already sent this type?
if _, alreadySent := enc.sent[rt]; !alreadySent {
// No, so send it.
- enc.sendType(rt);
+ enc.sendType(rt)
if enc.state.err != nil {
- enc.countState.b.Reset();
- return enc.state.err;
+ enc.countState.b.Reset()
+ return enc.state.err
}
}
// Identify the type of this top-level value.
- encodeInt(enc.state, int64(enc.sent[rt]));
+ encodeInt(enc.state, int64(enc.sent[rt]))
// Encode the object.
- encode(enc.state.b, e);
- enc.send();
+ encode(enc.state.b, e)
+ enc.send()
- return enc.state.err;
+ return enc.state.err
}
package gob
import (
- "bytes";
- "io";
- "os";
- "reflect";
- "strings";
- "testing";
+ "bytes"
+ "io"
+ "os"
+ "reflect"
+ "strings"
+ "testing"
)
type ET2 struct {
- x string;
+ x string
}
type ET1 struct {
- a int;
- et2 *ET2;
- next *ET1;
+ a int
+ et2 *ET2
+ next *ET1
}
// Like ET1 but with a different name for a field
type ET3 struct {
- a int;
- et2 *ET2;
- differentNext *ET1;
+ a int
+ et2 *ET2
+ differentNext *ET1
}
// Like ET1 but with a different type for a field
type ET4 struct {
- a int;
- et2 float;
- next int;
+ a int
+ et2 float
+ next int
}
func TestEncoderDecoder(t *testing.T) {
- b := new(bytes.Buffer);
- enc := NewEncoder(b);
- et1 := new(ET1);
- et1.a = 7;
- et1.et2 = new(ET2);
- enc.Encode(et1);
+ b := new(bytes.Buffer)
+ enc := NewEncoder(b)
+ et1 := new(ET1)
+ et1.a = 7
+ et1.et2 = new(ET2)
+ enc.Encode(et1)
if enc.state.err != nil {
t.Error("encoder fail:", enc.state.err)
}
- dec := NewDecoder(b);
- newEt1 := new(ET1);
- dec.Decode(newEt1);
+ dec := NewDecoder(b)
+ newEt1 := new(ET1)
+ dec.Decode(newEt1)
if dec.state.err != nil {
t.Fatal("error decoding ET1:", dec.state.err)
}
t.Error("not at eof;", b.Len(), "bytes left")
}
- enc.Encode(et1);
- newEt1 = new(ET1);
- dec.Decode(newEt1);
+ enc.Encode(et1)
+ newEt1 = new(ET1)
+ dec.Decode(newEt1)
if dec.state.err != nil {
t.Fatal("round 2: error decoding ET1:", dec.state.err)
}
}
// Now test with a running encoder/decoder pair that we recognize a type mismatch.
- enc.Encode(et1);
+ enc.Encode(et1)
if enc.state.err != nil {
t.Error("round 3: encoder fail:", enc.state.err)
}
- newEt2 := new(ET2);
- dec.Decode(newEt2);
+ newEt2 := new(ET2)
+ dec.Decode(newEt2)
if dec.state.err == nil {
t.Fatal("round 3: expected `bad type' error decoding ET2")
}
// Run one value through the encoder/decoder, but use the wrong type.
// Input is always an ET1; we compare it to whatever is under 'e'.
func badTypeCheck(e interface{}, shouldFail bool, msg string, t *testing.T) {
- b := new(bytes.Buffer);
- enc := NewEncoder(b);
- et1 := new(ET1);
- et1.a = 7;
- et1.et2 = new(ET2);
- enc.Encode(et1);
+ b := new(bytes.Buffer)
+ enc := NewEncoder(b)
+ et1 := new(ET1)
+ et1.a = 7
+ et1.et2 = new(ET2)
+ enc.Encode(et1)
if enc.state.err != nil {
t.Error("encoder fail:", enc.state.err)
}
- dec := NewDecoder(b);
- dec.Decode(e);
+ dec := NewDecoder(b)
+ dec.Decode(e)
if shouldFail && (dec.state.err == nil) {
t.Error("expected error for", msg)
}
// Test that we recognize a bad type the first time.
func TestWrongTypeDecoder(t *testing.T) {
- badTypeCheck(new(ET2), true, "no fields in common", t);
- badTypeCheck(new(ET3), false, "different name of field", t);
- badTypeCheck(new(ET4), true, "different type of field", t);
+ badTypeCheck(new(ET2), true, "no fields in common", t)
+ badTypeCheck(new(ET3), false, "different name of field", t)
+ badTypeCheck(new(ET4), true, "different type of field", t)
}
func corruptDataCheck(s string, err os.Error, t *testing.T) {
- b := bytes.NewBufferString(s);
- dec := NewDecoder(b);
- dec.Decode(new(ET2));
+ b := bytes.NewBufferString(s)
+ dec := NewDecoder(b)
+ dec.Decode(new(ET2))
if dec.state.err != err {
t.Error("expected error", err, "got", dec.state.err)
}
// Check that we survive bad data.
func TestBadData(t *testing.T) {
- corruptDataCheck("", os.EOF, t);
- corruptDataCheck("\x7Fhi", io.ErrUnexpectedEOF, t);
- corruptDataCheck("\x03now is the time for all good men", errBadType, t);
+ corruptDataCheck("", os.EOF, t)
+ corruptDataCheck("\x7Fhi", io.ErrUnexpectedEOF, t)
+ corruptDataCheck("\x03now is the time for all good men", errBadType, t)
}
// Types not supported by the Encoder (only structs work at the top level).
}
func TestUnsupported(t *testing.T) {
- var b bytes.Buffer;
- enc := NewEncoder(&b);
+ var b bytes.Buffer
+ enc := NewEncoder(&b)
for _, v := range unsupportedValues {
- err := enc.Encode(v);
+ err := enc.Encode(v)
if err == nil {
t.Errorf("expected error for %T; got none", v)
}
}
func encAndDec(in, out interface{}) os.Error {
- b := new(bytes.Buffer);
- enc := NewEncoder(b);
- enc.Encode(in);
+ b := new(bytes.Buffer)
+ enc := NewEncoder(b)
+ enc.Encode(in)
if enc.state.err != nil {
return enc.state.err
}
- dec := NewDecoder(b);
- dec.Decode(out);
+ dec := NewDecoder(b)
+ dec.Decode(out)
if dec.state.err != nil {
return dec.state.err
}
- return nil;
+ return nil
}
func TestTypeToPtrType(t *testing.T) {
// Encode a T, decode a *T
type Type0 struct {
- a int;
+ a int
}
- t0 := Type0{7};
- t0p := (*Type0)(nil);
+ t0 := Type0{7}
+ t0p := (*Type0)(nil)
if err := encAndDec(t0, t0p); err != nil {
t.Error(err)
}
func TestPtrTypeToType(t *testing.T) {
// Encode a *T, decode a T
type Type1 struct {
- a uint;
+ a uint
}
- t1p := &Type1{17};
- var t1 Type1;
+ t1p := &Type1{17}
+ var t1 Type1
if err := encAndDec(t1, t1p); err != nil {
t.Error(err)
}
func TestTypeToPtrPtrPtrPtrType(t *testing.T) {
type Type2 struct {
- a ****float;
+ a ****float
}
- t2 := Type2{};
- t2.a = new(***float);
- *t2.a = new(**float);
- **t2.a = new(*float);
- ***t2.a = new(float);
- ****t2.a = 27.4;
- t2pppp := new(***Type2);
+ t2 := Type2{}
+ t2.a = new(***float)
+ *t2.a = new(**float)
+ **t2.a = new(*float)
+ ***t2.a = new(float)
+ ****t2.a = 27.4
+ t2pppp := new(***Type2)
if err := encAndDec(t2, t2pppp); err != nil {
t.Error(err)
}
func TestSlice(t *testing.T) {
type Type3 struct {
- a []string;
+ a []string
}
- t3p := &Type3{[]string{"hello", "world"}};
- var t3 Type3;
+ t3p := &Type3{[]string{"hello", "world"}}
+ var t3 Type3
if err := encAndDec(t3, t3p); err != nil {
t.Error(err)
}
func TestValueError(t *testing.T) {
// Encode a *T, decode a T
type Type4 struct {
- a int;
+ a int
}
- t4p := &Type4{3};
- var t4 Type4; // note: not a pointer.
+ t4p := &Type4{3}
+ var t4 Type4 // note: not a pointer.
if err := encAndDec(t4p, t4); err == nil || strings.Index(err.String(), "pointer") < 0 {
t.Error("expected error about pointer; got", err)
}
func TestArray(t *testing.T) {
type Type5 struct {
- a [3]string;
+ a [3]string
}
type Type6 struct {
- a [2]string; // can't hold t5.a
+ a [2]string // can't hold t5.a
}
- t5 := Type5{[3]string{"hello", ",", "world"}};
- var t5p Type5;
+ t5 := Type5{[3]string{"hello", ",", "world"}}
+ var t5p Type5
if err := encAndDec(t5, &t5p); err != nil {
t.Error(err)
}
- var t6 Type6;
+ var t6 Type6
if err := encAndDec(t5, &t6); err == nil {
t.Error("should fail with mismatched array sizes")
}
package gob
import (
- "fmt";
- "os";
- "reflect";
- "sync";
+ "fmt"
+ "os"
+ "reflect"
+ "sync"
)
type kind reflect.Type
// int8, int16, int, uint, float, func, chan, struct, and so on.
// That is, all struct types have the same kind, all func types have the same
// kind, all int8 types have the same kind, and so on.
-func typeKind(typ reflect.Type) kind { return kind(reflect.Typeof(typ)) }
+func typeKind(typ reflect.Type) kind { return kind(reflect.Typeof(typ)) }
// valueKind returns the kind of the value type
// stored inside the interface v.
-func valueKind(v interface{}) reflect.Type { return typeKind(reflect.Typeof(v)) }
+func valueKind(v interface{}) reflect.Type { return typeKind(reflect.Typeof(v)) }
// A typeId represents a gob Type as an integer that can be passed on the wire.
// Internally, typeIds are used as keys to a map to recover the underlying type info.
type typeId int32
-var nextId typeId // incremented for each new type we build
-var typeLock sync.Mutex // set while building a type
+var nextId typeId // incremented for each new type we build
+var typeLock sync.Mutex // set while building a type
type gobType interface {
- id() typeId;
- setId(id typeId);
- Name() string;
- string() string; // not public; only for debugging
- safeString(seen map[typeId]bool) string;
+ id() typeId
+ setId(id typeId)
+ Name() string
+ string() string // not public; only for debugging
+ safeString(seen map[typeId]bool) string
}
var types = make(map[reflect.Type]gobType)
var idToType = make(map[typeId]gobType)
-var builtinIdToType map[typeId]gobType // set in init() after builtins are established
+var builtinIdToType map[typeId]gobType // set in init() after builtins are established
func setTypeId(typ gobType) {
- nextId++;
- typ.setId(nextId);
- idToType[nextId] = typ;
+ nextId++
+ typ.setId(nextId)
+ idToType[nextId] = typ
}
func (t typeId) gobType() gobType {
if t == 0 {
return nil
}
- return idToType[t];
+ return idToType[t]
}
// string returns the string representation of the type associated with the typeId.
-func (t typeId) string() string { return t.gobType().string() }
+func (t typeId) string() string { return t.gobType().string() }
// Name returns the name of the type associated with the typeId.
-func (t typeId) Name() string { return t.gobType().Name() }
+func (t typeId) Name() string { return t.gobType().Name() }
// Common elements of all types.
type commonType struct {
- name string;
- _id typeId;
+ name string
+ _id typeId
}
-func (t *commonType) id() typeId { return t._id }
+func (t *commonType) id() typeId { return t._id }
-func (t *commonType) setId(id typeId) { t._id = id }
+func (t *commonType) setId(id typeId) { t._id = id }
-func (t *commonType) string() string { return t.name }
+func (t *commonType) string() string { return t.name }
func (t *commonType) safeString(seen map[typeId]bool) string {
return t.name
}
-func (t *commonType) Name() string { return t.name }
+func (t *commonType) Name() string { return t.name }
// Create and check predefined types
// The string for tBytes is "bytes" not "[]byte" to signify its specialness.
var tWireType = mustGetTypeInfo(reflect.Typeof(wireType{})).id
func init() {
- checkId(7, tWireType);
- checkId(9, mustGetTypeInfo(reflect.Typeof(commonType{})).id);
- checkId(11, mustGetTypeInfo(reflect.Typeof(structType{})).id);
- checkId(12, mustGetTypeInfo(reflect.Typeof(fieldType{})).id);
- builtinIdToType = make(map[typeId]gobType);
+ checkId(7, tWireType)
+ checkId(9, mustGetTypeInfo(reflect.Typeof(commonType{})).id)
+ checkId(11, mustGetTypeInfo(reflect.Typeof(structType{})).id)
+ checkId(12, mustGetTypeInfo(reflect.Typeof(fieldType{})).id)
+ builtinIdToType = make(map[typeId]gobType)
for k, v := range idToType {
builtinIdToType[k] = v
}
// Array type
type arrayType struct {
- commonType;
- Elem typeId;
- Len int;
+ commonType
+ Elem typeId
+ Len int
}
func newArrayType(name string, elem gobType, length int) *arrayType {
- a := &arrayType{commonType{name: name}, elem.id(), length};
- setTypeId(a);
- return a;
+ a := &arrayType{commonType{name: name}, elem.id(), length}
+ setTypeId(a)
+ return a
}
func (a *arrayType) safeString(seen map[typeId]bool) string {
if _, ok := seen[a._id]; ok {
return a.name
}
- seen[a._id] = true;
- return fmt.Sprintf("[%d]%s", a.Len, a.Elem.gobType().safeString(seen));
+ seen[a._id] = true
+ return fmt.Sprintf("[%d]%s", a.Len, a.Elem.gobType().safeString(seen))
}
-func (a *arrayType) string() string { return a.safeString(make(map[typeId]bool)) }
+func (a *arrayType) string() string { return a.safeString(make(map[typeId]bool)) }
// Slice type
type sliceType struct {
- commonType;
- Elem typeId;
+ commonType
+ Elem typeId
}
func newSliceType(name string, elem gobType) *sliceType {
- s := &sliceType{commonType{name: name}, elem.id()};
- setTypeId(s);
- return s;
+ s := &sliceType{commonType{name: name}, elem.id()}
+ setTypeId(s)
+ return s
}
func (s *sliceType) safeString(seen map[typeId]bool) string {
if _, ok := seen[s._id]; ok {
return s.name
}
- seen[s._id] = true;
- return fmt.Sprintf("[]%s", s.Elem.gobType().safeString(seen));
+ seen[s._id] = true
+ return fmt.Sprintf("[]%s", s.Elem.gobType().safeString(seen))
}
-func (s *sliceType) string() string { return s.safeString(make(map[typeId]bool)) }
+func (s *sliceType) string() string { return s.safeString(make(map[typeId]bool)) }
// Struct type
type fieldType struct {
- name string;
- id typeId;
+ name string
+ id typeId
}
type structType struct {
- commonType;
- field []*fieldType;
+ commonType
+ field []*fieldType
}
func (s *structType) safeString(seen map[typeId]bool) string {
if _, ok := seen[s._id]; ok {
return s.name
}
- seen[s._id] = true;
- str := s.name + " = struct { ";
+ seen[s._id] = true
+ str := s.name + " = struct { "
for _, f := range s.field {
str += fmt.Sprintf("%s %s; ", f.name, f.id.gobType().safeString(seen))
}
- str += "}";
- return str;
+ str += "}"
+ return str
}
-func (s *structType) string() string { return s.safeString(make(map[typeId]bool)) }
+func (s *structType) string() string { return s.safeString(make(map[typeId]bool)) }
func newStructType(name string) *structType {
- s := &structType{commonType{name: name}, nil};
- setTypeId(s);
- return s;
+ s := &structType{commonType{name: name}, nil}
+ setTypeId(s)
+ return s
}
// Step through the indirections on a type to discover the base type.
// Return the number of indirections.
func indirect(t reflect.Type) (rt reflect.Type, count int) {
- rt = t;
+ rt = t
for {
- pt, ok := rt.(*reflect.PtrType);
+ pt, ok := rt.(*reflect.PtrType)
if !ok {
break
}
- rt = pt.Elem();
- count++;
+ rt = pt.Elem()
+ count++
}
- return;
+ return
}
func newTypeObject(name string, rt reflect.Type) (gobType, os.Error) {
return tString.gobType(), nil
case *reflect.ArrayType:
- gt, err := getType("", t.Elem());
+ gt, err := getType("", t.Elem())
if err != nil {
return nil, err
}
- return newArrayType(name, gt, t.Len()), nil;
+ return newArrayType(name, gt, t.Len()), nil
case *reflect.SliceType:
// []byte == []uint8 is a special case
if _, ok := t.Elem().(*reflect.Uint8Type); ok {
return tBytes.gobType(), nil
}
- gt, err := getType(t.Elem().Name(), t.Elem());
+ gt, err := getType(t.Elem().Name(), t.Elem())
if err != nil {
return nil, err
}
- return newSliceType(name, gt), nil;
+ return newSliceType(name, gt), nil
case *reflect.StructType:
// Install the struct type itself before the fields so recursive
// structures can be constructed safely.
- strType := newStructType(name);
- types[rt] = strType;
- idToType[strType.id()] = strType;
- field := make([]*fieldType, t.NumField());
+ strType := newStructType(name)
+ types[rt] = strType
+ idToType[strType.id()] = strType
+ field := make([]*fieldType, t.NumField())
for i := 0; i < t.NumField(); i++ {
- f := t.Field(i);
- typ, _ := indirect(f.Type);
- tname := typ.Name();
+ f := t.Field(i)
+ typ, _ := indirect(f.Type)
+ tname := typ.Name()
if tname == "" {
tname = f.Type.String()
}
- gt, err := getType(tname, f.Type);
+ gt, err := getType(tname, f.Type)
if err != nil {
return nil, err
}
- field[i] = &fieldType{f.Name, gt.id()};
+ field[i] = &fieldType{f.Name, gt.id()}
}
- strType.field = field;
- return strType, nil;
+ strType.field = field
+ return strType, nil
default:
return nil, os.ErrorString("gob NewTypeObject can't handle type: " + rt.String())
}
- return nil, nil;
+ return nil, nil
}
// getType returns the Gob type describing the given reflect.Type.
func getType(name string, rt reflect.Type) (gobType, os.Error) {
// Flatten the data structure by collapsing out pointers
for {
- pt, ok := rt.(*reflect.PtrType);
+ pt, ok := rt.(*reflect.PtrType)
if !ok {
break
}
- rt = pt.Elem();
+ rt = pt.Elem()
}
- typ, present := types[rt];
+ typ, present := types[rt]
if present {
return typ, nil
}
- typ, err := newTypeObject(name, rt);
+ typ, err := newTypeObject(name, rt)
if err == nil {
types[rt] = typ
}
- return typ, err;
+ return typ, err
}
func checkId(want, got typeId) {
// used for building the basic types; called only from init()
func bootstrapType(name string, e interface{}, expect typeId) typeId {
- rt := reflect.Typeof(e);
- _, present := types[rt];
+ rt := reflect.Typeof(e)
+ _, present := types[rt]
if present {
panicln("bootstrap type already present:", name)
}
- typ := &commonType{name: name};
- types[rt] = typ;
- setTypeId(typ);
- checkId(expect, nextId);
- return nextId;
+ typ := &commonType{name: name}
+ types[rt] = typ
+ setTypeId(typ)
+ checkId(expect, nextId)
+ return nextId
}
// Representation of the information we send and receive about this type.
// are built in encode.go's init() function.
type wireType struct {
- array *arrayType;
- slice *sliceType;
- strct *structType;
+ array *arrayType
+ slice *sliceType
+ strct *structType
}
func (w *wireType) name() string {
if w.strct != nil {
return w.strct.name
}
- return "unknown";
+ return "unknown"
}
type typeInfo struct {
- id typeId;
- encoder *encEngine;
- wire *wireType;
+ id typeId
+ encoder *encEngine
+ wire *wireType
}
-var typeInfoMap = make(map[reflect.Type]*typeInfo) // protected by typeLock
+var typeInfoMap = make(map[reflect.Type]*typeInfo) // protected by typeLock
// The reflection type must have all its indirections processed out.
// typeLock must be held.
if _, ok := rt.(*reflect.PtrType); ok {
panicln("pointer type in getTypeInfo:", rt.String())
}
- info, ok := typeInfoMap[rt];
+ info, ok := typeInfoMap[rt]
if !ok {
- info = new(typeInfo);
- name := rt.Name();
- gt, err := getType(name, rt);
+ info = new(typeInfo)
+ name := rt.Name()
+ gt, err := getType(name, rt)
if err != nil {
return nil, err
}
- info.id = gt.id();
- t := info.id.gobType();
+ info.id = gt.id()
+ t := info.id.gobType()
switch typ := rt.(type) {
case *reflect.ArrayType:
info.wire = &wireType{array: t.(*arrayType)}
case *reflect.StructType:
info.wire = &wireType{strct: t.(*structType)}
}
- typeInfoMap[rt] = info;
+ typeInfoMap[rt] = info
}
- return info, nil;
+ return info, nil
}
// Called only when a panic is acceptable and unexpected.
func mustGetTypeInfo(rt reflect.Type) *typeInfo {
- t, err := getTypeInfo(rt);
+ t, err := getTypeInfo(rt)
if err != nil {
panicln("getTypeInfo:", err.String())
}
- return t;
+ return t
}
package gob
import (
- "reflect";
- "testing";
+ "reflect"
+ "testing"
)
type typeT struct {
- id typeId;
- str string;
+ id typeId
+ str string
}
var basicTypes = []typeT{
}
func getTypeUnlocked(name string, rt reflect.Type) gobType {
- typeLock.Lock();
- defer typeLock.Unlock();
- t, err := getType(name, rt);
+ typeLock.Lock()
+ defer typeLock.Unlock()
+ t, err := getType(name, rt)
if err != nil {
panicln("getTypeUnlocked:", err.String())
}
- return t;
+ return t
}
// Sanity checks
// Reregister some basic types to check registration is idempotent.
func TestReregistration(t *testing.T) {
- newtyp := getTypeUnlocked("int", reflect.Typeof(int(0)));
+ newtyp := getTypeUnlocked("int", reflect.Typeof(int(0)))
if newtyp != tInt.gobType() {
t.Errorf("reregistration of %s got new type", newtyp.string())
}
- newtyp = getTypeUnlocked("uint", reflect.Typeof(uint(0)));
+ newtyp = getTypeUnlocked("uint", reflect.Typeof(uint(0)))
if newtyp != tUint.gobType() {
t.Errorf("reregistration of %s got new type", newtyp.string())
}
- newtyp = getTypeUnlocked("string", reflect.Typeof("hello"));
+ newtyp = getTypeUnlocked("string", reflect.Typeof("hello"))
if newtyp != tString.gobType() {
t.Errorf("reregistration of %s got new type", newtyp.string())
}
}
func TestArrayType(t *testing.T) {
- var a3 [3]int;
- a3int := getTypeUnlocked("foo", reflect.Typeof(a3));
- newa3int := getTypeUnlocked("bar", reflect.Typeof(a3));
+ var a3 [3]int
+ a3int := getTypeUnlocked("foo", reflect.Typeof(a3))
+ newa3int := getTypeUnlocked("bar", reflect.Typeof(a3))
if a3int != newa3int {
t.Errorf("second registration of [3]int creates new type")
}
- var a4 [4]int;
- a4int := getTypeUnlocked("goo", reflect.Typeof(a4));
+ var a4 [4]int
+ a4int := getTypeUnlocked("goo", reflect.Typeof(a4))
if a3int == a4int {
t.Errorf("registration of [3]int creates same type as [4]int")
}
- var b3 [3]bool;
- a3bool := getTypeUnlocked("", reflect.Typeof(b3));
+ var b3 [3]bool
+ a3bool := getTypeUnlocked("", reflect.Typeof(b3))
if a3int == a3bool {
t.Errorf("registration of [3]bool creates same type as [3]int")
}
- str := a3bool.string();
- expected := "[3]bool";
+ str := a3bool.string()
+ expected := "[3]bool"
if str != expected {
t.Errorf("array printed as %q; expected %q", str, expected)
}
}
func TestSliceType(t *testing.T) {
- var s []int;
- sint := getTypeUnlocked("slice", reflect.Typeof(s));
- var news []int;
- newsint := getTypeUnlocked("slice1", reflect.Typeof(news));
+ var s []int
+ sint := getTypeUnlocked("slice", reflect.Typeof(s))
+ var news []int
+ newsint := getTypeUnlocked("slice1", reflect.Typeof(news))
if sint != newsint {
t.Errorf("second registration of []int creates new type")
}
- var b []bool;
- sbool := getTypeUnlocked("", reflect.Typeof(b));
+ var b []bool
+ sbool := getTypeUnlocked("", reflect.Typeof(b))
if sbool == sint {
t.Errorf("registration of []bool creates same type as []int")
}
- str := sbool.string();
- expected := "[]bool";
+ str := sbool.string()
+ expected := "[]bool"
if str != expected {
t.Errorf("slice printed as %q; expected %q", str, expected)
}
}
type Bar struct {
- x string;
+ x string
}
// This structure has pointers and refers to itself, making it a good test case.
type Foo struct {
- a int;
- b int32; // will become int
- c string;
- d []byte;
- e *float; // will become float
- f ****float64; // will become float
- g *Bar;
- h *Bar; // should not interpolate the definition of Bar again
- i *Foo; // will not explode
+ a int
+ b int32 // will become int
+ c string
+ d []byte
+ e *float // will become float
+ f ****float64 // will become float
+ g *Bar
+ h *Bar // should not interpolate the definition of Bar again
+ i *Foo // will not explode
}
func TestStructType(t *testing.T) {
- sstruct := getTypeUnlocked("Foo", reflect.Typeof(Foo{}));
- str := sstruct.string();
+ sstruct := getTypeUnlocked("Foo", reflect.Typeof(Foo{}))
+ str := sstruct.string()
// If we can print it correctly, we built it correctly.
- expected := "Foo = struct { a int; b int; c string; d bytes; e float; f float; g Bar = struct { x string; }; h Bar; i Foo; }";
+ expected := "Foo = struct { a int; b int; c string; d bytes; e float; f float; g Bar = struct { x string; }; h Bar; i Foo; }"
if str != expected {
t.Errorf("struct printed as %q; expected %q", str, expected)
}
package adler32
import (
- "hash";
- "os";
+ "hash"
+ "os"
)
const (
- mod = 65521;
+ mod = 65521
)
// The size of an Adler-32 checksum in bytes.
type digest struct {
// invariant: (a < mod && b < mod) || a <= b
// invariant: a + b + 255 <= 0xffffffff
- a, b uint32;
+ a, b uint32
}
-func (d *digest) Reset() { d.a, d.b = 1, 0 }
+func (d *digest) Reset() { d.a, d.b = 1, 0 }
// New returns a new hash.Hash32 computing the Adler-32 checksum.
func New() hash.Hash32 {
- d := new(digest);
- d.Reset();
- return d;
+ d := new(digest)
+ d.Reset()
+ return d
}
-func (d *digest) Size() int { return Size }
+func (d *digest) Size() int { return Size }
// Add p to the running checksum a, b.
func update(a, b uint32, p []byte) (aa, bb uint32) {
for i := 0; i < len(p); i++ {
- a += uint32(p[i]);
- b += a;
+ a += uint32(p[i])
+ b += a
// invariant: a <= b
if b > (0xffffffff-255)/2 {
- a %= mod;
- b %= mod;
+ a %= mod
+ b %= mod
// invariant: a < mod && b < mod
} else {
// invariant: a + b + 255 <= 2 * b + 255 <= 0xffffffff
}
}
- return a, b;
+ return a, b
}
// Return the 32-bit checksum corresponding to a, b.
func finish(a, b uint32) uint32 {
if b >= mod {
- a %= mod;
- b %= mod;
+ a %= mod
+ b %= mod
}
- return b<<16 | a;
+ return b<<16 | a
}
func (d *digest) Write(p []byte) (nn int, err os.Error) {
- d.a, d.b = update(d.a, d.b, p);
- return len(p), nil;
+ d.a, d.b = update(d.a, d.b, p)
+ return len(p), nil
}
-func (d *digest) Sum32() uint32 { return finish(d.a, d.b) }
+func (d *digest) Sum32() uint32 { return finish(d.a, d.b) }
func (d *digest) Sum() []byte {
- p := make([]byte, 4);
- s := d.Sum32();
- p[0] = byte(s >> 24);
- p[1] = byte(s >> 16);
- p[2] = byte(s >> 8);
- p[3] = byte(s);
- return p;
+ p := make([]byte, 4)
+ s := d.Sum32()
+ p[0] = byte(s >> 24)
+ p[1] = byte(s >> 16)
+ p[2] = byte(s >> 8)
+ p[3] = byte(s)
+ return p
}
// Checksum returns the Adler-32 checksum of data.
-func Checksum(data []byte) uint32 { return finish(update(1, 0, data)) }
+func Checksum(data []byte) uint32 { return finish(update(1, 0, data)) }
package adler32
import (
- "io";
- "testing";
+ "io"
+ "testing"
)
type _Adler32Test struct {
- out uint32;
- in string;
+ out uint32
+ in string
}
var golden = []_Adler32Test{
func TestGolden(t *testing.T) {
for i := 0; i < len(golden); i++ {
- g := golden[i];
- c := New();
- io.WriteString(c, g.in);
- s := c.Sum32();
+ g := golden[i]
+ c := New()
+ io.WriteString(c, g.in)
+ s := c.Sum32()
if s != g.out {
- t.Errorf("adler32(%s) = 0x%x want 0x%x", g.in, s, g.out);
- t.FailNow();
+ t.Errorf("adler32(%s) = 0x%x want 0x%x", g.in, s, g.out)
+ t.FailNow()
}
}
}
package crc32
import (
- "hash";
- "os";
+ "hash"
+ "os"
)
// The size of a CRC-32 checksum in bytes.
const (
// Far and away the most common CRC-32 polynomial.
// Used by ethernet (IEEE 802.3), v.42, fddi, gzip, zip, png, mpeg-2, ...
- IEEE = 0xedb88320;
+ IEEE = 0xedb88320
// Castagnoli's polynomial, used in iSCSI.
// Has better error detection characteristics than IEEE.
// http://dx.doi.org/10.1109/26.231911
- Castagnoli = 0x82f63b78;
+ Castagnoli = 0x82f63b78
// Koopman's polynomial.
// Also has better error detection characteristics than IEEE.
// http://dx.doi.org/10.1109/DSN.2002.1028931
- Koopman = 0xeb31d82e;
+ Koopman = 0xeb31d82e
)
// Table is a 256-word table representing the polynomial for efficient processing.
// MakeTable returns the Table constructed from the specified polynomial.
func MakeTable(poly uint32) *Table {
- t := new(Table);
+ t := new(Table)
for i := 0; i < 256; i++ {
- crc := uint32(i);
+ crc := uint32(i)
for j := 0; j < 8; j++ {
if crc&1 == 1 {
crc = (crc >> 1) ^ poly
crc >>= 1
}
}
- t[i] = crc;
+ t[i] = crc
}
- return t;
+ return t
}
// IEEETable is the table for the IEEE polynomial.
// digest represents the partial evaluation of a checksum.
type digest struct {
- crc uint32;
- tab *Table;
+ crc uint32
+ tab *Table
}
// New creates a new hash.Hash32 computing the CRC-32 checksum
// using the polynomial represented by the Table.
-func New(tab *Table) hash.Hash32 { return &digest{0, tab} }
+func New(tab *Table) hash.Hash32 { return &digest{0, tab} }
// NewIEEE creates a new hash.Hash32 computing the CRC-32 checksum
// using the IEEE polynomial.
-func NewIEEE() hash.Hash32 { return New(IEEETable) }
+func NewIEEE() hash.Hash32 { return New(IEEETable) }
-func (d *digest) Size() int { return Size }
+func (d *digest) Size() int { return Size }
-func (d *digest) Reset() { d.crc = 0 }
+func (d *digest) Reset() { d.crc = 0 }
func update(crc uint32, tab *Table, p []byte) uint32 {
- crc = ^crc;
+ crc = ^crc
for i := 0; i < len(p); i++ {
crc = tab[byte(crc)^p[i]] ^ (crc >> 8)
}
- return ^crc;
+ return ^crc
}
func (d *digest) Write(p []byte) (n int, err os.Error) {
- d.crc = update(d.crc, d.tab, p);
- return len(p), nil;
+ d.crc = update(d.crc, d.tab, p)
+ return len(p), nil
}
-func (d *digest) Sum32() uint32 { return d.crc }
+func (d *digest) Sum32() uint32 { return d.crc }
func (d *digest) Sum() []byte {
- p := make([]byte, 4);
- s := d.Sum32();
- p[0] = byte(s >> 24);
- p[1] = byte(s >> 16);
- p[2] = byte(s >> 8);
- p[3] = byte(s);
- return p;
+ p := make([]byte, 4)
+ s := d.Sum32()
+ p[0] = byte(s >> 24)
+ p[1] = byte(s >> 16)
+ p[2] = byte(s >> 8)
+ p[3] = byte(s)
+ return p
}
// Checksum returns the CRC-32 checksum of data
// using the polynomial represented by the Table.
-func Checksum(data []byte, tab *Table) uint32 { return update(0, tab, data) }
+func Checksum(data []byte, tab *Table) uint32 { return update(0, tab, data) }
// ChecksumIEEE returns the CRC-32 checksum of data
// using the IEEE polynomial.
-func ChecksumIEEE(data []byte) uint32 { return update(0, IEEETable, data) }
+func ChecksumIEEE(data []byte) uint32 { return update(0, IEEETable, data) }
package crc32
import (
- "io";
- "testing";
+ "io"
+ "testing"
)
type _Crc32Test struct {
- out uint32;
- in string;
+ out uint32
+ in string
}
var golden = []_Crc32Test{
func TestGolden(t *testing.T) {
for i := 0; i < len(golden); i++ {
- g := golden[i];
- c := NewIEEE();
- io.WriteString(c, g.in);
- s := c.Sum32();
+ g := golden[i]
+ c := NewIEEE()
+ io.WriteString(c, g.in)
+ s := c.Sum32()
if s != g.out {
- t.Errorf("crc32(%s) = 0x%x want 0x%x", g.in, s, g.out);
- t.FailNow();
+ t.Errorf("crc32(%s) = 0x%x want 0x%x", g.in, s, g.out)
+ t.FailNow()
}
}
}
func BenchmarkCrc32KB(b *testing.B) {
- b.StopTimer();
- data := make([]uint8, 1024);
+ b.StopTimer()
+ data := make([]uint8, 1024)
for i := 0; i < 1024; i++ {
data[i] = uint8(i)
}
- c := NewIEEE();
- b.StartTimer();
+ c := NewIEEE()
+ b.StartTimer()
for i := 0; i < b.N; i++ {
c.Write(data)
// The Write method never returns an error.
// Sum returns the bytes of integer hash codes in big-endian order.
type Hash interface {
- io.Writer;
- Sum() []byte;
- Reset();
- Size() int; // number of bytes Sum returns
+ io.Writer
+ Sum() []byte
+ Reset()
+ Size() int // number of bytes Sum returns
}
// Hash32 is the common interface implemented by all 32-bit hash functions.
type Hash32 interface {
- Hash;
- Sum32() uint32;
+ Hash
+ Sum32() uint32
}
package http
import (
- "bufio";
- "fmt";
- "io";
- "net";
- "os";
- "strconv";
- "strings";
+ "bufio"
+ "fmt"
+ "io"
+ "net"
+ "os"
+ "strconv"
+ "strings"
)
// Response represents the response from an HTTP request.
type Response struct {
- Status string; // e.g. "200 OK"
- StatusCode int; // e.g. 200
+ Status string // e.g. "200 OK"
+ StatusCode int // e.g. 200
// Header maps header keys to values. If the response had multiple
// headers with the same key, they will be concatenated, with comma
// be semantically equivalent to a comma-delimited sequence.)
//
// Keys in the map are canonicalized (see CanonicalHeaderKey).
- Header map[string]string;
+ Header map[string]string
// Stream from which the response body can be read.
- Body io.ReadCloser;
+ Body io.ReadCloser
}
// GetHeader returns the value of the response header with the given
// response headers with the given key, it returns the empty string and
// false. Keys are not case sensitive.
func (r *Response) GetHeader(key string) (value string) {
- value, _ = r.Header[CanonicalHeaderKey(key)];
- return;
+ value, _ = r.Header[CanonicalHeaderKey(key)]
+ return
}
// AddHeader adds a value under the given key. Keys are not case sensitive.
func (r *Response) AddHeader(key, value string) {
- key = CanonicalHeaderKey(key);
+ key = CanonicalHeaderKey(key)
- oldValues, oldValuesPresent := r.Header[key];
+ oldValues, oldValuesPresent := r.Header[key]
if oldValuesPresent {
r.Header[key] = oldValues + "," + value
} else {
// Given a string of the form "host", "host:port", or "[ipv6::address]:port",
// return true if the string includes a port.
-func hasPort(s string) bool { return strings.LastIndex(s, ":") > strings.LastIndex(s, "]") }
+func hasPort(s string) bool { return strings.LastIndex(s, ":") > strings.LastIndex(s, "]") }
// Used in Send to implement io.ReadCloser by bundling together the
// io.BufReader through which we read the response, and the underlying
// network connection.
type readClose struct {
- io.Reader;
- io.Closer;
+ io.Reader
+ io.Closer
}
// ReadResponse reads and returns an HTTP response from r.
func ReadResponse(r *bufio.Reader) (*Response, os.Error) {
- resp := new(Response);
+ resp := new(Response)
// Parse the first line of the response.
- resp.Header = make(map[string]string);
+ resp.Header = make(map[string]string)
- line, err := readLine(r);
+ line, err := readLine(r)
if err != nil {
return nil, err
}
- f := strings.Split(line, " ", 3);
+ f := strings.Split(line, " ", 3)
if len(f) < 3 {
return nil, &badStringError{"malformed HTTP response", line}
}
- resp.Status = f[1] + " " + f[2];
- resp.StatusCode, err = strconv.Atoi(f[1]);
+ resp.Status = f[1] + " " + f[2]
+ resp.StatusCode, err = strconv.Atoi(f[1])
if err != nil {
return nil, &badStringError{"malformed HTTP status code", f[1]}
}
// Parse the response headers.
for {
- key, value, err := readKeyValue(r);
+ key, value, err := readKeyValue(r)
if err != nil {
return nil, err
}
if key == "" {
- break // end of response header
+ break // end of response header
}
- resp.AddHeader(key, value);
+ resp.AddHeader(key, value)
}
- return resp, nil;
+ return resp, nil
}
return nil, &badStringError{"unsupported protocol scheme", req.URL.Scheme}
}
- addr := req.URL.Host;
+ addr := req.URL.Host
if !hasPort(addr) {
addr += ":http"
}
- conn, err := net.Dial("tcp", "", addr);
+ conn, err := net.Dial("tcp", "", addr)
if err != nil {
return nil, err
}
- err = req.Write(conn);
+ err = req.Write(conn)
if err != nil {
- conn.Close();
- return nil, err;
+ conn.Close()
+ return nil, err
}
- reader := bufio.NewReader(conn);
- resp, err = ReadResponse(reader);
+ reader := bufio.NewReader(conn)
+ resp, err = ReadResponse(reader)
if err != nil {
- conn.Close();
- return nil, err;
+ conn.Close()
+ return nil, err
}
- r := io.Reader(reader);
+ r := io.Reader(reader)
if v := resp.GetHeader("Transfer-Encoding"); v == "chunked" {
r = newChunkedReader(reader)
} else if v := resp.GetHeader("Content-Length"); v != "" {
- n, err := strconv.Atoi64(v);
+ n, err := strconv.Atoi64(v)
if err != nil {
return nil, &badStringError{"invalid Content-Length", v}
}
- r = io.LimitReader(r, n);
+ r = io.LimitReader(r, n)
}
- resp.Body = readClose{r, conn};
+ resp.Body = readClose{r, conn}
- return;
+ return
}
// True if the specified HTTP status code is one for which the Get utility should
case StatusMovedPermanently, StatusFound, StatusSeeOther, StatusTemporaryRedirect:
return true
}
- return false;
+ return false
}
// Get issues a GET to the specified URL. If the response is one of the following
// TODO: set referrer header on redirects.
for redirect := 0; ; redirect++ {
if redirect >= 10 {
- err = os.ErrorString("stopped after 10 redirects");
- break;
+ err = os.ErrorString("stopped after 10 redirects")
+ break
}
- var req Request;
+ var req Request
if req.URL, err = ParseURL(url); err != nil {
break
}
break
}
if shouldRedirect(r.StatusCode) {
- r.Body.Close();
+ r.Body.Close()
if url = r.GetHeader("Location"); url == "" {
- err = os.ErrorString(fmt.Sprintf("%d response missing Location header", r.StatusCode));
- break;
+ err = os.ErrorString(fmt.Sprintf("%d response missing Location header", r.StatusCode))
+ break
}
- continue;
+ continue
}
- finalURL = url;
- return;
+ finalURL = url
+ return
}
- err = &URLError{"Get", url, err};
- return;
+ err = &URLError{"Get", url, err}
+ return
}
//
// Caller should close r.Body when done reading it.
func Post(url string, bodyType string, body io.Reader) (r *Response, err os.Error) {
- var req Request;
- req.Method = "POST";
- req.Body = body;
+ var req Request
+ req.Method = "POST"
+ req.Body = body
req.Header = map[string]string{
"Content-Type": bodyType,
"Transfer-Encoding": "chunked",
- };
+ }
- req.URL, err = ParseURL(url);
+ req.URL, err = ParseURL(url)
if err != nil {
return nil, err
}
- return send(&req);
+ return send(&req)
}
package http
import (
- "io/ioutil";
- "strings";
- "testing";
+ "io/ioutil"
+ "strings"
+ "testing"
)
func TestClient(t *testing.T) {
// TODO: add a proper test suite. Current test merely verifies that
// we can retrieve the Google robots.txt file.
- r, _, err := Get("http://www.google.com/robots.txt");
- var b []byte;
+ r, _, err := Get("http://www.google.com/robots.txt")
+ var b []byte
if err == nil {
- b, err = ioutil.ReadAll(r.Body);
- r.Body.Close();
+ b, err = ioutil.ReadAll(r.Body)
+ r.Body.Close()
}
if err != nil {
t.Error(err)
package http
import (
- "fmt";
- "io";
- "os";
- "path";
- "strings";
- "utf8";
+ "fmt"
+ "io"
+ "os"
+ "path"
+ "strings"
+ "utf8"
)
// TODO this should be in a mime package somewhere
// contain any unprintable ASCII or Unicode characters.
func isText(b []byte) bool {
for len(b) > 0 && utf8.FullRune(b) {
- rune, size := utf8.DecodeRune(b);
+ rune, size := utf8.DecodeRune(b)
if size == 1 && rune == utf8.RuneError {
// decoding error
return false
return false
}
}
- b = b[size:];
+ b = b[size:]
}
- return true;
+ return true
}
func dirList(c *Conn, f *os.File) {
- fmt.Fprintf(c, "<pre>\n");
+ fmt.Fprintf(c, "<pre>\n")
for {
- dirs, err := f.Readdir(100);
+ dirs, err := f.Readdir(100)
if err != nil || len(dirs) == 0 {
break
}
for _, d := range dirs {
- name := d.Name;
+ name := d.Name
if d.IsDirectory() {
name += "/"
}
// TODO htmlescape
- fmt.Fprintf(c, "<a href=\"%s\">%s</a>\n", name, name);
+ fmt.Fprintf(c, "<a href=\"%s\">%s</a>\n", name, name)
}
}
- fmt.Fprintf(c, "</pre>\n");
+ fmt.Fprintf(c, "</pre>\n")
}
func serveFileInternal(c *Conn, r *Request, name string, redirect bool) {
- const indexPage = "/index.html";
+ const indexPage = "/index.html"
// redirect .../index.html to .../
if strings.HasSuffix(r.URL.Path, indexPage) {
- Redirect(c, r.URL.Path[0:len(r.URL.Path)-len(indexPage)+1], StatusMovedPermanently);
- return;
+ Redirect(c, r.URL.Path[0:len(r.URL.Path)-len(indexPage)+1], StatusMovedPermanently)
+ return
}
- f, err := os.Open(name, os.O_RDONLY, 0);
+ f, err := os.Open(name, os.O_RDONLY, 0)
if err != nil {
// TODO expose actual error?
- NotFound(c, r);
- return;
+ NotFound(c, r)
+ return
}
- defer f.Close();
+ defer f.Close()
- d, err1 := f.Stat();
+ d, err1 := f.Stat()
if err1 != nil {
// TODO expose actual error?
- NotFound(c, r);
- return;
+ NotFound(c, r)
+ return
}
if redirect {
// redirect to canonical path: / at end of directory url
// r.URL.Path always begins with /
- url := r.URL.Path;
+ url := r.URL.Path
if d.IsDirectory() {
if url[len(url)-1] != '/' {
- Redirect(c, url+"/", StatusMovedPermanently);
- return;
+ Redirect(c, url+"/", StatusMovedPermanently)
+ return
}
} else {
if url[len(url)-1] == '/' {
- Redirect(c, url[0:len(url)-1], StatusMovedPermanently);
- return;
+ Redirect(c, url[0:len(url)-1], StatusMovedPermanently)
+ return
}
}
}
// use contents of index.html for directory, if present
if d.IsDirectory() {
- index := name + indexPage;
- ff, err := os.Open(index, os.O_RDONLY, 0);
+ index := name + indexPage
+ ff, err := os.Open(index, os.O_RDONLY, 0)
if err == nil {
- defer ff.Close();
- dd, err := ff.Stat();
+ defer ff.Close()
+ dd, err := ff.Stat()
if err == nil {
- name = index;
- d = dd;
- f = ff;
+ name = index
+ d = dd
+ f = ff
}
}
}
if d.IsDirectory() {
- dirList(c, f);
- return;
+ dirList(c, f)
+ return
}
// serve file
// use extension to find content type.
- ext := path.Ext(name);
+ ext := path.Ext(name)
if ctype, ok := contentByExt[ext]; ok {
c.SetHeader("Content-Type", ctype)
} else {
// read first chunk to decide between utf-8 text and binary
- var buf [1024]byte;
- n, _ := io.ReadFull(f, &buf);
- b := buf[0:n];
+ var buf [1024]byte
+ n, _ := io.ReadFull(f, &buf)
+ b := buf[0:n]
if isText(b) {
c.SetHeader("Content-Type", "text-plain; charset=utf-8")
} else {
- c.SetHeader("Content-Type", "application/octet-stream") // generic binary
+ c.SetHeader("Content-Type", "application/octet-stream") // generic binary
}
- c.Write(b);
+ c.Write(b)
}
- io.Copy(c, f);
+ io.Copy(c, f)
}
// ServeFile replies to the request with the contents of the named file or directory.
}
type fileHandler struct {
- root string;
- prefix string;
+ root string
+ prefix string
}
// FileServer returns a handler that serves HTTP requests
// with the contents of the file system rooted at root.
// It strips prefix from the incoming requests before
// looking up the file name in the file system.
-func FileServer(root, prefix string) Handler { return &fileHandler{root, prefix} }
+func FileServer(root, prefix string) Handler { return &fileHandler{root, prefix} }
func (f *fileHandler) ServeHTTP(c *Conn, r *Request) {
- path := r.URL.Path;
+ path := r.URL.Path
if !strings.HasPrefix(path, f.prefix) {
- NotFound(c, r);
- return;
+ NotFound(c, r)
+ return
}
- path = path[len(f.prefix):];
- serveFileInternal(c, r, f.root+"/"+path, true);
+ path = path[len(f.prefix):]
+ serveFileInternal(c, r, f.root+"/"+path, true)
}
package http
import (
- "bufio";
- "bytes";
- "container/vector";
- "fmt";
- "io";
- "io/ioutil";
- "os";
- "strconv";
- "strings";
+ "bufio"
+ "bytes"
+ "container/vector"
+ "fmt"
+ "io"
+ "io/ioutil"
+ "os"
+ "strconv"
+ "strings"
)
const (
- maxLineLength = 1024; // assumed < bufio.DefaultBufSize
- maxValueLength = 1024;
- maxHeaderLines = 1024;
- chunkSize = 4 << 10; // 4 KB chunks
+ maxLineLength = 1024 // assumed < bufio.DefaultBufSize
+ maxValueLength = 1024
+ maxHeaderLines = 1024
+ chunkSize = 4 << 10 // 4 KB chunks
)
// HTTP request parsing errors.
type ProtocolError struct {
- os.ErrorString;
+ os.ErrorString
}
var (
- ErrLineTooLong = &ProtocolError{"header line too long"};
- ErrHeaderTooLong = &ProtocolError{"header too long"};
- ErrShortBody = &ProtocolError{"entity body too short"};
+ ErrLineTooLong = &ProtocolError{"header line too long"}
+ ErrHeaderTooLong = &ProtocolError{"header too long"}
+ ErrShortBody = &ProtocolError{"entity body too short"}
)
type badStringError struct {
- what string;
- str string;
+ what string
+ str string
}
-func (e *badStringError) String() string { return fmt.Sprintf("%s %q", e.what, e.str) }
+func (e *badStringError) String() string { return fmt.Sprintf("%s %q", e.what, e.str) }
// A Request represents a parsed HTTP request header.
type Request struct {
- Method string; // GET, POST, PUT, etc.
- RawURL string; // The raw URL given in the request.
- URL *URL; // Parsed URL.
- Proto string; // "HTTP/1.0"
- ProtoMajor int; // 1
- ProtoMinor int; // 0
+ Method string // GET, POST, PUT, etc.
+ RawURL string // The raw URL given in the request.
+ URL *URL // Parsed URL.
+ Proto string // "HTTP/1.0"
+ ProtoMajor int // 1
+ ProtoMinor int // 0
// A header mapping request lines to their values.
// If the header says
// The request parser implements this by canonicalizing the
// name, making the first character and any characters
// following a hyphen uppercase and the rest lowercase.
- Header map[string]string;
+ Header map[string]string
// The message body.
- Body io.Reader;
+ Body io.Reader
// Whether to close the connection after replying to this request.
- Close bool;
+ Close bool
// The host on which the URL is sought.
// Per RFC 2616, this is either the value of the Host: header
// or the host name given in the URL itself.
- Host string;
+ Host string
// The referring URL, if sent in the request.
//
// can diagnose programs that use the alternate
// (correct English) spelling req.Referrer but cannot
// diagnose programs that use Header["Referrer"].
- Referer string;
+ Referer string
// The User-Agent: header string, if sent in the request.
- UserAgent string;
+ UserAgent string
// The parsed form. Only available after ParseForm is called.
- Form map[string][]string;
+ Form map[string][]string
}
// ProtoAtLeast returns whether the HTTP protocol used
if value != "" {
return value
}
- return def;
+ return def
}
const defaultUserAgent = "Go http package"
//
// If Body is present, "Transfer-Encoding: chunked" is forced as a header.
func (req *Request) Write(w io.Writer) os.Error {
- uri := URLEscape(req.URL.Path);
+ uri := URLEscape(req.URL.Path)
if req.URL.RawQuery != "" {
uri += "?" + req.URL.RawQuery
}
- fmt.Fprintf(w, "%s %s HTTP/1.1\r\n", valueOrDefault(req.Method, "GET"), uri);
- fmt.Fprintf(w, "Host: %s\r\n", req.URL.Host);
- fmt.Fprintf(w, "User-Agent: %s\r\n", valueOrDefault(req.UserAgent, defaultUserAgent));
+ fmt.Fprintf(w, "%s %s HTTP/1.1\r\n", valueOrDefault(req.Method, "GET"), uri)
+ fmt.Fprintf(w, "Host: %s\r\n", req.URL.Host)
+ fmt.Fprintf(w, "User-Agent: %s\r\n", valueOrDefault(req.UserAgent, defaultUserAgent))
if req.Referer != "" {
fmt.Fprintf(w, "Referer: %s\r\n", req.Referer)
io.WriteString(w, k+": "+v+"\r\n")
}
- io.WriteString(w, "\r\n");
+ io.WriteString(w, "\r\n")
if req.Body != nil {
- buf := make([]byte, chunkSize);
+ buf := make([]byte, chunkSize)
Loop:
for {
- var nr, nw int;
- var er, ew os.Error;
+ var nr, nw int
+ var er, ew os.Error
if nr, er = req.Body.Read(buf); nr > 0 {
if er == nil || er == os.EOF {
- fmt.Fprintf(w, "%x\r\n", nr);
- nw, ew = w.Write(buf[0:nr]);
- fmt.Fprint(w, "\r\n");
+ fmt.Fprintf(w, "%x\r\n", nr)
+ nw, ew = w.Write(buf[0:nr])
+ fmt.Fprint(w, "\r\n")
}
}
switch {
if er == os.EOF {
break Loop
}
- return er;
+ return er
case ew != nil:
return ew
case nw < nr:
}
}
// last-chunk CRLF
- fmt.Fprint(w, "0\r\n\r\n");
+ fmt.Fprint(w, "0\r\n\r\n")
}
- return nil;
+ return nil
}
// Read a line of bytes (up to \n) from b.
if err == os.EOF {
err = io.ErrUnexpectedEOF
}
- return nil, err;
+ return nil, err
}
if len(p) >= maxLineLength {
return nil, ErrLineTooLong
}
// Chop off trailing white space.
- var i int;
+ var i int
for i = len(p); i > 0; i-- {
if c := p[i-1]; c != ' ' && c != '\r' && c != '\t' && c != '\n' {
break
}
}
- return p[0:i], nil;
+ return p[0:i], nil
}
// readLineBytes, but convert the bytes into a string.
func readLine(b *bufio.Reader) (s string, err os.Error) {
- p, e := readLineBytes(b);
+ p, e := readLineBytes(b)
if e != nil {
return "", e
}
- return string(p), nil;
+ return string(p), nil
}
var colon = []byte{':'}
// and the Value can continue on multiple lines if each continuation line
// starts with a space.
func readKeyValue(b *bufio.Reader) (key, value string, err os.Error) {
- line, e := readLineBytes(b);
+ line, e := readLineBytes(b)
if e != nil {
return "", "", e
}
}
// Scan first line for colon.
- i := bytes.Index(line, colon);
+ i := bytes.Index(line, colon)
if i < 0 {
goto Malformed
}
- key = string(line[0:i]);
+ key = string(line[0:i])
if strings.Index(key, " ") >= 0 {
// Key field has space - no good.
goto Malformed
break
}
}
- value = string(line[i:]);
+ value = string(line[i:])
// Look for extension lines, which must begin with space.
for {
- c, e := b.ReadByte();
+ c, e := b.ReadByte()
if c != ' ' {
if e != os.EOF {
b.UnreadByte()
}
- break;
+ break
}
// Eat leading space.
if e == os.EOF {
e = io.ErrUnexpectedEOF
}
- return "", "", e;
+ return "", "", e
}
}
- b.UnreadByte();
+ b.UnreadByte()
// Read the rest of the line and add to value.
if line, e = readLineBytes(b); e != nil {
return "", "", e
}
- value += " " + string(line);
+ value += " " + string(line)
if len(value) >= maxValueLength {
return "", "", &badStringError{"value too long for key", key}
}
}
- return key, value, nil;
+ return key, value, nil
Malformed:
- return "", "", &badStringError{"malformed header line", string(line)};
+ return "", "", &badStringError{"malformed header line", string(line)}
}
// Convert decimal at s[i:len(s)] to integer,
// returning value, string position where the digits stopped,
// and whether there was a valid number (digits, not too big).
func atoi(s string, i int) (n, i1 int, ok bool) {
- const Big = 1000000;
+ const Big = 1000000
if i >= len(s) || s[i] < '0' || s[i] > '9' {
return 0, 0, false
}
- n = 0;
+ n = 0
for ; i < len(s) && '0' <= s[i] && s[i] <= '9'; i++ {
- n = n*10 + int(s[i]-'0');
+ n = n*10 + int(s[i]-'0')
if n > Big {
return 0, 0, false
}
}
- return n, i, true;
+ return n, i, true
}
// Parse HTTP version: "HTTP/1.2" -> (1, 2, true).
if vers[0:5] != "HTTP/" {
return 0, 0, false
}
- major, i, ok := atoi(vers, 5);
+ major, i, ok := atoi(vers, 5)
if !ok || i >= len(vers) || vers[i] != '.' {
return 0, 0, false
}
- var minor int;
- minor, i, ok = atoi(vers, i+1);
+ var minor int
+ minor, i, ok = atoi(vers, i+1)
if !ok || i != len(vers) {
return 0, 0, false
}
- return major, minor, true;
+ return major, minor, true
}
var cmap = make(map[string]string)
// and upper case after each dash.
// (Host, User-Agent, If-Modified-Since).
// HTTP headers are ASCII only, so no Unicode issues.
- a := strings.Bytes(s);
- upper := true;
+ a := strings.Bytes(s)
+ upper := true
for i, v := range a {
if upper && 'a' <= v && v <= 'z' {
a[i] = v + 'A' - 'a'
if !upper && 'A' <= v && v <= 'Z' {
a[i] = v + 'a' - 'A'
}
- upper = false;
+ upper = false
if v == '-' {
upper = true
}
}
- t := string(a);
- cmap[s] = t;
- return t;
+ t := string(a)
+ cmap[s] = t
+ return t
}
type chunkedReader struct {
- r *bufio.Reader;
- n uint64; // unread bytes in chunk
- err os.Error;
+ r *bufio.Reader
+ n uint64 // unread bytes in chunk
+ err os.Error
}
func newChunkedReader(r *bufio.Reader) *chunkedReader {
func (cr *chunkedReader) beginChunk() {
// chunk-size CRLF
- var line string;
- line, cr.err = readLine(cr.r);
+ var line string
+ line, cr.err = readLine(cr.r)
if cr.err != nil {
return
}
- cr.n, cr.err = strconv.Btoui64(line, 16);
+ cr.n, cr.err = strconv.Btoui64(line, 16)
if cr.err != nil {
return
}
if cr.n == 0 {
// trailer CRLF
for {
- line, cr.err = readLine(cr.r);
+ line, cr.err = readLine(cr.r)
if cr.err != nil {
return
}
break
}
}
- cr.err = os.EOF;
+ cr.err = os.EOF
}
}
return 0, cr.err
}
if cr.n == 0 {
- cr.beginChunk();
+ cr.beginChunk()
if cr.err != nil {
return 0, cr.err
}
if uint64(len(b)) > cr.n {
b = b[0:cr.n]
}
- n, cr.err = cr.r.Read(b);
- cr.n -= uint64(n);
+ n, cr.err = cr.r.Read(b)
+ cr.n -= uint64(n)
if cr.n == 0 && cr.err == nil {
// end of chunk (CRLF)
- b := make([]byte, 2);
+ b := make([]byte, 2)
if _, cr.err = io.ReadFull(cr.r, b); cr.err == nil {
if b[0] != '\r' || b[1] != '\n' {
cr.err = os.NewError("malformed chunked encoding")
}
}
}
- return n, cr.err;
+ return n, cr.err
}
// ReadRequest reads and parses a request from b.
func ReadRequest(b *bufio.Reader) (req *Request, err os.Error) {
- req = new(Request);
+ req = new(Request)
// First line: GET /index.html HTTP/1.0
- var s string;
+ var s string
if s, err = readLine(b); err != nil {
return nil, err
}
- var f []string;
+ var f []string
if f = strings.Split(s, " ", 3); len(f) < 3 {
return nil, &badStringError{"malformed HTTP request", s}
}
- req.Method, req.RawURL, req.Proto = f[0], f[1], f[2];
- var ok bool;
+ req.Method, req.RawURL, req.Proto = f[0], f[1], f[2]
+ var ok bool
if req.ProtoMajor, req.ProtoMinor, ok = parseHTTPVersion(req.Proto); !ok {
return nil, &badStringError{"malformed HTTP version", req.Proto}
}
}
// Subsequent lines: Key: value.
- nheader := 0;
- req.Header = make(map[string]string);
+ nheader := 0
+ req.Header = make(map[string]string)
for {
- var key, value string;
+ var key, value string
if key, value, err = readKeyValue(b); err != nil {
return nil, err
}
return nil, ErrHeaderTooLong
}
- key = CanonicalHeaderKey(key);
+ key = CanonicalHeaderKey(key)
// RFC 2616 says that if you send the same header key
// multiple times, it has to be semantically equivalent
// to concatenating the values separated by commas.
- oldvalue, present := req.Header[key];
+ oldvalue, present := req.Header[key]
if present {
req.Header[key] = oldvalue + "," + value
} else {
if v, present := req.Header["Transfer-Encoding"]; present && v == "chunked" {
req.Body = newChunkedReader(b)
} else if v, present := req.Header["Content-Length"]; present {
- length, err := strconv.Btoui64(v, 10);
+ length, err := strconv.Btoui64(v, 10)
if err != nil {
return nil, &badStringError{"invalid Content-Length", v}
}
// TODO: limit the Content-Length. This is an easy DoS vector.
- raw := make([]byte, length);
- n, err := b.Read(raw);
+ raw := make([]byte, length)
+ n, err := b.Read(raw)
if err != nil || uint64(n) < length {
return nil, ErrShortBody
}
- req.Body = bytes.NewBuffer(raw);
+ req.Body = bytes.NewBuffer(raw)
}
- return req, nil;
+ return req, nil
}
func parseForm(m map[string][]string, query string) (err os.Error) {
- data := make(map[string]*vector.StringVector);
+ data := make(map[string]*vector.StringVector)
for _, kv := range strings.Split(query, "&", 0) {
- kvPair := strings.Split(kv, "=", 2);
+ kvPair := strings.Split(kv, "=", 2)
- var key, value string;
- var e os.Error;
- key, e = URLUnescape(kvPair[0]);
+ var key, value string
+ var e os.Error
+ key, e = URLUnescape(kvPair[0])
if e == nil && len(kvPair) > 1 {
value, e = URLUnescape(kvPair[1])
}
err = e
}
- vec, ok := data[key];
+ vec, ok := data[key]
if !ok {
- vec = new(vector.StringVector);
- data[key] = vec;
+ vec = new(vector.StringVector)
+ data[key] = vec
}
- vec.Push(value);
+ vec.Push(value)
}
for k, vec := range data {
m[k] = vec.Data()
}
- return;
+ return
}
// ParseForm parses the request body as a form for POST requests, or the raw query for GET requests.
if r.Form != nil {
return
}
- r.Form = make(map[string][]string);
+ r.Form = make(map[string][]string)
- var query string;
+ var query string
switch r.Method {
case "GET":
query = r.URL.RawQuery
if r.Body == nil {
return os.ErrorString("missing form body")
}
- ct, _ := r.Header["Content-Type"];
+ ct, _ := r.Header["Content-Type"]
switch strings.Split(ct, ";", 2)[0] {
case "text/plain", "application/x-www-form-urlencoded", "":
- var b []byte;
+ var b []byte
if b, err = ioutil.ReadAll(r.Body); err != nil {
return err
}
- query = string(b);
+ query = string(b)
// TODO(dsymonds): Handle multipart/form-data
default:
return &badStringError{"unknown Content-Type", ct}
}
}
- return parseForm(r.Form, query);
+ return parseForm(r.Form, query)
}
// FormValue returns the first value for the named component of the query.
if vs, ok := r.Form[key]; ok && len(vs) > 0 {
return vs[0]
}
- return "";
+ return ""
}
package http
import (
- "bytes";
- "testing";
+ "bytes"
+ "testing"
)
type stringMultimap map[string][]string
type parseTest struct {
- query string;
- out stringMultimap;
+ query string
+ out stringMultimap
}
var parseTests = []parseTest{
func TestParseForm(t *testing.T) {
for i, test := range parseTests {
- form := make(map[string][]string);
- err := parseForm(form, test.query);
+ form := make(map[string][]string)
+ err := parseForm(form, test.query)
if err != nil {
- t.Errorf("test %d: Unexpected error: %v", i, err);
- continue;
+ t.Errorf("test %d: Unexpected error: %v", i, err)
+ continue
}
if len(form) != len(test.out) {
t.Errorf("test %d: len(form) = %d, want %d", i, len(form), len(test.out))
}
for k, evs := range test.out {
- vs, ok := form[k];
+ vs, ok := form[k]
if !ok {
- t.Errorf("test %d: Missing key %q", i, k);
- continue;
+ t.Errorf("test %d: Missing key %q", i, k)
+ continue
}
if len(vs) != len(evs) {
- t.Errorf("test %d: len(form[%q]) = %d, want %d", i, k, len(vs), len(evs));
- continue;
+ t.Errorf("test %d: len(form[%q]) = %d, want %d", i, k, len(vs), len(evs))
+ continue
}
for j, ev := range evs {
if v := vs[j]; v != ev {
}
func TestQuery(t *testing.T) {
- req := &Request{Method: "GET"};
- req.URL, _ = ParseURL("http://www.google.com/search?q=foo&q=bar");
+ req := &Request{Method: "GET"}
+ req.URL, _ = ParseURL("http://www.google.com/search?q=foo&q=bar")
if q := req.FormValue("q"); q != "foo" {
t.Errorf(`req.FormValue("q") = %q, want "foo"`, q)
}
type stringMap map[string]string
type parseContentTypeTest struct {
- contentType stringMap;
- error bool;
+ contentType stringMap
+ error bool
}
var parseContentTypeTests = []parseContentTypeTest{
Method: "POST",
Header: test.contentType,
Body: bytes.NewBufferString("body"),
- };
- err := req.ParseForm();
+ }
+ err := req.ParseForm()
if !test.error && err != nil {
t.Errorf("test %d: Unexpected error: %v", i, err)
}
func TestRedirect(t *testing.T) {
const (
- start = "http://codesearch.google.com/";
- end = "http://www.google.com/codesearch";
+ start = "http://codesearch.google.com/"
+ end = "http://www.google.com/codesearch"
)
- r, url, err := Get(start);
+ r, url, err := Get(start)
if err != nil {
t.Fatal(err)
}
- r.Body.Close();
+ r.Body.Close()
if r.StatusCode != 200 || url != end {
t.Fatalf("Get(%s) got status %d at %s, want 200 at %s", start, r.StatusCode, url, end)
}
package http
import (
- "bufio";
- "fmt";
- "io";
- "log";
- "net";
- "os";
- "path";
- "strconv";
- "strings";
+ "bufio"
+ "fmt"
+ "io"
+ "log"
+ "net"
+ "os"
+ "path"
+ "strconv"
+ "strings"
)
// Errors introduced by the HTTP server.
var (
- ErrWriteAfterFlush = os.NewError("Conn.Write called after Flush");
- ErrHijacked = os.NewError("Conn has been hijacked");
+ ErrWriteAfterFlush = os.NewError("Conn.Write called after Flush")
+ ErrHijacked = os.NewError("Conn has been hijacked")
)
// Objects implementing the Handler interface can be
// registered to serve a particular path or subtree
// in the HTTP server.
type Handler interface {
- ServeHTTP(*Conn, *Request);
+ ServeHTTP(*Conn, *Request)
}
// A Conn represents the server side of a single active HTTP connection.
type Conn struct {
- RemoteAddr string; // network address of remote side
- Req *Request; // current HTTP request
+ RemoteAddr string // network address of remote side
+ Req *Request // current HTTP request
- rwc io.ReadWriteCloser; // i/o connection
- buf *bufio.ReadWriter; // buffered rwc
- handler Handler; // request handler
- hijacked bool; // connection has been hijacked by handler
+ rwc io.ReadWriteCloser // i/o connection
+ buf *bufio.ReadWriter // buffered rwc
+ handler Handler // request handler
+ hijacked bool // connection has been hijacked by handler
// state for the current reply
- closeAfterReply bool; // close connection after this reply
- chunking bool; // using chunked transfer encoding for reply body
- wroteHeader bool; // reply header has been written
- header map[string]string; // reply header parameters
- written int64; // number of bytes written in body
- status int; // status code passed to WriteHeader
+ closeAfterReply bool // close connection after this reply
+ chunking bool // using chunked transfer encoding for reply body
+ wroteHeader bool // reply header has been written
+ header map[string]string // reply header parameters
+ written int64 // number of bytes written in body
+ status int // status code passed to WriteHeader
}
// Create new connection from rwc.
func newConn(rwc net.Conn, handler Handler) (c *Conn, err os.Error) {
- c = new(Conn);
+ c = new(Conn)
if a := rwc.RemoteAddr(); a != nil {
c.RemoteAddr = a.String()
}
- c.handler = handler;
- c.rwc = rwc;
- br := bufio.NewReader(rwc);
- bw := bufio.NewWriter(rwc);
- c.buf = bufio.NewReadWriter(br, bw);
- return c, nil;
+ c.handler = handler
+ c.rwc = rwc
+ br := bufio.NewReader(rwc)
+ bw := bufio.NewWriter(rwc)
+ c.buf = bufio.NewReadWriter(br, bw)
+ return c, nil
}
// Read next request from connection.
}
// Reset per-request connection state.
- c.header = make(map[string]string);
- c.wroteHeader = false;
- c.Req = req;
+ c.header = make(map[string]string)
+ c.wroteHeader = false
+ c.Req = req
// Default output is HTML encoded in UTF-8.
- c.SetHeader("Content-Type", "text/html; charset=utf-8");
+ c.SetHeader("Content-Type", "text/html; charset=utf-8")
if req.ProtoAtLeast(1, 1) {
// HTTP/1.1 or greater: use chunked transfer encoding
// to avoid closing the connection at EOF.
- c.chunking = true;
- c.SetHeader("Transfer-Encoding", "chunked");
+ c.chunking = true
+ c.SetHeader("Transfer-Encoding", "chunked")
} else {
// HTTP version < 1.1: cannot do chunked transfer
// encoding, so signal EOF by closing connection.
// a Content-Length: header in the response,
// but everyone who expects persistent connections
// does HTTP/1.1 now.
- c.closeAfterReply = true;
- c.chunking = false;
+ c.closeAfterReply = true
+ c.chunking = false
}
- return req, nil;
+ return req, nil
}
// SetHeader sets a header line in the eventual reply.
// Content-Type in this library, so users need not make that
// particular call. Calls to SetHeader after WriteHeader (or Write)
// are ignored.
-func (c *Conn) SetHeader(hdr, val string) { c.header[CanonicalHeaderKey(hdr)] = val }
+func (c *Conn) SetHeader(hdr, val string) { c.header[CanonicalHeaderKey(hdr)] = val }
// WriteHeader sends an HTTP response header with status code.
// If WriteHeader is not called explicitly, the first call to Write
// send error codes.
func (c *Conn) WriteHeader(code int) {
if c.hijacked {
- log.Stderr("http: Conn.WriteHeader on hijacked connection");
- return;
+ log.Stderr("http: Conn.WriteHeader on hijacked connection")
+ return
}
if c.wroteHeader {
- log.Stderr("http: multiple Conn.WriteHeader calls");
- return;
+ log.Stderr("http: multiple Conn.WriteHeader calls")
+ return
}
- c.wroteHeader = true;
- c.status = code;
- c.written = 0;
+ c.wroteHeader = true
+ c.status = code
+ c.written = 0
if !c.Req.ProtoAtLeast(1, 0) {
return
}
- proto := "HTTP/1.0";
+ proto := "HTTP/1.0"
if c.Req.ProtoAtLeast(1, 1) {
proto = "HTTP/1.1"
}
- codestring := strconv.Itoa(code);
- text, ok := statusText[code];
+ codestring := strconv.Itoa(code)
+ text, ok := statusText[code]
if !ok {
text = "status code " + codestring
}
- io.WriteString(c.buf, proto+" "+codestring+" "+text+"\r\n");
+ io.WriteString(c.buf, proto+" "+codestring+" "+text+"\r\n")
for k, v := range c.header {
io.WriteString(c.buf, k+": "+v+"\r\n")
}
- io.WriteString(c.buf, "\r\n");
+ io.WriteString(c.buf, "\r\n")
}
// Write writes the data to the connection as part of an HTTP reply.
// before writing the data.
func (c *Conn) Write(data []byte) (n int, err os.Error) {
if c.hijacked {
- log.Stderr("http: Conn.Write on hijacked connection");
- return 0, ErrHijacked;
+ log.Stderr("http: Conn.Write on hijacked connection")
+ return 0, ErrHijacked
}
if !c.wroteHeader {
c.WriteHeader(StatusOK)
return 0, nil
}
- c.written += int64(len(data)); // ignoring errors, for errorKludge
+ c.written += int64(len(data)) // ignoring errors, for errorKludge
// TODO(rsc): if chunking happened after the buffering,
// then there would be fewer chunk headers.
// On the other hand, it would make hijacking more difficult.
if c.chunking {
- fmt.Fprintf(c.buf, "%x\r\n", len(data)) // TODO(rsc): use strconv not fmt
+ fmt.Fprintf(c.buf, "%x\r\n", len(data)) // TODO(rsc): use strconv not fmt
}
- n, err = c.buf.Write(data);
+ n, err = c.buf.Write(data)
if err == nil && c.chunking {
if n != len(data) {
err = io.ErrShortWrite
}
}
- return n, err;
+ return n, err
}
// If this is an error reply (4xx or 5xx)
// browsers are in the 256-512 range.
// Pad to 1024 bytes.
func errorKludge(c *Conn, req *Request) {
- const min = 1024;
+ const min = 1024
// Is this an error?
if kind := c.status / 100; kind != 4 && kind != 5 {
}
// Is it a broken browser?
- var msg string;
+ var msg string
switch agent := req.UserAgent; {
case strings.Index(agent, "MSIE") >= 0:
msg = "Internet Explorer"
default:
return
}
- msg += " would ignore this error page if this text weren't here.\n";
+ msg += " would ignore this error page if this text weren't here.\n"
// Is it text? ("Content-Type" is always in the map)
- baseType := strings.Split(c.header["Content-Type"], ";", 2)[0];
+ baseType := strings.Split(c.header["Content-Type"], ";", 2)[0]
switch baseType {
case "text/html":
- io.WriteString(c, "<!-- ");
+ io.WriteString(c, "<!-- ")
for c.written < min {
io.WriteString(c, msg)
}
- io.WriteString(c, " -->");
+ io.WriteString(c, " -->")
case "text/plain":
- io.WriteString(c, "\n");
+ io.WriteString(c, "\n")
for c.written < min {
io.WriteString(c, msg)
}
if !c.wroteHeader {
c.WriteHeader(StatusOK)
}
- errorKludge(c, c.Req);
+ errorKludge(c, c.Req)
if c.chunking {
- io.WriteString(c.buf, "0\r\n");
+ io.WriteString(c.buf, "0\r\n")
// trailer key/value pairs, followed by blank line
- io.WriteString(c.buf, "\r\n");
+ io.WriteString(c.buf, "\r\n")
}
- c.buf.Flush();
+ c.buf.Flush()
}
// Flush sends any buffered data to the client.
if !c.wroteHeader {
c.WriteHeader(StatusOK)
}
- c.buf.Flush();
+ c.buf.Flush()
}
// Close the connection.
func (c *Conn) close() {
if c.buf != nil {
- c.buf.Flush();
- c.buf = nil;
+ c.buf.Flush()
+ c.buf = nil
}
if c.rwc != nil {
- c.rwc.Close();
- c.rwc = nil;
+ c.rwc.Close()
+ c.rwc = nil
}
}
// Serve a new connection.
func (c *Conn) serve() {
for {
- req, err := c.readRequest();
+ req, err := c.readRequest()
if err != nil {
break
}
// HTTP cannot have multiple simultaneous active requests.
// Until the server replies to this request, it can't read another,
// so we might as well run the handler in this goroutine.
- c.handler.ServeHTTP(c, req);
+ c.handler.ServeHTTP(c, req)
if c.hijacked {
return
}
- c.finishRequest();
+ c.finishRequest()
if c.closeAfterReply {
break
}
}
- c.close();
+ c.close()
}
// Hijack lets the caller take over the connection.
if c.hijacked {
return nil, nil, ErrHijacked
}
- c.hijacked = true;
- rwc = c.rwc;
- buf = c.buf;
- c.rwc = nil;
- c.buf = nil;
- return;
+ c.hijacked = true
+ rwc = c.rwc
+ buf = c.buf
+ c.rwc = nil
+ c.buf = nil
+ return
}
// The HandlerFunc type is an adapter to allow the use of
// NotFound replies to the request with an HTTP 404 not found error.
func NotFound(c *Conn, req *Request) {
- c.SetHeader("Content-Type", "text/plain; charset=utf-8");
- c.WriteHeader(StatusNotFound);
- io.WriteString(c, "404 page not found\n");
+ c.SetHeader("Content-Type", "text/plain; charset=utf-8")
+ c.WriteHeader(StatusNotFound)
+ io.WriteString(c, "404 page not found\n")
}
// NotFoundHandler returns a simple request handler
// that replies to each request with a ``404 page not found'' reply.
-func NotFoundHandler() Handler { return HandlerFunc(NotFound) }
+func NotFoundHandler() Handler { return HandlerFunc(NotFound) }
// Redirect replies to the request with a redirect to url,
// which may be a path relative to the request path.
func Redirect(c *Conn, url string, code int) {
// RFC2616 recommends that a short note "SHOULD" be included in the
// response because older user agents may not understand 301/307.
- note := "<a href=\"%v\">" + statusText[code] + "</a>.\n";
+ note := "<a href=\"%v\">" + statusText[code] + "</a>.\n"
if c.Req.Method == "POST" {
note = ""
}
- u, err := ParseURL(url);
+ u, err := ParseURL(url)
if err != nil {
goto finish
}
// Because of this problem, no one pays attention
// to the RFC; they all send back just a new path.
// So do we.
- oldpath := c.Req.URL.Path;
- if oldpath == "" { // should not happen, but avoid a crash if it does
+ oldpath := c.Req.URL.Path
+ if oldpath == "" { // should not happen, but avoid a crash if it does
oldpath = "/"
}
if u.Scheme == "" {
// no leading http://server
if url == "" || url[0] != '/' {
// make relative path absolute
- olddir, _ := path.Split(oldpath);
- url = olddir + url;
+ olddir, _ := path.Split(oldpath)
+ url = olddir + url
}
// clean up but preserve trailing slash
- trailing := url[len(url)-1] == '/';
- url = path.Clean(url);
+ trailing := url[len(url)-1] == '/'
+ url = path.Clean(url)
if trailing && url[len(url)-1] != '/' {
url += "/"
}
}
finish:
- c.SetHeader("Location", url);
- c.WriteHeader(code);
- fmt.Fprintf(c, note, url);
+ c.SetHeader("Location", url)
+ c.WriteHeader(code)
+ fmt.Fprintf(c, note, url)
}
// Redirect to a fixed URL
type redirectHandler struct {
- url string;
- code int;
+ url string
+ code int
}
func (rh *redirectHandler) ServeHTTP(c *Conn, req *Request) {
// redirecting any request containing . or .. elements to an
// equivalent .- and ..-free URL.
type ServeMux struct {
- m map[string]Handler;
+ m map[string]Handler
}
// NewServeMux allocates and returns a new ServeMux.
-func NewServeMux() *ServeMux { return &ServeMux{make(map[string]Handler)} }
+func NewServeMux() *ServeMux { return &ServeMux{make(map[string]Handler)} }
// DefaultServeMux is the default ServeMux used by Serve.
var DefaultServeMux = NewServeMux()
// should not happen
return false
}
- n := len(pattern);
+ n := len(pattern)
if pattern[n-1] != '/' {
return pattern == path
}
- return len(path) >= n && path[0:n] == pattern;
+ return len(path) >= n && path[0:n] == pattern
}
// Return the canonical path for p, eliminating . and .. elements.
if p[0] != '/' {
p = "/" + p
}
- np := path.Clean(p);
+ np := path.Clean(p)
// path.Clean removes trailing slash except for root;
// put the trailing slash back if necessary.
if p[len(p)-1] == '/' && np != "/" {
np += "/"
}
- return np;
+ return np
}
// ServeHTTP dispatches the request to the handler whose
func (mux *ServeMux) ServeHTTP(c *Conn, req *Request) {
// Clean path to canonical form and redirect.
if p := cleanPath(req.URL.Path); p != req.URL.Path {
- c.SetHeader("Location", p);
- c.WriteHeader(StatusMovedPermanently);
- return;
+ c.SetHeader("Location", p)
+ c.WriteHeader(StatusMovedPermanently)
+ return
}
// Most-specific (longest) pattern wins.
- var h Handler;
- var n = 0;
+ var h Handler
+ var n = 0
for k, v := range mux.m {
if !pathMatch(k, req.URL.Path) {
continue
}
if h == nil || len(k) > n {
- n = len(k);
- h = v;
+ n = len(k)
+ h = v
}
}
if h == nil {
h = NotFoundHandler()
}
- h.ServeHTTP(c, req);
+ h.ServeHTTP(c, req)
}
// Handle registers the handler for the given pattern.
panicln("http: invalid pattern", pattern)
}
- mux.m[pattern] = handler;
+ mux.m[pattern] = handler
// Helpful behavior:
// If pattern is /tree/, insert permanent redirect for /tree.
- n := len(pattern);
+ n := len(pattern)
if n > 0 && pattern[n-1] == '/' {
mux.m[pattern[0:n-1]] = RedirectHandler(pattern, StatusMovedPermanently)
}
// Handle registers the handler for the given pattern
// in the DefaultServeMux.
-func Handle(pattern string, handler Handler) { DefaultServeMux.Handle(pattern, handler) }
+func Handle(pattern string, handler Handler) { DefaultServeMux.Handle(pattern, handler) }
// Serve accepts incoming HTTP connections on the listener l,
// creating a new service thread for each. The service threads
handler = DefaultServeMux
}
for {
- rw, e := l.Accept();
+ rw, e := l.Accept()
if e != nil {
return e
}
- c, err := newConn(rw, handler);
+ c, err := newConn(rw, handler)
if err != nil {
continue
}
- go c.serve();
+ go c.serve()
}
- panic("not reached");
+ panic("not reached")
}
// ListenAndServe listens on the TCP network address addr
// }
// }
func ListenAndServe(addr string, handler Handler) os.Error {
- l, e := net.Listen("tcp", addr);
+ l, e := net.Listen("tcp", addr)
if e != nil {
return e
}
- e = Serve(l, handler);
- l.Close();
- return e;
+ e = Serve(l, handler)
+ l.Close()
+ return e
}
// HTTP status codes, defined in RFC 2616.
const (
- StatusContinue = 100;
- StatusSwitchingProtocols = 101;
+ StatusContinue = 100
+ StatusSwitchingProtocols = 101
- StatusOK = 200;
- StatusCreated = 201;
- StatusAccepted = 202;
- StatusNonAuthoritativeInfo = 203;
- StatusNoContent = 204;
- StatusResetContent = 205;
- StatusPartialContent = 206;
+ StatusOK = 200
+ StatusCreated = 201
+ StatusAccepted = 202
+ StatusNonAuthoritativeInfo = 203
+ StatusNoContent = 204
+ StatusResetContent = 205
+ StatusPartialContent = 206
- StatusMultipleChoices = 300;
- StatusMovedPermanently = 301;
- StatusFound = 302;
- StatusSeeOther = 303;
- StatusNotModified = 304;
- StatusUseProxy = 305;
- StatusTemporaryRedirect = 307;
+ StatusMultipleChoices = 300
+ StatusMovedPermanently = 301
+ StatusFound = 302
+ StatusSeeOther = 303
+ StatusNotModified = 304
+ StatusUseProxy = 305
+ StatusTemporaryRedirect = 307
- StatusBadRequest = 400;
- StatusUnauthorized = 401;
- StatusPaymentRequired = 402;
- StatusForbidden = 403;
- StatusNotFound = 404;
- StatusMethodNotAllowed = 405;
- StatusNotAcceptable = 406;
- StatusProxyAuthRequired = 407;
- StatusRequestTimeout = 408;
- StatusConflict = 409;
- StatusGone = 410;
- StatusLengthRequired = 411;
- StatusPreconditionFailed = 412;
- StatusRequestEntityTooLarge = 413;
- StatusRequestURITooLong = 414;
- StatusUnsupportedMediaType = 415;
- StatusRequestedRangeNotSatisfiable = 416;
- StatusExpectationFailed = 417;
+ StatusBadRequest = 400
+ StatusUnauthorized = 401
+ StatusPaymentRequired = 402
+ StatusForbidden = 403
+ StatusNotFound = 404
+ StatusMethodNotAllowed = 405
+ StatusNotAcceptable = 406
+ StatusProxyAuthRequired = 407
+ StatusRequestTimeout = 408
+ StatusConflict = 409
+ StatusGone = 410
+ StatusLengthRequired = 411
+ StatusPreconditionFailed = 412
+ StatusRequestEntityTooLarge = 413
+ StatusRequestURITooLong = 414
+ StatusUnsupportedMediaType = 415
+ StatusRequestedRangeNotSatisfiable = 416
+ StatusExpectationFailed = 417
- StatusInternalServerError = 500;
- StatusNotImplemented = 501;
- StatusBadGateway = 502;
- StatusServiceUnavailable = 503;
- StatusGatewayTimeout = 504;
- StatusHTTPVersionNotSupported = 505;
+ StatusInternalServerError = 500
+ StatusNotImplemented = 501
+ StatusBadGateway = 502
+ StatusServiceUnavailable = 503
+ StatusGatewayTimeout = 504
+ StatusHTTPVersionNotSupported = 505
)
var statusText = map[int]string{
package main
import (
- "bytes";
- "bufio";
- "expvar";
- "flag";
- "fmt";
- "io";
- "log";
- "net";
- "os";
- "strconv";
+ "bytes"
+ "bufio"
+ "expvar"
+ "flag"
+ "fmt"
+ "io"
+ "log"
+ "net"
+ "os"
+ "strconv"
)
var helloRequests = expvar.NewInt("hello-requests")
func HelloServer(c *http.Conn, req *http.Request) {
- helloRequests.Add(1);
- io.WriteString(c, "hello, world!\n");
+ helloRequests.Add(1)
+ io.WriteString(c, "hello, world!\n")
}
// Simple counter server. POSTing to it will set the value.
type Counter struct {
- n int;
+ n int
}
// This makes Counter satisfy the expvar.Var interface, so we can export
// it directly.
-func (ctr *Counter) String() string { return fmt.Sprintf("%d", ctr.n) }
+func (ctr *Counter) String() string { return fmt.Sprintf("%d", ctr.n) }
func (ctr *Counter) ServeHTTP(c *http.Conn, req *http.Request) {
switch req.Method {
case "GET":
ctr.n++
case "POST":
- buf := new(bytes.Buffer);
- io.Copy(buf, req.Body);
- body := buf.String();
+ buf := new(bytes.Buffer)
+ io.Copy(buf, req.Body)
+ body := buf.String()
if n, err := strconv.Atoi(body); err != nil {
fmt.Fprintf(c, "bad POST: %v\nbody: [%v]\n", err, body)
} else {
- ctr.n = n;
- fmt.Fprint(c, "counter reset\n");
+ ctr.n = n
+ fmt.Fprint(c, "counter reset\n")
}
}
- fmt.Fprintf(c, "counter = %d\n", ctr.n);
+ fmt.Fprintf(c, "counter = %d\n", ctr.n)
}
// simple file server
var pathVar = expvar.NewMap("file-requests")
func FileServer(c *http.Conn, req *http.Request) {
- c.SetHeader("content-type", "text/plain; charset=utf-8");
- pathVar.Add(req.URL.Path, 1);
- path := *webroot + req.URL.Path; // TODO: insecure: use os.CleanName
- f, err := os.Open(path, os.O_RDONLY, 0);
+ c.SetHeader("content-type", "text/plain; charset=utf-8")
+ pathVar.Add(req.URL.Path, 1)
+ path := *webroot + req.URL.Path // TODO: insecure: use os.CleanName
+ f, err := os.Open(path, os.O_RDONLY, 0)
if err != nil {
- c.WriteHeader(http.StatusNotFound);
- fmt.Fprintf(c, "open %s: %v\n", path, err);
- return;
+ c.WriteHeader(http.StatusNotFound)
+ fmt.Fprintf(c, "open %s: %v\n", path, err)
+ return
}
- n, err1 := io.Copy(c, f);
- fmt.Fprintf(c, "[%d bytes]\n", n);
- f.Close();
+ n, err1 := io.Copy(c, f)
+ fmt.Fprintf(c, "[%d bytes]\n", n)
+ f.Close()
}
// simple flag server
var booleanflag = flag.Bool("boolean", true, "another flag for testing")
func FlagServer(c *http.Conn, req *http.Request) {
- c.SetHeader("content-type", "text/plain; charset=utf-8");
- fmt.Fprint(c, "Flags:\n");
+ c.SetHeader("content-type", "text/plain; charset=utf-8")
+ fmt.Fprint(c, "Flags:\n")
flag.VisitAll(func(f *flag.Flag) {
if f.Value.String() != f.DefValue {
fmt.Fprintf(c, "%s = %s [default = %s]\n", f.Name, f.Value.String(), f.DefValue)
} else {
fmt.Fprintf(c, "%s = %s\n", f.Name, f.Value.String())
}
- });
+ })
}
// simple argument server
type Chan chan int
func ChanCreate() Chan {
- c := make(Chan);
+ c := make(Chan)
go func(c Chan) {
for x := 0; ; x++ {
c <- x
}
- }(c);
- return c;
+ }(c)
+ return c
}
func (ch Chan) ServeHTTP(c *http.Conn, req *http.Request) {
// exec a program, redirecting output
func DateServer(c *http.Conn, req *http.Request) {
- c.SetHeader("content-type", "text/plain; charset=utf-8");
- r, w, err := os.Pipe();
+ c.SetHeader("content-type", "text/plain; charset=utf-8")
+ r, w, err := os.Pipe()
if err != nil {
- fmt.Fprintf(c, "pipe: %s\n", err);
- return;
+ fmt.Fprintf(c, "pipe: %s\n", err)
+ return
}
- pid, err := os.ForkExec("/bin/date", []string{"date"}, os.Environ(), "", []*os.File{nil, w, w});
- defer r.Close();
- w.Close();
+ pid, err := os.ForkExec("/bin/date", []string{"date"}, os.Environ(), "", []*os.File{nil, w, w})
+ defer r.Close()
+ w.Close()
if err != nil {
- fmt.Fprintf(c, "fork/exec: %s\n", err);
- return;
+ fmt.Fprintf(c, "fork/exec: %s\n", err)
+ return
}
- io.Copy(c, r);
- wait, err := os.Wait(pid, 0);
+ io.Copy(c, r)
+ wait, err := os.Wait(pid, 0)
if err != nil {
- fmt.Fprintf(c, "wait: %s\n", err);
- return;
+ fmt.Fprintf(c, "wait: %s\n", err)
+ return
}
if !wait.Exited() || wait.ExitStatus() != 0 {
- fmt.Fprintf(c, "date: %v\n", wait);
- return;
+ fmt.Fprintf(c, "date: %v\n", wait)
+ return
}
}
func main() {
- flag.Parse();
+ flag.Parse()
// The counter is published as a variable directly.
- ctr := new(Counter);
- http.Handle("/counter", ctr);
- expvar.Publish("counter", ctr);
-
- http.Handle("/go/", http.HandlerFunc(FileServer));
- http.Handle("/flags", http.HandlerFunc(FlagServer));
- http.Handle("/args", http.HandlerFunc(ArgServer));
- http.Handle("/go/hello", http.HandlerFunc(HelloServer));
- http.Handle("/chan", ChanCreate());
- http.Handle("/date", http.HandlerFunc(DateServer));
- err := http.ListenAndServe(":12345", nil);
+ ctr := new(Counter)
+ http.Handle("/counter", ctr)
+ expvar.Publish("counter", ctr)
+
+ http.Handle("/go/", http.HandlerFunc(FileServer))
+ http.Handle("/flags", http.HandlerFunc(FlagServer))
+ http.Handle("/args", http.HandlerFunc(ArgServer))
+ http.Handle("/go/hello", http.HandlerFunc(HelloServer))
+ http.Handle("/chan", ChanCreate())
+ http.Handle("/date", http.HandlerFunc(DateServer))
+ err := http.ListenAndServe(":12345", nil)
if err != nil {
log.Crash("ListenAndServe: ", err)
}
package http
import (
- "os";
- "strconv";
- "strings";
+ "os"
+ "strconv"
+ "strings"
)
// URLError reports an error and the operation and URL that caused it.
type URLError struct {
- Op string;
- URL string;
- Error os.Error;
+ Op string
+ URL string
+ Error os.Error
}
-func (e *URLError) String() string { return e.Op + " " + e.URL + ": " + e.Error.String() }
+func (e *URLError) String() string { return e.Op + " " + e.URL + ": " + e.Error.String() }
func ishex(c byte) bool {
switch {
case 'A' <= c && c <= 'F':
return true
}
- return false;
+ return false
}
func unhex(c byte) byte {
case 'A' <= c && c <= 'F':
return c - 'A' + 10
}
- return 0;
+ return 0
}
type URLEscapeError string
return true
}
switch c {
- case '<', '>', '#', '%', '"', // RFC 2396 delims
- '{', '}', '|', '\\', '^', '[', ']', '`', // RFC2396 unwise
- '?', '&', '=', '+': // RFC 2396 reserved in path
+ case '<', '>', '#', '%', '"', // RFC 2396 delims
+ '{', '}', '|', '\\', '^', '[', ']', '`', // RFC2396 unwise
+ '?', '&', '=', '+': // RFC 2396 reserved in path
return true
}
- return false;
+ return false
}
// URLUnescape unescapes a URL-encoded string,
// by two hexadecimal digits.
func URLUnescape(s string) (string, os.Error) {
// Count %, check that they're well-formed.
- n := 0;
- hasPlus := false;
+ n := 0
+ hasPlus := false
for i := 0; i < len(s); {
switch s[i] {
case '%':
- n++;
+ n++
if i+2 >= len(s) || !ishex(s[i+1]) || !ishex(s[i+2]) {
- s = s[i:];
+ s = s[i:]
if len(s) > 3 {
s = s[0:3]
}
- return "", URLEscapeError(s);
+ return "", URLEscapeError(s)
}
- i += 3;
+ i += 3
case '+':
- hasPlus = true;
- i++;
+ hasPlus = true
+ i++
default:
i++
}
return s, nil
}
- t := make([]byte, len(s)-2*n);
- j := 0;
+ t := make([]byte, len(s)-2*n)
+ j := 0
for i := 0; i < len(s); {
switch s[i] {
case '%':
- t[j] = unhex(s[i+1])<<4 | unhex(s[i+2]);
- j++;
- i += 3;
+ t[j] = unhex(s[i+1])<<4 | unhex(s[i+2])
+ j++
+ i += 3
case '+':
- t[j] = ' ';
- j++;
- i++;
+ t[j] = ' '
+ j++
+ i++
default:
- t[j] = s[i];
- j++;
- i++;
+ t[j] = s[i]
+ j++
+ i++
}
}
- return string(t), nil;
+ return string(t), nil
}
// URLEscape converts a string into URL-encoded form.
func URLEscape(s string) string {
- spaceCount, hexCount := 0, 0;
+ spaceCount, hexCount := 0, 0
for i := 0; i < len(s); i++ {
- c := s[i];
+ c := s[i]
if shouldEscape(c) {
if c == ' ' {
spaceCount++
return s
}
- t := make([]byte, len(s)+2*hexCount);
- j := 0;
+ t := make([]byte, len(s)+2*hexCount)
+ j := 0
for i := 0; i < len(s); i++ {
switch c := s[i]; {
case c == ' ':
- t[j] = '+';
- j++;
+ t[j] = '+'
+ j++
case shouldEscape(c):
- t[j] = '%';
- t[j+1] = "0123456789abcdef"[c>>4];
- t[j+2] = "0123456789abcdef"[c&15];
- j += 3;
+ t[j] = '%'
+ t[j+1] = "0123456789abcdef"[c>>4]
+ t[j+2] = "0123456789abcdef"[c&15]
+ j += 3
default:
- t[j] = s[i];
- j++;
+ t[j] = s[i]
+ j++
}
}
- return string(t);
+ return string(t)
}
// A URL represents a parsed URL (technically, a URI reference).
// Note, the reason for using wire format for the query is that it needs
// to be split into key/value pairs before decoding.
type URL struct {
- Raw string; // the original string
- Scheme string; // scheme
- RawPath string; // //[userinfo@]host/path[?query][#fragment]
- Authority string; // [userinfo@]host
- Userinfo string; // userinfo
- Host string; // host
- Path string; // /path
- RawQuery string; // query
- Fragment string; // fragment
+ Raw string // the original string
+ Scheme string // scheme
+ RawPath string // //[userinfo@]host/path[?query][#fragment]
+ Authority string // [userinfo@]host
+ Userinfo string // userinfo
+ Host string // host
+ Path string // /path
+ RawQuery string // query
+ Fragment string // fragment
}
// Maybe rawurl is of the form scheme:path.
// If so, return scheme, path; else return "", rawurl.
func getscheme(rawurl string) (scheme, path string, err os.Error) {
for i := 0; i < len(rawurl); i++ {
- c := rawurl[i];
+ c := rawurl[i]
switch {
case 'a' <= c && c <= 'z' || 'A' <= c && c <= 'Z':
// do nothing
if i == 0 {
return "", "", os.ErrorString("missing protocol scheme")
}
- return rawurl[0:i], rawurl[i+1:], nil;
+ return rawurl[0:i], rawurl[i+1:], nil
default:
// we have encountered an invalid character,
// so there is no valid scheme
return "", rawurl, nil
}
}
- return "", rawurl, nil;
+ return "", rawurl, nil
}
// Maybe s is of the form t c u.
if cutc {
return s[0:i], s[i+1:]
}
- return s[0:i], s[i:];
+ return s[0:i], s[i:]
}
}
- return s, "";
+ return s, ""
}
// TODO(rsc): The BUG comment is supposed to appear in the godoc output
// (Web browsers strip #fragment before sending the URL to a web server.)
func ParseURL(rawurl string) (url *URL, err os.Error) {
if rawurl == "" {
- err = os.ErrorString("empty url");
- goto Error;
+ err = os.ErrorString("empty url")
+ goto Error
}
- url = new(URL);
- url.Raw = rawurl;
+ url = new(URL)
+ url.Raw = rawurl
// split off possible leading "http:", "mailto:", etc.
- var path string;
+ var path string
if url.Scheme, path, err = getscheme(rawurl); err != nil {
goto Error
}
- url.RawPath = path;
+ url.RawPath = path
// RFC 2396: a relative URI (no scheme) has a ?query,
// but absolute URIs only have query if path begins with /
goto Error
}
if strings.Index(url.Scheme, "%") >= 0 {
- err = os.ErrorString("hexadecimal escape in scheme");
- goto Error;
+ err = os.ErrorString("hexadecimal escape in scheme")
+ goto Error
}
if strings.Index(url.Host, "%") >= 0 {
- err = os.ErrorString("hexadecimal escape in host");
- goto Error;
+ err = os.ErrorString("hexadecimal escape in host")
+ goto Error
}
- return url, nil;
+ return url, nil
Error:
- return nil, &URLError{"parse", rawurl, err};
+ return nil, &URLError{"parse", rawurl, err}
}
// ParseURLReference is like ParseURL but allows a trailing #fragment.
func ParseURLReference(rawurlref string) (url *URL, err os.Error) {
// Cut off #frag.
- rawurl, frag := split(rawurlref, '#', true);
+ rawurl, frag := split(rawurlref, '#', true)
if url, err = ParseURL(rawurl); err != nil {
return nil, err
}
if url.Fragment, err = URLUnescape(frag); err != nil {
return nil, &URLError{"parse", rawurl, err}
}
- return url, nil;
+ return url, nil
}
// String reassembles url into a valid URL string.
// the String method consults Scheme, Path, Host, Userinfo,
// RawQuery, and Fragment, but not Raw, RawPath or Authority.
func (url *URL) String() string {
- result := "";
+ result := ""
if url.Scheme != "" {
result += url.Scheme + ":"
}
if url.Host != "" || url.Userinfo != "" {
- result += "//";
+ result += "//"
if url.Userinfo != "" {
result += URLEscape(url.Userinfo) + "@"
}
- result += url.Host;
+ result += url.Host
}
- result += URLEscape(url.Path);
+ result += URLEscape(url.Path)
if url.RawQuery != "" {
result += "?" + url.RawQuery
}
if url.Fragment != "" {
result += "#" + URLEscape(url.Fragment)
}
- return result;
+ return result
}
package http
import (
- "fmt";
- "os";
- "reflect";
- "testing";
+ "fmt"
+ "os"
+ "reflect"
+ "testing"
)
// TODO(rsc):
// test ParseURL
type URLTest struct {
- in string;
- out *URL;
- roundtrip string; // expected result of reserializing the URL; empty means same as "in".
+ in string
+ out *URL
+ roundtrip string // expected result of reserializing the URL; empty means same as "in".
}
var urltests = []URLTest{
func DoTest(t *testing.T, parse func(string) (*URL, os.Error), name string, tests []URLTest) {
for _, tt := range tests {
- u, err := parse(tt.in);
+ u, err := parse(tt.in)
if err != nil {
- t.Errorf("%s(%q) returned error %s", name, tt.in, err);
- continue;
+ t.Errorf("%s(%q) returned error %s", name, tt.in, err)
+ continue
}
if !reflect.DeepEqual(u, tt.out) {
t.Errorf("%s(%q):\n\thave %v\n\twant %v\n",
}
func TestParseURL(t *testing.T) {
- DoTest(t, ParseURL, "ParseURL", urltests);
- DoTest(t, ParseURL, "ParseURL", urlnofragtests);
+ DoTest(t, ParseURL, "ParseURL", urltests)
+ DoTest(t, ParseURL, "ParseURL", urlnofragtests)
}
func TestParseURLReference(t *testing.T) {
- DoTest(t, ParseURLReference, "ParseURLReference", urltests);
- DoTest(t, ParseURLReference, "ParseURLReference", urlfragtests);
+ DoTest(t, ParseURLReference, "ParseURLReference", urltests)
+ DoTest(t, ParseURLReference, "ParseURLReference", urlfragtests)
}
func DoTestString(t *testing.T, parse func(string) (*URL, os.Error), name string, tests []URLTest) {
for _, tt := range tests {
- u, err := parse(tt.in);
+ u, err := parse(tt.in)
if err != nil {
- t.Errorf("%s(%q) returned error %s", name, tt.in, err);
- continue;
+ t.Errorf("%s(%q) returned error %s", name, tt.in, err)
+ continue
}
- s := u.String();
- expected := tt.in;
+ s := u.String()
+ expected := tt.in
if len(tt.roundtrip) > 0 {
expected = tt.roundtrip
}
}
func TestURLString(t *testing.T) {
- DoTestString(t, ParseURL, "ParseURL", urltests);
- DoTestString(t, ParseURL, "ParseURL", urlfragtests);
- DoTestString(t, ParseURL, "ParseURL", urlnofragtests);
- DoTestString(t, ParseURLReference, "ParseURLReference", urltests);
- DoTestString(t, ParseURLReference, "ParseURLReference", urlfragtests);
- DoTestString(t, ParseURLReference, "ParseURLReference", urlnofragtests);
+ DoTestString(t, ParseURL, "ParseURL", urltests)
+ DoTestString(t, ParseURL, "ParseURL", urlfragtests)
+ DoTestString(t, ParseURL, "ParseURL", urlnofragtests)
+ DoTestString(t, ParseURLReference, "ParseURLReference", urltests)
+ DoTestString(t, ParseURLReference, "ParseURLReference", urlfragtests)
+ DoTestString(t, ParseURLReference, "ParseURLReference", urlnofragtests)
}
type URLEscapeTest struct {
- in string;
- out string;
- err os.Error;
+ in string
+ out string
+ err os.Error
}
var unescapeTests = []URLEscapeTest{
nil,
},
URLEscapeTest{
- "%", // not enough characters after %
+ "%", // not enough characters after %
"",
URLEscapeError("%"),
},
URLEscapeTest{
- "%a", // not enough characters after %
+ "%a", // not enough characters after %
"",
URLEscapeError("%a"),
},
URLEscapeTest{
- "%1", // not enough characters after %
+ "%1", // not enough characters after %
"",
URLEscapeError("%1"),
},
URLEscapeTest{
- "123%45%6", // not enough characters after %
+ "123%45%6", // not enough characters after %
"",
URLEscapeError("%6"),
},
URLEscapeTest{
- "%zzzzz", // invalid hex digits
+ "%zzzzz", // invalid hex digits
"",
URLEscapeError("%zz"),
},
func TestURLUnescape(t *testing.T) {
for _, tt := range unescapeTests {
- actual, err := URLUnescape(tt.in);
+ actual, err := URLUnescape(tt.in)
if actual != tt.out || (err != nil) != (tt.err != nil) {
t.Errorf("URLUnescape(%q) = %q, %s; want %q, %s", tt.in, actual, err, tt.out, tt.err)
}
func TestURLEscape(t *testing.T) {
for _, tt := range escapeTests {
- actual := URLEscape(tt.in);
+ actual := URLEscape(tt.in)
if tt.out != actual {
t.Errorf("URLEscape(%q) = %q, want %q", tt.in, actual, tt.out)
}
// for bonus points, verify that escape:unescape is an identity.
- roundtrip, err := URLUnescape(actual);
+ roundtrip, err := URLUnescape(actual)
if roundtrip != tt.in || err != nil {
t.Errorf("URLUnescape(%q) = %q, %s; want %q, %s", actual, roundtrip, err, tt.in, "[no error]")
}
// All Colors can convert themselves, with a possible loss of precision, to 128-bit alpha-premultiplied RGBA.
type Color interface {
- RGBA() (r, g, b, a uint32);
+ RGBA() (r, g, b, a uint32)
}
// An RGBAColor represents a traditional 32-bit alpha-premultiplied color, having 8 bits for each of red, green, blue and alpha.
type RGBAColor struct {
- R, G, B, A uint8;
+ R, G, B, A uint8
}
func (c RGBAColor) RGBA() (r, g, b, a uint32) {
- r = uint32(c.R);
- r |= r << 8;
- r |= r << 16;
- g = uint32(c.G);
- g |= g << 8;
- g |= g << 16;
- b = uint32(c.B);
- b |= b << 8;
- b |= b << 16;
- a = uint32(c.A);
- a |= a << 8;
- a |= a << 16;
- return;
+ r = uint32(c.R)
+ r |= r << 8
+ r |= r << 16
+ g = uint32(c.G)
+ g |= g << 8
+ g |= g << 16
+ b = uint32(c.B)
+ b |= b << 8
+ b |= b << 16
+ a = uint32(c.A)
+ a |= a << 8
+ a |= a << 16
+ return
}
// An RGBA64Color represents a 64-bit alpha-premultiplied color, having 16 bits for each of red, green, blue and alpha.
type RGBA64Color struct {
- R, G, B, A uint16;
+ R, G, B, A uint16
}
func (c RGBA64Color) RGBA() (r, g, b, a uint32) {
- r = uint32(c.R);
- r |= r << 16;
- g = uint32(c.G);
- g |= g << 16;
- b = uint32(c.B);
- b |= b << 16;
- a = uint32(c.A);
- a |= a << 16;
- return;
+ r = uint32(c.R)
+ r |= r << 16
+ g = uint32(c.G)
+ g |= g << 16
+ b = uint32(c.B)
+ b |= b << 16
+ a = uint32(c.A)
+ a |= a << 16
+ return
}
// An NRGBAColor represents a non-alpha-premultiplied 32-bit color.
type NRGBAColor struct {
- R, G, B, A uint8;
+ R, G, B, A uint8
}
func (c NRGBAColor) RGBA() (r, g, b, a uint32) {
- r = uint32(c.R);
- r |= r << 8;
- r *= uint32(c.A);
- r /= 0xff;
- r |= r << 16;
- g = uint32(c.G);
- g |= g << 8;
- g *= uint32(c.A);
- g /= 0xff;
- g |= g << 16;
- b = uint32(c.B);
- b |= b << 8;
- b *= uint32(c.A);
- b /= 0xff;
- b |= b << 16;
- a = uint32(c.A);
- a |= a << 8;
- a |= a << 16;
- return;
+ r = uint32(c.R)
+ r |= r << 8
+ r *= uint32(c.A)
+ r /= 0xff
+ r |= r << 16
+ g = uint32(c.G)
+ g |= g << 8
+ g *= uint32(c.A)
+ g /= 0xff
+ g |= g << 16
+ b = uint32(c.B)
+ b |= b << 8
+ b *= uint32(c.A)
+ b /= 0xff
+ b |= b << 16
+ a = uint32(c.A)
+ a |= a << 8
+ a |= a << 16
+ return
}
// An NRGBA64Color represents a non-alpha-premultiplied 64-bit color, having 16 bits for each of red, green, blue and alpha.
type NRGBA64Color struct {
- R, G, B, A uint16;
+ R, G, B, A uint16
}
func (c NRGBA64Color) RGBA() (r, g, b, a uint32) {
- r = uint32(c.R);
- r *= uint32(c.A);
- r /= 0xffff;
- r |= r << 16;
- g = uint32(c.G);
- g *= uint32(c.A);
- g /= 0xffff;
- g |= g << 16;
- b = uint32(c.B);
- b *= uint32(c.A);
- b /= 0xffff;
- b |= b << 16;
- a = uint32(c.A);
- a |= a << 8;
- a |= a << 16;
- return;
+ r = uint32(c.R)
+ r *= uint32(c.A)
+ r /= 0xffff
+ r |= r << 16
+ g = uint32(c.G)
+ g *= uint32(c.A)
+ g /= 0xffff
+ g |= g << 16
+ b = uint32(c.B)
+ b *= uint32(c.A)
+ b /= 0xffff
+ b |= b << 16
+ a = uint32(c.A)
+ a |= a << 8
+ a |= a << 16
+ return
}
// A ColorModel can convert foreign Colors, with a possible loss of precision, to a Color
// from its own color model.
type ColorModel interface {
- Convert(c Color) Color;
+ Convert(c Color) Color
}
// The ColorModelFunc type is an adapter to allow the use of an ordinary
}
func toRGBAColor(c Color) Color {
- if _, ok := c.(RGBAColor); ok { // no-op conversion
+ if _, ok := c.(RGBAColor); ok { // no-op conversion
return c
}
- r, g, b, a := c.RGBA();
- return RGBAColor{uint8(r >> 24), uint8(g >> 24), uint8(b >> 24), uint8(a >> 24)};
+ r, g, b, a := c.RGBA()
+ return RGBAColor{uint8(r >> 24), uint8(g >> 24), uint8(b >> 24), uint8(a >> 24)}
}
func toRGBA64Color(c Color) Color {
- if _, ok := c.(RGBA64Color); ok { // no-op conversion
+ if _, ok := c.(RGBA64Color); ok { // no-op conversion
return c
}
- r, g, b, a := c.RGBA();
- return RGBA64Color{uint16(r >> 16), uint16(g >> 16), uint16(b >> 16), uint16(a >> 16)};
+ r, g, b, a := c.RGBA()
+ return RGBA64Color{uint16(r >> 16), uint16(g >> 16), uint16(b >> 16), uint16(a >> 16)}
}
func toNRGBAColor(c Color) Color {
- if _, ok := c.(NRGBAColor); ok { // no-op conversion
+ if _, ok := c.(NRGBAColor); ok { // no-op conversion
return c
}
- r, g, b, a := c.RGBA();
- a >>= 16;
+ r, g, b, a := c.RGBA()
+ a >>= 16
if a == 0xffff {
return NRGBAColor{uint8(r >> 24), uint8(g >> 24), uint8(b >> 24), 0xff}
}
if a == 0 {
return NRGBAColor{0, 0, 0, 0}
}
- r >>= 16;
- g >>= 16;
- b >>= 16;
+ r >>= 16
+ g >>= 16
+ b >>= 16
// Since Color.RGBA returns a alpha-premultiplied color, we should have r <= a && g <= a && b <= a.
- r = (r * 0xffff) / a;
- g = (g * 0xffff) / a;
- b = (b * 0xffff) / a;
- return NRGBAColor{uint8(r >> 8), uint8(g >> 8), uint8(b >> 8), uint8(a >> 8)};
+ r = (r * 0xffff) / a
+ g = (g * 0xffff) / a
+ b = (b * 0xffff) / a
+ return NRGBAColor{uint8(r >> 8), uint8(g >> 8), uint8(b >> 8), uint8(a >> 8)}
}
func toNRGBA64Color(c Color) Color {
- if _, ok := c.(NRGBA64Color); ok { // no-op conversion
+ if _, ok := c.(NRGBA64Color); ok { // no-op conversion
return c
}
- r, g, b, a := c.RGBA();
- a >>= 16;
- r >>= 16;
- g >>= 16;
- b >>= 16;
+ r, g, b, a := c.RGBA()
+ a >>= 16
+ r >>= 16
+ g >>= 16
+ b >>= 16
if a == 0xffff {
return NRGBA64Color{uint16(r), uint16(g), uint16(b), 0xffff}
}
return NRGBA64Color{0, 0, 0, 0}
}
// Since Color.RGBA returns a alpha-premultiplied color, we should have r <= a && g <= a && b <= a.
- r = (r * 0xffff) / a;
- g = (g * 0xffff) / a;
- b = (b * 0xffff) / a;
- return NRGBA64Color{uint16(r), uint16(g), uint16(b), uint16(a)};
+ r = (r * 0xffff) / a
+ g = (g * 0xffff) / a
+ b = (b * 0xffff) / a
+ return NRGBA64Color{uint16(r), uint16(g), uint16(b), uint16(a)}
}
// The ColorModel associated with RGBAColor.
// An Image is a rectangular grid of Colors drawn from a ColorModel.
type Image interface {
- ColorModel() ColorModel;
- Width() int;
- Height() int;
+ ColorModel() ColorModel
+ Width() int
+ Height() int
// At(0, 0) returns the upper-left pixel of the grid.
// At(Width()-1, Height()-1) returns the lower-right pixel.
- At(x, y int) Color;
+ At(x, y int) Color
}
// An RGBA is an in-memory image backed by a 2-D slice of RGBAColor values.
type RGBA struct {
// The Pixel field's indices are y first, then x, so that At(x, y) == Pixel[y][x].
- Pixel [][]RGBAColor;
+ Pixel [][]RGBAColor
}
-func (p *RGBA) ColorModel() ColorModel { return RGBAColorModel }
+func (p *RGBA) ColorModel() ColorModel { return RGBAColorModel }
func (p *RGBA) Width() int {
if len(p.Pixel) == 0 {
return 0
}
- return len(p.Pixel[0]);
+ return len(p.Pixel[0])
}
-func (p *RGBA) Height() int { return len(p.Pixel) }
+func (p *RGBA) Height() int { return len(p.Pixel) }
-func (p *RGBA) At(x, y int) Color { return p.Pixel[y][x] }
+func (p *RGBA) At(x, y int) Color { return p.Pixel[y][x] }
-func (p *RGBA) Set(x, y int, c Color) { p.Pixel[y][x] = toRGBAColor(c).(RGBAColor) }
+func (p *RGBA) Set(x, y int, c Color) { p.Pixel[y][x] = toRGBAColor(c).(RGBAColor) }
// NewRGBA returns a new RGBA with the given width and height.
func NewRGBA(w, h int) *RGBA {
- pixel := make([][]RGBAColor, h);
+ pixel := make([][]RGBAColor, h)
for y := 0; y < h; y++ {
pixel[y] = make([]RGBAColor, w)
}
- return &RGBA{pixel};
+ return &RGBA{pixel}
}
// An RGBA64 is an in-memory image backed by a 2-D slice of RGBA64Color values.
type RGBA64 struct {
// The Pixel field's indices are y first, then x, so that At(x, y) == Pixel[y][x].
- Pixel [][]RGBA64Color;
+ Pixel [][]RGBA64Color
}
-func (p *RGBA64) ColorModel() ColorModel { return RGBA64ColorModel }
+func (p *RGBA64) ColorModel() ColorModel { return RGBA64ColorModel }
func (p *RGBA64) Width() int {
if len(p.Pixel) == 0 {
return 0
}
- return len(p.Pixel[0]);
+ return len(p.Pixel[0])
}
-func (p *RGBA64) Height() int { return len(p.Pixel) }
+func (p *RGBA64) Height() int { return len(p.Pixel) }
-func (p *RGBA64) At(x, y int) Color { return p.Pixel[y][x] }
+func (p *RGBA64) At(x, y int) Color { return p.Pixel[y][x] }
-func (p *RGBA64) Set(x, y int, c Color) { p.Pixel[y][x] = toRGBA64Color(c).(RGBA64Color) }
+func (p *RGBA64) Set(x, y int, c Color) { p.Pixel[y][x] = toRGBA64Color(c).(RGBA64Color) }
// NewRGBA64 returns a new RGBA64 with the given width and height.
func NewRGBA64(w, h int) *RGBA64 {
- pixel := make([][]RGBA64Color, h);
+ pixel := make([][]RGBA64Color, h)
for y := 0; y < h; y++ {
pixel[y] = make([]RGBA64Color, w)
}
- return &RGBA64{pixel};
+ return &RGBA64{pixel}
}
// A NRGBA is an in-memory image backed by a 2-D slice of NRGBAColor values.
type NRGBA struct {
// The Pixel field's indices are y first, then x, so that At(x, y) == Pixel[y][x].
- Pixel [][]NRGBAColor;
+ Pixel [][]NRGBAColor
}
-func (p *NRGBA) ColorModel() ColorModel { return NRGBAColorModel }
+func (p *NRGBA) ColorModel() ColorModel { return NRGBAColorModel }
func (p *NRGBA) Width() int {
if len(p.Pixel) == 0 {
return 0
}
- return len(p.Pixel[0]);
+ return len(p.Pixel[0])
}
-func (p *NRGBA) Height() int { return len(p.Pixel) }
+func (p *NRGBA) Height() int { return len(p.Pixel) }
-func (p *NRGBA) At(x, y int) Color { return p.Pixel[y][x] }
+func (p *NRGBA) At(x, y int) Color { return p.Pixel[y][x] }
-func (p *NRGBA) Set(x, y int, c Color) { p.Pixel[y][x] = toNRGBAColor(c).(NRGBAColor) }
+func (p *NRGBA) Set(x, y int, c Color) { p.Pixel[y][x] = toNRGBAColor(c).(NRGBAColor) }
// NewNRGBA returns a new NRGBA with the given width and height.
func NewNRGBA(w, h int) *NRGBA {
- pixel := make([][]NRGBAColor, h);
+ pixel := make([][]NRGBAColor, h)
for y := 0; y < h; y++ {
pixel[y] = make([]NRGBAColor, w)
}
- return &NRGBA{pixel};
+ return &NRGBA{pixel}
}
// A NRGBA64 is an in-memory image backed by a 2-D slice of NRGBA64Color values.
type NRGBA64 struct {
// The Pixel field's indices are y first, then x, so that At(x, y) == Pixel[y][x].
- Pixel [][]NRGBA64Color;
+ Pixel [][]NRGBA64Color
}
-func (p *NRGBA64) ColorModel() ColorModel { return NRGBA64ColorModel }
+func (p *NRGBA64) ColorModel() ColorModel { return NRGBA64ColorModel }
func (p *NRGBA64) Width() int {
if len(p.Pixel) == 0 {
return 0
}
- return len(p.Pixel[0]);
+ return len(p.Pixel[0])
}
-func (p *NRGBA64) Height() int { return len(p.Pixel) }
+func (p *NRGBA64) Height() int { return len(p.Pixel) }
-func (p *NRGBA64) At(x, y int) Color { return p.Pixel[y][x] }
+func (p *NRGBA64) At(x, y int) Color { return p.Pixel[y][x] }
-func (p *NRGBA64) Set(x, y int, c Color) { p.Pixel[y][x] = toNRGBA64Color(c).(NRGBA64Color) }
+func (p *NRGBA64) Set(x, y int, c Color) { p.Pixel[y][x] = toNRGBA64Color(c).(NRGBA64Color) }
// NewNRGBA64 returns a new NRGBA64 with the given width and height.
func NewNRGBA64(w, h int) *NRGBA64 {
- pixel := make([][]NRGBA64Color, h);
+ pixel := make([][]NRGBA64Color, h)
for y := 0; y < h; y++ {
pixel[y] = make([]NRGBA64Color, w)
}
- return &NRGBA64{pixel};
+ return &NRGBA64{pixel}
}
// A PalettedColorModel represents a fixed palette of colors.
if a > b {
return a - b
}
- return b - a;
+ return b - a
}
// Convert returns the palette color closest to c in Euclidean R,G,B space.
// TODO(nigeltao): Revisit the "pick the palette color which minimizes sum-squared-difference"
// algorithm when the premultiplied vs unpremultiplied issue is resolved.
// Currently, we only compare the R, G and B values, and ignore A.
- cr, cg, cb, _ := c.RGBA();
+ cr, cg, cb, _ := c.RGBA()
// Shift by 17 bits to avoid potential uint32 overflow in sum-squared-difference.
- cr >>= 17;
- cg >>= 17;
- cb >>= 17;
- result := Color(nil);
- bestSSD := uint32(1<<32 - 1);
+ cr >>= 17
+ cg >>= 17
+ cb >>= 17
+ result := Color(nil)
+ bestSSD := uint32(1<<32 - 1)
for _, v := range p {
- vr, vg, vb, _ := v.RGBA();
- vr >>= 17;
- vg >>= 17;
- vb >>= 17;
- dr, dg, db := diff(cr, vr), diff(cg, vg), diff(cb, vb);
- ssd := (dr * dr) + (dg * dg) + (db * db);
+ vr, vg, vb, _ := v.RGBA()
+ vr >>= 17
+ vg >>= 17
+ vb >>= 17
+ dr, dg, db := diff(cr, vr), diff(cg, vg), diff(cb, vb)
+ ssd := (dr * dr) + (dg * dg) + (db * db)
if ssd < bestSSD {
- bestSSD = ssd;
- result = v;
+ bestSSD = ssd
+ result = v
}
}
- return result;
+ return result
}
// A Paletted is an in-memory image backed by a 2-D slice of uint8 values and a PalettedColorModel.
type Paletted struct {
// The Pixel field's indices are y first, then x, so that At(x, y) == Palette[Pixel[y][x]].
- Pixel [][]uint8;
- Palette PalettedColorModel;
+ Pixel [][]uint8
+ Palette PalettedColorModel
}
-func (p *Paletted) ColorModel() ColorModel { return p.Palette }
+func (p *Paletted) ColorModel() ColorModel { return p.Palette }
func (p *Paletted) Width() int {
if len(p.Pixel) == 0 {
return 0
}
- return len(p.Pixel[0]);
+ return len(p.Pixel[0])
}
-func (p *Paletted) Height() int { return len(p.Pixel) }
+func (p *Paletted) Height() int { return len(p.Pixel) }
-func (p *Paletted) At(x, y int) Color { return p.Palette[p.Pixel[y][x]] }
+func (p *Paletted) At(x, y int) Color { return p.Palette[p.Pixel[y][x]] }
func (p *Paletted) ColorIndexAt(x, y int) uint8 {
return p.Pixel[y][x]
// NewPaletted returns a new Paletted with the given width, height and palette.
func NewPaletted(w, h int, m PalettedColorModel) *Paletted {
- pixel := make([][]uint8, h);
+ pixel := make([][]uint8, h)
for y := 0; y < h; y++ {
pixel[y] = make([]uint8, w)
}
- return &Paletted{pixel, m};
+ return &Paletted{pixel, m}
}
package png
import (
- "compress/zlib";
- "hash";
- "hash/crc32";
- "image";
- "io";
- "os";
+ "compress/zlib"
+ "hash"
+ "hash/crc32"
+ "image"
+ "io"
+ "os"
)
// Color type, as per the PNG spec.
const (
- ctGrayscale = 0;
- ctTrueColor = 2;
- ctPaletted = 3;
- ctGrayscaleAlpha = 4;
- ctTrueColorAlpha = 6;
+ ctGrayscale = 0
+ ctTrueColor = 2
+ ctPaletted = 3
+ ctGrayscaleAlpha = 4
+ ctTrueColorAlpha = 6
)
// Filter type, as per the PNG spec.
const (
- ftNone = 0;
- ftSub = 1;
- ftUp = 2;
- ftAverage = 3;
- ftPaeth = 4;
- nFilter = 5;
+ ftNone = 0
+ ftSub = 1
+ ftUp = 2
+ ftAverage = 3
+ ftPaeth = 4
+ nFilter = 5
)
// Decoding stage.
// IDAT chunks must be sequential (i.e. they may not have any other chunks
// between them).
const (
- dsStart = iota;
- dsSeenIHDR;
- dsSeenPLTE;
- dsSeenIDAT;
- dsSeenIEND;
+ dsStart = iota
+ dsSeenIHDR
+ dsSeenPLTE
+ dsSeenIDAT
+ dsSeenIEND
)
const pngHeader = "\x89PNG\r\n\x1a\n"
type decoder struct {
- width, height int;
- image image.Image;
- colorType uint8;
- stage int;
- idatWriter io.WriteCloser;
- idatDone chan os.Error;
- tmp [3 * 256]byte;
+ width, height int
+ image image.Image
+ colorType uint8
+ stage int
+ idatWriter io.WriteCloser
+ idatDone chan os.Error
+ tmp [3 * 256]byte
}
// A FormatError reports that the input is not a valid PNG.
type FormatError string
-func (e FormatError) String() string { return "invalid PNG format: " + string(e) }
+func (e FormatError) String() string { return "invalid PNG format: " + string(e) }
var chunkOrderError = FormatError("chunk out of order")
// An IDATDecodingError wraps an inner error (such as a ZLIB decoding error) encountered while processing an IDAT chunk.
type IDATDecodingError struct {
- Err os.Error;
+ Err os.Error
}
-func (e IDATDecodingError) String() string { return "IDAT decoding error: " + e.Err.String() }
+func (e IDATDecodingError) String() string { return "IDAT decoding error: " + e.Err.String() }
// An UnsupportedError reports that the input uses a valid but unimplemented PNG feature.
type UnsupportedError string
-func (e UnsupportedError) String() string { return "unsupported PNG feature: " + string(e) }
+func (e UnsupportedError) String() string { return "unsupported PNG feature: " + string(e) }
// Big-endian.
func parseUint32(b []uint8) uint32 {
if x < 0 {
return -x
}
- return x;
+ return x
}
func min(a, b int) int {
if a < b {
return a
}
- return b;
+ return b
}
func (d *decoder) parseIHDR(r io.Reader, crc hash.Hash32, length uint32) os.Error {
if length != 13 {
return FormatError("bad IHDR length")
}
- _, err := io.ReadFull(r, d.tmp[0:13]);
+ _, err := io.ReadFull(r, d.tmp[0:13])
if err != nil {
return err
}
- crc.Write(d.tmp[0:13]);
+ crc.Write(d.tmp[0:13])
if d.tmp[8] != 8 {
return UnsupportedError("bit depth")
}
if d.tmp[10] != 0 || d.tmp[11] != 0 || d.tmp[12] != 0 {
return UnsupportedError("compression, filter or interlace method")
}
- w := int32(parseUint32(d.tmp[0:4]));
- h := int32(parseUint32(d.tmp[4:8]));
+ w := int32(parseUint32(d.tmp[0:4]))
+ h := int32(parseUint32(d.tmp[4:8]))
if w < 0 || h < 0 {
return FormatError("negative dimension")
}
- nPixels := int64(w) * int64(h);
+ nPixels := int64(w) * int64(h)
if nPixels != int64(int(nPixels)) {
return UnsupportedError("dimension overflow")
}
- d.colorType = d.tmp[9];
+ d.colorType = d.tmp[9]
switch d.colorType {
case ctTrueColor:
d.image = image.NewRGBA(int(w), int(h))
default:
return UnsupportedError("color type")
}
- d.width, d.height = int(w), int(h);
- return nil;
+ d.width, d.height = int(w), int(h)
+ return nil
}
func (d *decoder) parsePLTE(r io.Reader, crc hash.Hash32, length uint32) os.Error {
- np := int(length / 3); // The number of palette entries.
+ np := int(length / 3) // The number of palette entries.
if length%3 != 0 || np <= 0 || np > 256 {
return FormatError("bad PLTE length")
}
- n, err := io.ReadFull(r, d.tmp[0:3*np]);
+ n, err := io.ReadFull(r, d.tmp[0:3*np])
if err != nil {
return err
}
- crc.Write(d.tmp[0:n]);
+ crc.Write(d.tmp[0:n])
switch d.colorType {
case ctPaletted:
- palette := make([]image.Color, np);
+ palette := make([]image.Color, np)
for i := 0; i < np; i++ {
palette[i] = image.RGBAColor{d.tmp[3*i+0], d.tmp[3*i+1], d.tmp[3*i+2], 0xff}
}
- d.image.(*image.Paletted).Palette = image.PalettedColorModel(palette);
+ d.image.(*image.Paletted).Palette = image.PalettedColorModel(palette)
case ctTrueColor, ctTrueColorAlpha:
// As per the PNG spec, a PLTE chunk is optional (and for practical purposes,
// ignorable) for the ctTrueColor and ctTrueColorAlpha color types (section 4.1.2).
default:
return FormatError("PLTE, color type mismatch")
}
- return nil;
+ return nil
}
// The Paeth filter function, as per the PNG specification.
func paeth(a, b, c uint8) uint8 {
- p := int(a) + int(b) - int(c);
- pa := abs(p - int(a));
- pb := abs(p - int(b));
- pc := abs(p - int(c));
+ p := int(a) + int(b) - int(c)
+ pa := abs(p - int(a))
+ pb := abs(p - int(b))
+ pc := abs(p - int(c))
if pa <= pb && pa <= pc {
return a
} else if pb <= pc {
return b
}
- return c;
+ return c
}
func (d *decoder) idatReader(idat io.Reader) os.Error {
- r, err := zlib.NewInflater(idat);
+ r, err := zlib.NewInflater(idat)
if err != nil {
return err
}
- defer r.Close();
- bpp := 0; // Bytes per pixel.
- maxPalette := uint8(0);
+ defer r.Close()
+ bpp := 0 // Bytes per pixel.
+ maxPalette := uint8(0)
var (
- rgba *image.RGBA;
- nrgba *image.NRGBA;
- paletted *image.Paletted;
+ rgba *image.RGBA
+ nrgba *image.NRGBA
+ paletted *image.Paletted
)
switch d.colorType {
case ctTrueColor:
- bpp = 3;
- rgba = d.image.(*image.RGBA);
+ bpp = 3
+ rgba = d.image.(*image.RGBA)
case ctPaletted:
- bpp = 1;
- paletted = d.image.(*image.Paletted);
- maxPalette = uint8(len(paletted.Palette) - 1);
+ bpp = 1
+ paletted = d.image.(*image.Paletted)
+ maxPalette = uint8(len(paletted.Palette) - 1)
case ctTrueColorAlpha:
- bpp = 4;
- nrgba = d.image.(*image.NRGBA);
+ bpp = 4
+ nrgba = d.image.(*image.NRGBA)
}
// cr and pr are the bytes for the current and previous row.
// The +1 is for the per-row filter type, which is at cr[0].
- cr := make([]uint8, 1+bpp*d.width);
- pr := make([]uint8, 1+bpp*d.width);
+ cr := make([]uint8, 1+bpp*d.width)
+ pr := make([]uint8, 1+bpp*d.width)
for y := 0; y < d.height; y++ {
// Read the decompressed bytes.
- _, err := io.ReadFull(r, cr);
+ _, err := io.ReadFull(r, cr)
if err != nil {
return err
}
// Apply the filter.
- cdat := cr[1:];
- pdat := pr[1:];
+ cdat := cr[1:]
+ pdat := pr[1:]
switch cr[0] {
case ftNone:
// No-op.
if cdat[x] > maxPalette {
return FormatError("palette index out of range")
}
- paletted.SetColorIndex(x, y, cdat[x]);
+ paletted.SetColorIndex(x, y, cdat[x])
}
case ctTrueColorAlpha:
for x := 0; x < d.width; x++ {
}
// The current row for y is the previous row for y+1.
- pr, cr = cr, pr;
+ pr, cr = cr, pr
}
- return nil;
+ return nil
}
func (d *decoder) parseIDAT(r io.Reader, crc hash.Hash32, length uint32) os.Error {
// we see them, and decode the stream in a separate go-routine, which
// signals its completion (successful or not) via a channel.
if d.idatWriter == nil {
- pr, pw := io.Pipe();
- d.idatWriter = pw;
- d.idatDone = make(chan os.Error);
+ pr, pw := io.Pipe()
+ d.idatWriter = pw
+ d.idatDone = make(chan os.Error)
go func() {
- err := d.idatReader(pr);
+ err := d.idatReader(pr)
if err == os.EOF {
err = FormatError("too little IDAT")
}
- pr.CloseWithError(FormatError("too much IDAT"));
- d.idatDone <- err;
- }();
+ pr.CloseWithError(FormatError("too much IDAT"))
+ d.idatDone <- err
+ }()
}
- var buf [4096]byte;
+ var buf [4096]byte
for length > 0 {
- n, err1 := r.Read(buf[0:min(len(buf), int(length))]);
+ n, err1 := r.Read(buf[0:min(len(buf), int(length))])
// We delay checking err1. It is possible to get n bytes and an error,
// but if the n bytes themselves contain a FormatError, for example, we
// want to report that error, and not the one that made the Read stop.
- n, err2 := d.idatWriter.Write(buf[0:n]);
+ n, err2 := d.idatWriter.Write(buf[0:n])
if err2 != nil {
return err2
}
if err1 != nil {
return err1
}
- crc.Write(buf[0:n]);
- length -= uint32(n);
+ crc.Write(buf[0:n])
+ length -= uint32(n)
}
- return nil;
+ return nil
}
func (d *decoder) parseIEND(r io.Reader, crc hash.Hash32, length uint32) os.Error {
if length != 0 {
return FormatError("bad IEND length")
}
- return nil;
+ return nil
}
func (d *decoder) parseChunk(r io.Reader) os.Error {
// Read the length.
- n, err := io.ReadFull(r, d.tmp[0:4]);
+ n, err := io.ReadFull(r, d.tmp[0:4])
if err == os.EOF {
return io.ErrUnexpectedEOF
}
if err != nil {
return err
}
- length := parseUint32(d.tmp[0:4]);
+ length := parseUint32(d.tmp[0:4])
// Read the chunk type.
- n, err = io.ReadFull(r, d.tmp[0:4]);
+ n, err = io.ReadFull(r, d.tmp[0:4])
if err == os.EOF {
return io.ErrUnexpectedEOF
}
if err != nil {
return err
}
- crc := crc32.NewIEEE();
- crc.Write(d.tmp[0:4]);
+ crc := crc32.NewIEEE()
+ crc.Write(d.tmp[0:4])
// Read the chunk data.
switch string(d.tmp[0:4]) {
if d.stage != dsStart {
return chunkOrderError
}
- d.stage = dsSeenIHDR;
- err = d.parseIHDR(r, crc, length);
+ d.stage = dsSeenIHDR
+ err = d.parseIHDR(r, crc, length)
case "PLTE":
if d.stage != dsSeenIHDR {
return chunkOrderError
}
- d.stage = dsSeenPLTE;
- err = d.parsePLTE(r, crc, length);
+ d.stage = dsSeenPLTE
+ err = d.parsePLTE(r, crc, length)
case "IDAT":
if d.stage < dsSeenIHDR || d.stage > dsSeenIDAT || (d.colorType == ctPaletted && d.stage == dsSeenIHDR) {
return chunkOrderError
}
- d.stage = dsSeenIDAT;
- err = d.parseIDAT(r, crc, length);
+ d.stage = dsSeenIDAT
+ err = d.parseIDAT(r, crc, length)
case "IEND":
if d.stage != dsSeenIDAT {
return chunkOrderError
}
- d.stage = dsSeenIEND;
- err = d.parseIEND(r, crc, length);
+ d.stage = dsSeenIEND
+ err = d.parseIEND(r, crc, length)
default:
// Ignore this chunk (of a known length).
- var ignored [4096]byte;
+ var ignored [4096]byte
for length > 0 {
- n, err = io.ReadFull(r, ignored[0:min(len(ignored), int(length))]);
+ n, err = io.ReadFull(r, ignored[0:min(len(ignored), int(length))])
if err != nil {
return err
}
- crc.Write(ignored[0:n]);
- length -= uint32(n);
+ crc.Write(ignored[0:n])
+ length -= uint32(n)
}
}
if err != nil {
}
// Read the checksum.
- n, err = io.ReadFull(r, d.tmp[0:4]);
+ n, err = io.ReadFull(r, d.tmp[0:4])
if err == os.EOF {
return io.ErrUnexpectedEOF
}
if parseUint32(d.tmp[0:4]) != crc.Sum32() {
return FormatError("invalid checksum")
}
- return nil;
+ return nil
}
func (d *decoder) checkHeader(r io.Reader) os.Error {
- _, err := io.ReadFull(r, d.tmp[0:8]);
+ _, err := io.ReadFull(r, d.tmp[0:8])
if err != nil {
return err
}
if string(d.tmp[0:8]) != pngHeader {
return FormatError("not a PNG file")
}
- return nil;
+ return nil
}
// Decode reads a PNG formatted image from r and returns it as an image.Image.
// The type of Image returned depends on the PNG contents.
func Decode(r io.Reader) (image.Image, os.Error) {
- var d decoder;
- err := d.checkHeader(r);
+ var d decoder
+ err := d.checkHeader(r)
if err != nil {
return nil, err
}
for d.stage = dsStart; d.stage != dsSeenIEND; {
- err = d.parseChunk(r);
+ err = d.parseChunk(r)
if err != nil {
break
}
}
if d.idatWriter != nil {
- d.idatWriter.Close();
- err1 := <-d.idatDone;
+ d.idatWriter.Close()
+ err1 := <-d.idatDone
if err == nil {
err = err1
}
if err != nil {
return nil, err
}
- return d.image, nil;
+ return d.image, nil
}
package png
import (
- "bufio";
- "fmt";
- "image";
- "io";
- "os";
- "testing";
+ "bufio"
+ "fmt"
+ "image"
+ "io"
+ "os"
+ "testing"
)
// The go PNG library currently supports only a subset of the full PNG specification.
}
func readPng(filename string) (image.Image, os.Error) {
- f, err := os.Open(filename, os.O_RDONLY, 0444);
+ f, err := os.Open(filename, os.O_RDONLY, 0444)
if err != nil {
return nil, err
}
- defer f.Close();
- return Decode(f);
+ defer f.Close()
+ return Decode(f)
}
// An approximation of the sng command-line tool.
func sng(w io.WriteCloser, filename string, png image.Image) {
- defer w.Close();
+ defer w.Close()
// For now, the go PNG parser only reads bitdepths of 8.
- bitdepth := 8;
+ bitdepth := 8
// Write the filename and IHDR.
- io.WriteString(w, "#SNG: from "+filename+".png\nIHDR {\n");
- fmt.Fprintf(w, " width: %d; height: %d; bitdepth: %d;\n", png.Width(), png.Height(), bitdepth);
- cm := png.ColorModel();
- var paletted *image.Paletted;
- cpm, _ := cm.(image.PalettedColorModel);
+ io.WriteString(w, "#SNG: from "+filename+".png\nIHDR {\n")
+ fmt.Fprintf(w, " width: %d; height: %d; bitdepth: %d;\n", png.Width(), png.Height(), bitdepth)
+ cm := png.ColorModel()
+ var paletted *image.Paletted
+ cpm, _ := cm.(image.PalettedColorModel)
switch {
case cm == image.RGBAColorModel:
io.WriteString(w, " using color;\n")
case cm == image.NRGBAColorModel:
io.WriteString(w, " using color alpha;\n")
case cpm != nil:
- io.WriteString(w, " using color palette;\n");
- paletted = png.(*image.Paletted);
+ io.WriteString(w, " using color palette;\n")
+ paletted = png.(*image.Paletted)
default:
io.WriteString(w, "unknown PNG decoder color model\n")
}
- io.WriteString(w, "}\n");
+ io.WriteString(w, "}\n")
// We fake a gAMA output. The test files have a gAMA chunk but the go PNG parser ignores it
// (the PNG spec section 11.3 says "Ancillary chunks may be ignored by a decoder").
- io.WriteString(w, "gAMA {1.0000}\n");
+ io.WriteString(w, "gAMA {1.0000}\n")
// Write the PLTE (if applicable).
if cpm != nil {
- io.WriteString(w, "PLTE {\n");
+ io.WriteString(w, "PLTE {\n")
for i := 0; i < len(cpm); i++ {
- r, g, b, _ := cpm[i].RGBA();
- r >>= 24;
- g >>= 24;
- b >>= 24;
- fmt.Fprintf(w, " (%3d,%3d,%3d) # rgb = (0x%02x,0x%02x,0x%02x)\n", r, g, b, r, g, b);
+ r, g, b, _ := cpm[i].RGBA()
+ r >>= 24
+ g >>= 24
+ b >>= 24
+ fmt.Fprintf(w, " (%3d,%3d,%3d) # rgb = (0x%02x,0x%02x,0x%02x)\n", r, g, b, r, g, b)
}
- io.WriteString(w, "}\n");
+ io.WriteString(w, "}\n")
}
// Write the IMAGE.
- io.WriteString(w, "IMAGE {\n pixels hex\n");
+ io.WriteString(w, "IMAGE {\n pixels hex\n")
for y := 0; y < png.Height(); y++ {
switch {
case cm == image.RGBAColorModel:
for x := 0; x < png.Width(); x++ {
- rgba := png.At(x, y).(image.RGBAColor);
- fmt.Fprintf(w, "%02x%02x%02x ", rgba.R, rgba.G, rgba.B);
+ rgba := png.At(x, y).(image.RGBAColor)
+ fmt.Fprintf(w, "%02x%02x%02x ", rgba.R, rgba.G, rgba.B)
}
case cm == image.NRGBAColorModel:
for x := 0; x < png.Width(); x++ {
- nrgba := png.At(x, y).(image.NRGBAColor);
- fmt.Fprintf(w, "%02x%02x%02x%02x ", nrgba.R, nrgba.G, nrgba.B, nrgba.A);
+ nrgba := png.At(x, y).(image.NRGBAColor)
+ fmt.Fprintf(w, "%02x%02x%02x%02x ", nrgba.R, nrgba.G, nrgba.B, nrgba.A)
}
case cpm != nil:
for x := 0; x < png.Width(); x++ {
fmt.Fprintf(w, "%02x", paletted.ColorIndexAt(x, y))
}
}
- io.WriteString(w, "\n");
+ io.WriteString(w, "\n")
}
- io.WriteString(w, "}\n");
+ io.WriteString(w, "}\n")
}
func TestReader(t *testing.T) {
for _, fn := range filenames {
// Read the .png file.
- image, err := readPng("testdata/pngsuite/" + fn + ".png");
+ image, err := readPng("testdata/pngsuite/" + fn + ".png")
if err != nil {
- t.Error(fn, err);
- continue;
+ t.Error(fn, err)
+ continue
}
- piper, pipew := io.Pipe();
- pb := bufio.NewReader(piper);
- go sng(pipew, fn, image);
- defer piper.Close();
+ piper, pipew := io.Pipe()
+ pb := bufio.NewReader(piper)
+ go sng(pipew, fn, image)
+ defer piper.Close()
// Read the .sng file.
- sf, err := os.Open("testdata/pngsuite/"+fn+".sng", os.O_RDONLY, 0444);
+ sf, err := os.Open("testdata/pngsuite/"+fn+".sng", os.O_RDONLY, 0444)
if err != nil {
- t.Error(fn, err);
- continue;
+ t.Error(fn, err)
+ continue
}
- defer sf.Close();
- sb := bufio.NewReader(sf);
+ defer sf.Close()
+ sb := bufio.NewReader(sf)
if err != nil {
- t.Error(fn, err);
- continue;
+ t.Error(fn, err)
+ continue
}
// Compare the two, in SNG format, line by line.
for {
- ps, perr := pb.ReadString('\n');
- ss, serr := sb.ReadString('\n');
+ ps, perr := pb.ReadString('\n')
+ ss, serr := sb.ReadString('\n')
if perr == os.EOF && serr == os.EOF {
break
}
if perr != nil {
- t.Error(fn, perr);
- break;
+ t.Error(fn, perr)
+ break
}
if serr != nil {
- t.Error(fn, serr);
- break;
+ t.Error(fn, serr)
+ break
}
if ps != ss {
- t.Errorf("%s: Mismatch\n%sversus\n%s\n", fn, ps, ss);
- break;
+ t.Errorf("%s: Mismatch\n%sversus\n%s\n", fn, ps, ss)
+ break
}
}
}
package png
import (
- "bufio";
- "compress/zlib";
- "hash/crc32";
- "image";
- "io";
- "os";
- "strconv";
+ "bufio"
+ "compress/zlib"
+ "hash/crc32"
+ "image"
+ "io"
+ "os"
+ "strconv"
)
type encoder struct {
- w io.Writer;
- m image.Image;
- colorType uint8;
- err os.Error;
- header [8]byte;
- footer [4]byte;
- tmp [3 * 256]byte;
+ w io.Writer
+ m image.Image
+ colorType uint8
+ err os.Error
+ header [8]byte
+ footer [4]byte
+ tmp [3 * 256]byte
}
// Big-endian.
func writeUint32(b []uint8, u uint32) {
- b[0] = uint8(u >> 24);
- b[1] = uint8(u >> 16);
- b[2] = uint8(u >> 8);
- b[3] = uint8(u >> 0);
+ b[0] = uint8(u >> 24)
+ b[1] = uint8(u >> 16)
+ b[2] = uint8(u >> 8)
+ b[3] = uint8(u >> 0)
}
// Returns whether or not the image is fully opaque.
func opaque(m image.Image) bool {
for y := 0; y < m.Height(); y++ {
for x := 0; x < m.Width(); x++ {
- _, _, _, a := m.At(x, y).RGBA();
+ _, _, _, a := m.At(x, y).RGBA()
if a != 0xffffffff {
return false
}
}
}
- return true;
+ return true
}
// The absolute value of a byte interpreted as a signed int8.
if d < 128 {
return int(d)
}
- return 256 - int(d);
+ return 256 - int(d)
}
func (e *encoder) writeChunk(b []byte, name string) {
if e.err != nil {
return
}
- n := uint32(len(b));
+ n := uint32(len(b))
if int(n) != len(b) {
- e.err = UnsupportedError(name + " chunk is too large: " + strconv.Itoa(len(b)));
- return;
+ e.err = UnsupportedError(name + " chunk is too large: " + strconv.Itoa(len(b)))
+ return
}
- writeUint32(e.header[0:4], n);
- e.header[4] = name[0];
- e.header[5] = name[1];
- e.header[6] = name[2];
- e.header[7] = name[3];
- crc := crc32.NewIEEE();
- crc.Write(e.header[4:8]);
- crc.Write(b);
- writeUint32(e.footer[0:4], crc.Sum32());
+ writeUint32(e.header[0:4], n)
+ e.header[4] = name[0]
+ e.header[5] = name[1]
+ e.header[6] = name[2]
+ e.header[7] = name[3]
+ crc := crc32.NewIEEE()
+ crc.Write(e.header[4:8])
+ crc.Write(b)
+ writeUint32(e.footer[0:4], crc.Sum32())
- _, e.err = e.w.Write(e.header[0:8]);
+ _, e.err = e.w.Write(e.header[0:8])
if e.err != nil {
return
}
- _, e.err = e.w.Write(b);
+ _, e.err = e.w.Write(b)
if e.err != nil {
return
}
- _, e.err = e.w.Write(e.footer[0:4]);
+ _, e.err = e.w.Write(e.footer[0:4])
}
func (e *encoder) writeIHDR() {
- writeUint32(e.tmp[0:4], uint32(e.m.Width()));
- writeUint32(e.tmp[4:8], uint32(e.m.Height()));
- e.tmp[8] = 8; // bit depth
- e.tmp[9] = e.colorType;
- e.tmp[10] = 0; // default compression method
- e.tmp[11] = 0; // default filter method
- e.tmp[12] = 0; // non-interlaced
- e.writeChunk(e.tmp[0:13], "IHDR");
+ writeUint32(e.tmp[0:4], uint32(e.m.Width()))
+ writeUint32(e.tmp[4:8], uint32(e.m.Height()))
+ e.tmp[8] = 8 // bit depth
+ e.tmp[9] = e.colorType
+ e.tmp[10] = 0 // default compression method
+ e.tmp[11] = 0 // default filter method
+ e.tmp[12] = 0 // non-interlaced
+ e.writeChunk(e.tmp[0:13], "IHDR")
}
func (e *encoder) writePLTE(p image.PalettedColorModel) {
if len(p) < 1 || len(p) > 256 {
- e.err = FormatError("bad palette length: " + strconv.Itoa(len(p)));
- return;
+ e.err = FormatError("bad palette length: " + strconv.Itoa(len(p)))
+ return
}
for i := 0; i < len(p); i++ {
- r, g, b, a := p[i].RGBA();
+ r, g, b, a := p[i].RGBA()
if a != 0xffffffff {
- e.err = UnsupportedError("non-opaque palette color");
- return;
+ e.err = UnsupportedError("non-opaque palette color")
+ return
}
- e.tmp[3*i+0] = uint8(r >> 24);
- e.tmp[3*i+1] = uint8(g >> 24);
- e.tmp[3*i+2] = uint8(b >> 24);
+ e.tmp[3*i+0] = uint8(r >> 24)
+ e.tmp[3*i+1] = uint8(g >> 24)
+ e.tmp[3*i+2] = uint8(b >> 24)
}
- e.writeChunk(e.tmp[0:3*len(p)], "PLTE");
+ e.writeChunk(e.tmp[0:3*len(p)], "PLTE")
}
// An encoder is an io.Writer that satisfies writes by writing PNG IDAT chunks,
// occur on a separate go-routine than the e.writeIDATs call, and care should be
// taken that e's state (such as its tmp buffer) is not modified concurrently.
func (e *encoder) Write(b []byte) (int, os.Error) {
- e.writeChunk(b, "IDAT");
+ e.writeChunk(b, "IDAT")
if e.err != nil {
return 0, e.err
}
- return len(b), nil;
+ return len(b), nil
}
// Chooses the filter to use for encoding the current row, and applies it.
// This is the same heuristic that libpng uses, although the filters are attempted in order of
// estimated most likely to be minimal (ftUp, ftPaeth, ftNone, ftSub, ftAverage), rather than
// in their enumeration order (ftNone, ftSub, ftUp, ftAverage, ftPaeth).
- cdat0 := cr[0][1:];
- cdat1 := cr[1][1:];
- cdat2 := cr[2][1:];
- cdat3 := cr[3][1:];
- cdat4 := cr[4][1:];
- pdat := pr[1:];
- n := len(cdat0);
+ cdat0 := cr[0][1:]
+ cdat1 := cr[1][1:]
+ cdat2 := cr[2][1:]
+ cdat3 := cr[3][1:]
+ cdat4 := cr[4][1:]
+ pdat := pr[1:]
+ n := len(cdat0)
// The up filter.
- sum := 0;
+ sum := 0
for i := 0; i < n; i++ {
- cdat2[i] = cdat0[i] - pdat[i];
- sum += abs8(cdat2[i]);
+ cdat2[i] = cdat0[i] - pdat[i]
+ sum += abs8(cdat2[i])
}
- best := sum;
- filter := ftUp;
+ best := sum
+ filter := ftUp
// The Paeth filter.
- sum = 0;
+ sum = 0
for i := 0; i < bpp; i++ {
- cdat4[i] = cdat0[i] - paeth(0, pdat[i], 0);
- sum += abs8(cdat4[i]);
+ cdat4[i] = cdat0[i] - paeth(0, pdat[i], 0)
+ sum += abs8(cdat4[i])
}
for i := bpp; i < n; i++ {
- cdat4[i] = cdat0[i] - paeth(cdat0[i-bpp], pdat[i], pdat[i-bpp]);
- sum += abs8(cdat4[i]);
+ cdat4[i] = cdat0[i] - paeth(cdat0[i-bpp], pdat[i], pdat[i-bpp])
+ sum += abs8(cdat4[i])
if sum >= best {
break
}
}
if sum < best {
- best = sum;
- filter = ftPaeth;
+ best = sum
+ filter = ftPaeth
}
// The none filter.
- sum = 0;
+ sum = 0
for i := 0; i < n; i++ {
- sum += abs8(cdat0[i]);
+ sum += abs8(cdat0[i])
if sum >= best {
break
}
}
if sum < best {
- best = sum;
- filter = ftNone;
+ best = sum
+ filter = ftNone
}
// The sub filter.
- sum = 0;
+ sum = 0
for i := 0; i < bpp; i++ {
- cdat1[i] = cdat0[i];
- sum += abs8(cdat1[i]);
+ cdat1[i] = cdat0[i]
+ sum += abs8(cdat1[i])
}
for i := bpp; i < n; i++ {
- cdat1[i] = cdat0[i] - cdat0[i-bpp];
- sum += abs8(cdat1[i]);
+ cdat1[i] = cdat0[i] - cdat0[i-bpp]
+ sum += abs8(cdat1[i])
if sum >= best {
break
}
}
if sum < best {
- best = sum;
- filter = ftSub;
+ best = sum
+ filter = ftSub
}
// The average filter.
- sum = 0;
+ sum = 0
for i := 0; i < bpp; i++ {
- cdat3[i] = cdat0[i] - pdat[i]/2;
- sum += abs8(cdat3[i]);
+ cdat3[i] = cdat0[i] - pdat[i]/2
+ sum += abs8(cdat3[i])
}
for i := bpp; i < n; i++ {
- cdat3[i] = cdat0[i] - uint8((int(cdat0[i-bpp])+int(pdat[i]))/2);
- sum += abs8(cdat3[i]);
+ cdat3[i] = cdat0[i] - uint8((int(cdat0[i-bpp])+int(pdat[i]))/2)
+ sum += abs8(cdat3[i])
if sum >= best {
break
}
}
if sum < best {
- best = sum;
- filter = ftAverage;
+ best = sum
+ filter = ftAverage
}
- return filter;
+ return filter
}
func writeImage(w io.Writer, m image.Image, ct uint8) os.Error {
- zw, err := zlib.NewDeflater(w);
+ zw, err := zlib.NewDeflater(w)
if err != nil {
return err
}
- defer zw.Close();
+ defer zw.Close()
- bpp := 0; // Bytes per pixel.
- var paletted *image.Paletted;
+ bpp := 0 // Bytes per pixel.
+ var paletted *image.Paletted
switch ct {
case ctTrueColor:
bpp = 3
case ctPaletted:
- bpp = 1;
- paletted = m.(*image.Paletted);
+ bpp = 1
+ paletted = m.(*image.Paletted)
case ctTrueColorAlpha:
bpp = 4
}
// cr[ft], for non-zero filter types ft, are buffers for transforming cr[0] under the
// other PNG filter types. These buffers are allocated once and re-used for each row.
// The +1 is for the per-row filter type, which is at cr[*][0].
- var cr [nFilter][]uint8;
+ var cr [nFilter][]uint8
for i := 0; i < len(cr); i++ {
- cr[i] = make([]uint8, 1+bpp*m.Width());
- cr[i][0] = uint8(i);
+ cr[i] = make([]uint8, 1+bpp*m.Width())
+ cr[i][0] = uint8(i)
}
- pr := make([]uint8, 1+bpp*m.Width());
+ pr := make([]uint8, 1+bpp*m.Width())
for y := 0; y < m.Height(); y++ {
// Convert from colors to bytes.
case ctTrueColor:
for x := 0; x < m.Width(); x++ {
// We have previously verified that the alpha value is fully opaque.
- r, g, b, _ := m.At(x, y).RGBA();
- cr[0][3*x+1] = uint8(r >> 24);
- cr[0][3*x+2] = uint8(g >> 24);
- cr[0][3*x+3] = uint8(b >> 24);
+ r, g, b, _ := m.At(x, y).RGBA()
+ cr[0][3*x+1] = uint8(r >> 24)
+ cr[0][3*x+2] = uint8(g >> 24)
+ cr[0][3*x+3] = uint8(b >> 24)
}
case ctPaletted:
for x := 0; x < m.Width(); x++ {
case ctTrueColorAlpha:
// Convert from image.Image (which is alpha-premultiplied) to PNG's non-alpha-premultiplied.
for x := 0; x < m.Width(); x++ {
- c := image.NRGBAColorModel.Convert(m.At(x, y)).(image.NRGBAColor);
- cr[0][4*x+1] = c.R;
- cr[0][4*x+2] = c.G;
- cr[0][4*x+3] = c.B;
- cr[0][4*x+4] = c.A;
+ c := image.NRGBAColorModel.Convert(m.At(x, y)).(image.NRGBAColor)
+ cr[0][4*x+1] = c.R
+ cr[0][4*x+2] = c.G
+ cr[0][4*x+3] = c.B
+ cr[0][4*x+4] = c.A
}
}
// Apply the filter.
- f := filter(cr[0:nFilter], pr, bpp);
+ f := filter(cr[0:nFilter], pr, bpp)
// Write the compressed bytes.
- _, err = zw.Write(cr[f]);
+ _, err = zw.Write(cr[f])
if err != nil {
return err
}
// The current row for y is the previous row for y+1.
- pr, cr[0] = cr[0], pr;
+ pr, cr[0] = cr[0], pr
}
- return nil;
+ return nil
}
// Write the actual image data to one or more IDAT chunks.
if e.err != nil {
return
}
- var bw *bufio.Writer;
- bw, e.err = bufio.NewWriterSize(e, 1<<15);
+ var bw *bufio.Writer
+ bw, e.err = bufio.NewWriterSize(e, 1<<15)
if e.err != nil {
return
}
- e.err = writeImage(bw, e.m, e.colorType);
+ e.err = writeImage(bw, e.m, e.colorType)
if e.err != nil {
return
}
- e.err = bw.Flush();
+ e.err = bw.Flush()
}
-func (e *encoder) writeIEND() { e.writeChunk(e.tmp[0:0], "IEND") }
+func (e *encoder) writeIEND() { e.writeChunk(e.tmp[0:0], "IEND") }
// Encode writes the Image m to w in PNG format. Any Image may be encoded, but
// images that are not image.NRGBA might be encoded lossily.
// Obviously, negative widths and heights are invalid. Furthermore, the PNG
// spec section 11.2.2 says that zero is invalid. Excessively large images are
// also rejected.
- mw, mh := int64(m.Width()), int64(m.Height());
+ mw, mh := int64(m.Width()), int64(m.Height())
if mw <= 0 || mh <= 0 || mw >= 1<<32 || mh >= 1<<32 {
return FormatError("invalid image size: " + strconv.Itoa64(mw) + "x" + strconv.Itoa64(mw))
}
- var e encoder;
- e.w = w;
- e.m = m;
- e.colorType = uint8(ctTrueColorAlpha);
- pal, _ := m.(*image.Paletted);
+ var e encoder
+ e.w = w
+ e.m = m
+ e.colorType = uint8(ctTrueColorAlpha)
+ pal, _ := m.(*image.Paletted)
if pal != nil {
e.colorType = ctPaletted
} else if opaque(m) {
e.colorType = ctTrueColor
}
- _, e.err = io.WriteString(w, pngHeader);
- e.writeIHDR();
+ _, e.err = io.WriteString(w, pngHeader)
+ e.writeIHDR()
if pal != nil {
e.writePLTE(pal.Palette)
}
- e.writeIDATs();
- e.writeIEND();
- return e.err;
+ e.writeIDATs()
+ e.writeIEND()
+ return e.err
}
package png
import (
- "fmt";
- "image";
- "io";
- "os";
- "testing";
+ "fmt"
+ "image"
+ "io"
+ "os"
+ "testing"
)
func diff(m0, m1 image.Image) os.Error {
}
for y := 0; y < m0.Height(); y++ {
for x := 0; x < m0.Width(); x++ {
- r0, g0, b0, a0 := m0.At(x, y).RGBA();
- r1, g1, b1, a1 := m1.At(x, y).RGBA();
+ r0, g0, b0, a0 := m0.At(x, y).RGBA()
+ r1, g1, b1, a1 := m1.At(x, y).RGBA()
if r0 != r1 || g0 != g1 || b0 != b1 || a0 != a1 {
return os.NewError(fmt.Sprintf("colors differ at (%d, %d): %v vs %v", x, y, m0.At(x, y), m1.At(x, y)))
}
}
}
- return nil;
+ return nil
}
func TestWriter(t *testing.T) {
// The filenames variable is declared in reader_test.go.
for _, fn := range filenames {
- qfn := "testdata/pngsuite/" + fn + ".png";
+ qfn := "testdata/pngsuite/" + fn + ".png"
// Read the image.
- m0, err := readPng(qfn);
+ m0, err := readPng(qfn)
if err != nil {
- t.Error(fn, err);
- continue;
+ t.Error(fn, err)
+ continue
}
// Read the image again, and push it through a pipe that encodes at the write end, and decodes at the read end.
- pr, pw := io.Pipe();
- defer pr.Close();
+ pr, pw := io.Pipe()
+ defer pr.Close()
go func() {
- defer pw.Close();
- m1, err := readPng(qfn);
+ defer pw.Close()
+ m1, err := readPng(qfn)
if err != nil {
- t.Error(fn, err);
- return;
+ t.Error(fn, err)
+ return
}
- err = Encode(pw, m1);
+ err = Encode(pw, m1)
if err != nil {
- t.Error(fn, err);
- return;
+ t.Error(fn, err)
+ return
}
- }();
- m2, err := Decode(pr);
+ }()
+ m2, err := Decode(pr)
if err != nil {
- t.Error(fn, err);
- continue;
+ t.Error(fn, err)
+ continue
}
// Compare the two.
- err = diff(m0, m2);
+ err = diff(m0, m2)
if err != nil {
- t.Error(fn, err);
- continue;
+ t.Error(fn, err)
+ continue
}
}
}
package io
import (
- "os";
- "strings";
+ "os"
+ "strings"
)
// Error represents an unexpected I/O behavior.
type Error struct {
- os.ErrorString;
+ os.ErrorString
}
// ErrShortWrite means that a write accepted fewer bytes than requested
// Read may return a non-zero number of bytes with a non-nil err.
// In particular, a Read that exhausts the input may return n > 0, os.EOF.
type Reader interface {
- Read(p []byte) (n int, err os.Error);
+ Read(p []byte) (n int, err os.Error)
}
// Writer is the interface that wraps the basic Write method.
// and any error encountered that caused the write to stop early.
// Write must return a non-nil error if it returns n < len(p).
type Writer interface {
- Write(p []byte) (n int, err os.Error);
+ Write(p []byte) (n int, err os.Error)
}
// Closer is the interface that wraps the basic Close method.
type Closer interface {
- Close() os.Error;
+ Close() os.Error
}
// Seeker is the interface that wraps the basic Seek method.
// relative to the end. Seek returns the new offset and an Error, if
// any.
type Seeker interface {
- Seek(offset int64, whence int) (ret int64, err os.Error);
+ Seek(offset int64, whence int) (ret int64, err os.Error)
}
// ReadWriter is the interface that groups the basic Read and Write methods.
type ReadWriter interface {
- Reader;
- Writer;
+ Reader
+ Writer
}
// ReadCloser is the interface that groups the basic Read and Close methods.
type ReadCloser interface {
- Reader;
- Closer;
+ Reader
+ Closer
}
// WriteCloser is the interface that groups the basic Write and Close methods.
type WriteCloser interface {
- Writer;
- Closer;
+ Writer
+ Closer
}
// ReadWriteCloser is the interface that groups the basic Read, Write and Close methods.
type ReadWriteCloser interface {
- Reader;
- Writer;
- Closer;
+ Reader
+ Writer
+ Closer
}
// ReadSeeker is the interface that groups the basic Read and Seek methods.
type ReadSeeker interface {
- Reader;
- Seeker;
+ Reader
+ Seeker
}
// WriteSeeker is the interface that groups the basic Write and Seek methods.
type WriteSeeker interface {
- Writer;
- Seeker;
+ Writer
+ Seeker
}
// ReadWriteSeeker is the interface that groups the basic Read, Write and Seek methods.
type ReadWriteSeeker interface {
- Reader;
- Writer;
- Seeker;
+ Reader
+ Writer
+ Seeker
}
// ReaderFrom is the interface that wraps the ReadFrom method.
type ReaderFrom interface {
- ReadFrom(r Reader) (n int64, err os.Error);
+ ReadFrom(r Reader) (n int64, err os.Error)
}
// WriterTo is the interface that wraps the WriteTo method.
type WriterTo interface {
- WriteTo(w Writer) (n int64, err os.Error);
+ WriteTo(w Writer) (n int64, err os.Error)
}
// ReaderAt is the interface that wraps the basic ReadAt method.
// ReadAt may return a non-zero number of bytes with a non-nil err.
// In particular, a ReadAt that exhausts the input may return n > 0, os.EOF.
type ReaderAt interface {
- ReadAt(p []byte, off int64) (n int, err os.Error);
+ ReadAt(p []byte, off int64) (n int, err os.Error)
}
// WriterAt is the interface that wraps the basic WriteAt method.
// and any error encountered that caused the write to stop early.
// WriteAt must return a non-nil error if it returns n < len(p).
type WriterAt interface {
- WriteAt(p []byte, off int64) (n int, err os.Error);
+ WriteAt(p []byte, off int64) (n int, err os.Error)
}
// WriteString writes the contents of the string s to w, which accepts an array of bytes.
// If an EOF happens after reading fewer than min bytes,
// ReadAtLeast returns ErrUnexpectedEOF.
func ReadAtLeast(r Reader, buf []byte, min int) (n int, err os.Error) {
- n = 0;
+ n = 0
for n < min {
- nn, e := r.Read(buf[n:]);
+ nn, e := r.Read(buf[n:])
if nn > 0 {
n += nn
}
if e == os.EOF && n > 0 {
e = ErrUnexpectedEOF
}
- return n, e;
+ return n, e
}
}
- return n, nil;
+ return n, nil
}
// ReadFull reads exactly len(buf) bytes from r into buf.
if rt, ok := dst.(ReaderFrom); ok {
return rt.ReadFrom(LimitReader(src, n))
}
- buf := make([]byte, 32*1024);
+ buf := make([]byte, 32*1024)
for written < n {
- l := len(buf);
+ l := len(buf)
if d := n - written; d < int64(l) {
l = int(d)
}
- nr, er := src.Read(buf[0:l]);
+ nr, er := src.Read(buf[0:l])
if nr > 0 {
- nw, ew := dst.Write(buf[0:nr]);
+ nw, ew := dst.Write(buf[0:nr])
if nw > 0 {
written += int64(nw)
}
if ew != nil {
- err = ew;
- break;
+ err = ew
+ break
}
if nr != nw {
- err = ErrShortWrite;
- break;
+ err = ErrShortWrite
+ break
}
}
if er != nil {
- err = er;
- break;
+ err = er
+ break
}
}
- return written, err;
+ return written, err
}
// Copy copies from src to dst until either EOF is reached
if wt, ok := src.(WriterTo); ok {
return wt.WriteTo(dst)
}
- buf := make([]byte, 32*1024);
+ buf := make([]byte, 32*1024)
for {
- nr, er := src.Read(buf);
+ nr, er := src.Read(buf)
if nr > 0 {
- nw, ew := dst.Write(buf[0:nr]);
+ nw, ew := dst.Write(buf[0:nr])
if nw > 0 {
written += int64(nw)
}
if ew != nil {
- err = ew;
- break;
+ err = ew
+ break
}
if nr != nw {
- err = ErrShortWrite;
- break;
+ err = ErrShortWrite
+ break
}
}
if er == os.EOF {
break
}
if er != nil {
- err = er;
- break;
+ err = er
+ break
}
}
- return written, err;
+ return written, err
}
// LimitReader returns a Reader that reads from r
// but stops with os.EOF after n bytes.
-func LimitReader(r Reader, n int64) Reader { return &limitedReader{r, n} }
+func LimitReader(r Reader, n int64) Reader { return &limitedReader{r, n} }
type limitedReader struct {
- r Reader;
- n int64;
+ r Reader
+ n int64
}
func (l *limitedReader) Read(p []byte) (n int, err os.Error) {
if int64(len(p)) > l.n {
p = p[0:l.n]
}
- n, err = l.r.Read(p);
- l.n -= int64(n);
- return;
+ n, err = l.r.Read(p)
+ l.n -= int64(n)
+ return
}
// NewSectionReader returns a SectionReader that reads from r
// SectionReader implements Read, Seek, and ReadAt on a section
// of an underlying ReaderAt.
type SectionReader struct {
- r ReaderAt;
- base int64;
- off int64;
- limit int64;
+ r ReaderAt
+ base int64
+ off int64
+ limit int64
}
func (s *SectionReader) Read(p []byte) (n int, err os.Error) {
if max := s.limit - s.off; int64(len(p)) > max {
p = p[0:max]
}
- n, err = s.r.ReadAt(p, s.off);
- s.off += int64(n);
- return;
+ n, err = s.r.ReadAt(p, s.off)
+ s.off += int64(n)
+ return
}
func (s *SectionReader) Seek(offset int64, whence int) (ret int64, err os.Error) {
if offset < s.off || offset > s.limit {
return 0, os.EINVAL
}
- s.off = offset;
- return offset - s.base, nil;
+ s.off = offset
+ return offset - s.base, nil
}
func (s *SectionReader) ReadAt(p []byte, off int64) (n int, err os.Error) {
if off < 0 || off >= s.limit-s.base {
return 0, os.EOF
}
- off += s.base;
+ off += s.base
if max := s.limit - off; int64(len(p)) > max {
p = p[0:max]
}
- return s.r.ReadAt(p, off);
+ return s.r.ReadAt(p, off)
}
// Size returns the size of the section in bytes.
-func (s *SectionReader) Size() int64 { return s.limit - s.base }
+func (s *SectionReader) Size() int64 { return s.limit - s.base }
package io_test
import (
- "bytes";
- . "io";
- "testing";
+ "bytes"
+ . "io"
+ "testing"
)
// An version of bytes.Buffer without ReadFrom and WriteTo
type Buffer struct {
- bytes.Buffer;
- ReaderFrom; // conflicts with and hides bytes.Buffer's ReaderFrom.
- WriterTo; // conflicts with and hides bytes.Buffer's WriterTo.
+ bytes.Buffer
+ ReaderFrom // conflicts with and hides bytes.Buffer's ReaderFrom.
+ WriterTo // conflicts with and hides bytes.Buffer's WriterTo.
}
// Simple tests, primarily to verify the ReadFrom and WriteTo callouts inside Copy and Copyn.
func TestCopy(t *testing.T) {
- rb := new(Buffer);
- wb := new(Buffer);
- rb.WriteString("hello, world.");
- Copy(wb, rb);
+ rb := new(Buffer)
+ wb := new(Buffer)
+ rb.WriteString("hello, world.")
+ Copy(wb, rb)
if wb.String() != "hello, world." {
t.Errorf("Copy did not work properly")
}
}
func TestCopyReadFrom(t *testing.T) {
- rb := new(Buffer);
- wb := new(bytes.Buffer); // implements ReadFrom.
- rb.WriteString("hello, world.");
- Copy(wb, rb);
+ rb := new(Buffer)
+ wb := new(bytes.Buffer) // implements ReadFrom.
+ rb.WriteString("hello, world.")
+ Copy(wb, rb)
if wb.String() != "hello, world." {
t.Errorf("Copy did not work properly")
}
}
func TestCopyWriteTo(t *testing.T) {
- rb := new(bytes.Buffer); // implements WriteTo.
- wb := new(Buffer);
- rb.WriteString("hello, world.");
- Copy(wb, rb);
+ rb := new(bytes.Buffer) // implements WriteTo.
+ wb := new(Buffer)
+ rb.WriteString("hello, world.")
+ Copy(wb, rb)
if wb.String() != "hello, world." {
t.Errorf("Copy did not work properly")
}
}
func TestCopyn(t *testing.T) {
- rb := new(Buffer);
- wb := new(Buffer);
- rb.WriteString("hello, world.");
- Copyn(wb, rb, 5);
+ rb := new(Buffer)
+ wb := new(Buffer)
+ rb.WriteString("hello, world.")
+ Copyn(wb, rb, 5)
if wb.String() != "hello" {
t.Errorf("Copyn did not work properly")
}
}
func TestCopynReadFrom(t *testing.T) {
- rb := new(Buffer);
- wb := new(bytes.Buffer); // implements ReadFrom.
- rb.WriteString("hello");
- Copyn(wb, rb, 5);
+ rb := new(Buffer)
+ wb := new(bytes.Buffer) // implements ReadFrom.
+ rb.WriteString("hello")
+ Copyn(wb, rb, 5)
if wb.String() != "hello" {
t.Errorf("Copyn did not work properly")
}
}
func TestCopynWriteTo(t *testing.T) {
- rb := new(bytes.Buffer); // implements WriteTo.
- wb := new(Buffer);
- rb.WriteString("hello, world.");
- Copyn(wb, rb, 5);
+ rb := new(bytes.Buffer) // implements WriteTo.
+ wb := new(Buffer)
+ rb.WriteString("hello, world.")
+ Copyn(wb, rb, 5)
if wb.String() != "hello" {
t.Errorf("Copyn did not work properly")
}
package ioutil
import (
- "bytes";
- "io";
- "os";
- "sort";
+ "bytes"
+ "io"
+ "os"
+ "sort"
)
// ReadAll reads from r until an error or EOF and returns the data it read.
func ReadAll(r io.Reader) ([]byte, os.Error) {
- var buf bytes.Buffer;
- _, err := io.Copy(&buf, r);
- return buf.Bytes(), err;
+ var buf bytes.Buffer
+ _, err := io.Copy(&buf, r)
+ return buf.Bytes(), err
}
// ReadFile reads the file named by filename and returns the contents.
func ReadFile(filename string) ([]byte, os.Error) {
- f, err := os.Open(filename, os.O_RDONLY, 0);
+ f, err := os.Open(filename, os.O_RDONLY, 0)
if err != nil {
return nil, err
}
- defer f.Close();
+ defer f.Close()
// It's a good but not certain bet that Stat will tell us exactly how much to
// read, so let's try it but be prepared for the answer to be wrong.
- dir, err := f.Stat();
- var n uint64;
- if err != nil && dir.Size < 2e9 { // Don't preallocate a huge buffer, just in case.
+ dir, err := f.Stat()
+ var n uint64
+ if err != nil && dir.Size < 2e9 { // Don't preallocate a huge buffer, just in case.
n = dir.Size
}
// Add a little extra in case Size is zero, and to avoid another allocation after
// Read has filled the buffer.
- n += bytes.MinRead;
+ n += bytes.MinRead
// Pre-allocate the correct size of buffer, then set its size to zero. The
// Buffer will read into the allocated space cheaply. If the size was wrong,
// we'll either waste some space off the end or reallocate as needed, but
// in the overwhelmingly common case we'll get it just right.
- buf := bytes.NewBuffer(make([]byte, 0, n));
- _, err = buf.ReadFrom(f);
- return buf.Bytes(), err;
+ buf := bytes.NewBuffer(make([]byte, 0, n))
+ _, err = buf.ReadFrom(f)
+ return buf.Bytes(), err
}
// WriteFile writes data to a file named by filename.
// If the file does not exist, WriteFile creates it with permissions perm;
// otherwise WriteFile truncates it before writing.
func WriteFile(filename string, data []byte, perm int) os.Error {
- f, err := os.Open(filename, os.O_WRONLY|os.O_CREAT|os.O_TRUNC, perm);
+ f, err := os.Open(filename, os.O_WRONLY|os.O_CREAT|os.O_TRUNC, perm)
if err != nil {
return err
}
- n, err := f.Write(data);
- f.Close();
+ n, err := f.Write(data)
+ f.Close()
if err == nil && n < len(data) {
err = io.ErrShortWrite
}
- return err;
+ return err
}
// A dirList implements sort.Interface.
type dirList []*os.Dir
-func (d dirList) Len() int { return len(d) }
-func (d dirList) Less(i, j int) bool { return d[i].Name < d[j].Name }
-func (d dirList) Swap(i, j int) { d[i], d[j] = d[j], d[i] }
+func (d dirList) Len() int { return len(d) }
+func (d dirList) Less(i, j int) bool { return d[i].Name < d[j].Name }
+func (d dirList) Swap(i, j int) { d[i], d[j] = d[j], d[i] }
// ReadDir reads the directory named by dirname and returns
// a list of sorted directory entries.
func ReadDir(dirname string) ([]*os.Dir, os.Error) {
- f, err := os.Open(dirname, os.O_RDONLY, 0);
+ f, err := os.Open(dirname, os.O_RDONLY, 0)
if err != nil {
return nil, err
}
- list, err := f.Readdir(-1);
- f.Close();
+ list, err := f.Readdir(-1)
+ f.Close()
if err != nil {
return nil, err
}
- dirs := make(dirList, len(list));
+ dirs := make(dirList, len(list))
for i := range list {
dirs[i] = &list[i]
}
- sort.Sort(dirs);
- return dirs, nil;
+ sort.Sort(dirs)
+ return dirs, nil
}
package ioutil_test
import (
- . "io/ioutil";
- "os";
- "strings";
- "testing";
+ . "io/ioutil"
+ "os"
+ "strings"
+ "testing"
)
func checkSize(t *testing.T, path string, size uint64) {
- dir, err := os.Stat(path);
+ dir, err := os.Stat(path)
if err != nil {
t.Fatalf("Stat %q (looking for size %d): %s", path, size, err)
}
}
func TestReadFile(t *testing.T) {
- filename := "rumpelstilzchen";
- contents, err := ReadFile(filename);
+ filename := "rumpelstilzchen"
+ contents, err := ReadFile(filename)
if err == nil {
t.Fatalf("ReadFile %s: error expected, none found", filename)
}
- filename = "ioutil_test.go";
- contents, err = ReadFile(filename);
+ filename = "ioutil_test.go"
+ contents, err = ReadFile(filename)
if err != nil {
t.Fatalf("ReadFile %s: %v", filename, err)
}
- checkSize(t, filename, uint64(len(contents)));
+ checkSize(t, filename, uint64(len(contents)))
}
func TestWriteFile(t *testing.T) {
- filename := "_obj/rumpelstilzchen";
+ filename := "_obj/rumpelstilzchen"
data := "Programming today is a race between software engineers striving to " +
"build bigger and better idiot-proof programs, and the Universe trying " +
- "to produce bigger and better idiots. So far, the Universe is winning.";
+ "to produce bigger and better idiots. So far, the Universe is winning."
if err := WriteFile(filename, strings.Bytes(data), 0644); err != nil {
t.Fatalf("WriteFile %s: %v", filename, err)
}
- contents, err := ReadFile(filename);
+ contents, err := ReadFile(filename)
if err != nil {
t.Fatalf("ReadFile %s: %v", filename, err)
}
}
// cleanup
- os.Remove(filename); // ignore error
+ os.Remove(filename) // ignore error
}
func TestReadDir(t *testing.T) {
- dirname := "rumpelstilzchen";
- _, err := ReadDir(dirname);
+ dirname := "rumpelstilzchen"
+ _, err := ReadDir(dirname)
if err == nil {
t.Fatalf("ReadDir %s: error expected, none found", dirname)
}
- dirname = ".";
- list, err := ReadDir(dirname);
+ dirname = "."
+ list, err := ReadDir(dirname)
if err != nil {
t.Fatalf("ReadDir %s: %v", dirname, err)
}
- foundTest := false;
- foundObj := false;
+ foundTest := false
+ foundObj := false
for _, dir := range list {
switch {
case dir.IsRegular() && dir.Name == "ioutil_test.go":
package io
import (
- "os";
- "sync";
+ "os"
+ "sync"
)
type pipeReturn struct {
- n int;
- err os.Error;
+ n int
+ err os.Error
}
// Shared pipe structure.
type pipe struct {
- rclosed bool; // Read end closed?
- rerr os.Error; // Error supplied to CloseReader
- wclosed bool; // Write end closed?
- werr os.Error; // Error supplied to CloseWriter
- wpend []byte; // Written data waiting to be read.
- wtot int; // Bytes consumed so far in current write.
- cr chan []byte; // Write sends data here...
- cw chan pipeReturn; // ... and reads the n, err back from here.
+ rclosed bool // Read end closed?
+ rerr os.Error // Error supplied to CloseReader
+ wclosed bool // Write end closed?
+ werr os.Error // Error supplied to CloseWriter
+ wpend []byte // Written data waiting to be read.
+ wtot int // Bytes consumed so far in current write.
+ cr chan []byte // Write sends data here...
+ cw chan pipeReturn // ... and reads the n, err back from here.
}
func (p *pipe) Read(data []byte) (n int, err os.Error) {
if p.wpend == nil {
return 0, p.werr
}
- p.wtot = 0;
+ p.wtot = 0
}
// Read from current write block.
- n = len(data);
+ n = len(data)
if n > len(p.wpend) {
n = len(p.wpend)
}
for i := 0; i < n; i++ {
data[i] = p.wpend[i]
}
- p.wtot += n;
- p.wpend = p.wpend[n:];
+ p.wtot += n
+ p.wpend = p.wpend[n:]
// If write block is done, finish the write.
if len(p.wpend) == 0 {
- p.wpend = nil;
- p.cw <- pipeReturn{p.wtot, nil};
- p.wtot = 0;
+ p.wpend = nil
+ p.cw <- pipeReturn{p.wtot, nil}
+ p.wtot = 0
}
- return n, nil;
+ return n, nil
}
func (p *pipe) Write(data []byte) (n int, err os.Error) {
}
// Send data to reader.
- p.cr <- data;
+ p.cr <- data
// Wait for reader to finish copying it.
- res := <-p.cw;
- return res.n, res.err;
+ res := <-p.cw
+ return res.n, res.err
}
func (p *pipe) CloseReader(rerr os.Error) os.Error {
}
// Stop any future writes.
- p.rclosed = true;
+ p.rclosed = true
if rerr == nil {
rerr = os.EPIPE
}
- p.rerr = rerr;
+ p.rerr = rerr
// Stop the current write.
if !p.wclosed {
p.cw <- pipeReturn{p.wtot, rerr}
}
- return nil;
+ return nil
}
func (p *pipe) CloseWriter(werr os.Error) os.Error {
}
// Stop any future reads.
- p.wclosed = true;
- p.werr = werr;
+ p.wclosed = true
+ p.werr = werr
// Stop the current read.
if !p.rclosed {
p.cr <- nil
}
- return nil;
+ return nil
}
// Read/write halves of the pipe.
// A PipeReader is the read half of a pipe.
type PipeReader struct {
- lock sync.Mutex;
- p *pipe;
+ lock sync.Mutex
+ p *pipe
}
// Read implements the standard Read interface:
// If the write end is closed with an error, that error is
// returned as err; otherwise err is nil.
func (r *PipeReader) Read(data []byte) (n int, err os.Error) {
- r.lock.Lock();
- defer r.lock.Unlock();
+ r.lock.Lock()
+ defer r.lock.Unlock()
- return r.p.Read(data);
+ return r.p.Read(data)
}
// Close closes the reader; subsequent writes to the
// write half of the pipe will return the error os.EPIPE.
func (r *PipeReader) Close() os.Error {
- r.lock.Lock();
- defer r.lock.Unlock();
+ r.lock.Lock()
+ defer r.lock.Unlock()
- return r.p.CloseReader(nil);
+ return r.p.CloseReader(nil)
}
// CloseWithError closes the reader; subsequent writes
// to the write half of the pipe will return the error rerr.
func (r *PipeReader) CloseWithError(rerr os.Error) os.Error {
- r.lock.Lock();
- defer r.lock.Unlock();
+ r.lock.Lock()
+ defer r.lock.Unlock()
- return r.p.CloseReader(rerr);
+ return r.p.CloseReader(rerr)
}
-func (r *PipeReader) finish() { r.Close() }
+func (r *PipeReader) finish() { r.Close() }
// Write half of pipe.
type PipeWriter struct {
- lock sync.Mutex;
- p *pipe;
+ lock sync.Mutex
+ p *pipe
}
// Write implements the standard Write interface:
// If the read end is closed with an error, that err is
// returned as err; otherwise err is os.EPIPE.
func (w *PipeWriter) Write(data []byte) (n int, err os.Error) {
- w.lock.Lock();
- defer w.lock.Unlock();
+ w.lock.Lock()
+ defer w.lock.Unlock()
- return w.p.Write(data);
+ return w.p.Write(data)
}
// Close closes the writer; subsequent reads from the
// read half of the pipe will return no bytes and a nil error.
func (w *PipeWriter) Close() os.Error {
- w.lock.Lock();
- defer w.lock.Unlock();
+ w.lock.Lock()
+ defer w.lock.Unlock()
- return w.p.CloseWriter(nil);
+ return w.p.CloseWriter(nil)
}
// CloseWithError closes the writer; subsequent reads from the
// read half of the pipe will return no bytes and the error werr.
func (w *PipeWriter) CloseWithError(werr os.Error) os.Error {
- w.lock.Lock();
- defer w.lock.Unlock();
+ w.lock.Lock()
+ defer w.lock.Unlock()
- return w.p.CloseWriter(werr);
+ return w.p.CloseWriter(werr)
}
-func (w *PipeWriter) finish() { w.Close() }
+func (w *PipeWriter) finish() { w.Close() }
// Pipe creates a synchronous in-memory pipe.
// It can be used to connect code expecting an io.Reader
// Reads on one end are matched with writes on the other,
// copying data directly between the two; there is no internal buffering.
func Pipe() (*PipeReader, *PipeWriter) {
- p := new(pipe);
- p.cr = make(chan []byte, 1);
- p.cw = make(chan pipeReturn, 1);
- r := new(PipeReader);
- r.p = p;
- w := new(PipeWriter);
- w.p = p;
- return r, w;
+ p := new(pipe)
+ p.cr = make(chan []byte, 1)
+ p.cw = make(chan pipeReturn, 1)
+ r := new(PipeReader)
+ r.p = p
+ w := new(PipeWriter)
+ w.p = p
+ return r, w
}
package io_test
import (
- "fmt";
- . "io";
- "os";
- "strings";
- "testing";
- "time";
+ "fmt"
+ . "io"
+ "os"
+ "strings"
+ "testing"
+ "time"
)
func checkWrite(t *testing.T, w Writer, data []byte, c chan int) {
- n, err := w.Write(data);
+ n, err := w.Write(data)
if err != nil {
t.Errorf("write: %v", err)
}
if n != len(data) {
t.Errorf("short write: %d != %d", n, len(data))
}
- c <- 0;
+ c <- 0
}
// Test a single read/write pair.
func TestPipe1(t *testing.T) {
- c := make(chan int);
- r, w := Pipe();
- var buf = make([]byte, 64);
- go checkWrite(t, w, strings.Bytes("hello, world"), c);
- n, err := r.Read(buf);
+ c := make(chan int)
+ r, w := Pipe()
+ var buf = make([]byte, 64)
+ go checkWrite(t, w, strings.Bytes("hello, world"), c)
+ n, err := r.Read(buf)
if err != nil {
t.Errorf("read: %v", err)
} else if n != 12 || string(buf[0:12]) != "hello, world" {
t.Errorf("bad read: got %q", buf[0:n])
}
- <-c;
- r.Close();
- w.Close();
+ <-c
+ r.Close()
+ w.Close()
}
func reader(t *testing.T, r Reader, c chan int) {
- var buf = make([]byte, 64);
+ var buf = make([]byte, 64)
for {
- n, err := r.Read(buf);
+ n, err := r.Read(buf)
if err == os.EOF {
- c <- 0;
- break;
+ c <- 0
+ break
}
if err != nil {
t.Errorf("read: %v", err)
}
- c <- n;
+ c <- n
}
}
// Test a sequence of read/write pairs.
func TestPipe2(t *testing.T) {
- c := make(chan int);
- r, w := Pipe();
- go reader(t, r, c);
- var buf = make([]byte, 64);
+ c := make(chan int)
+ r, w := Pipe()
+ go reader(t, r, c)
+ var buf = make([]byte, 64)
for i := 0; i < 5; i++ {
- p := buf[0 : 5+i*10];
- n, err := w.Write(p);
+ p := buf[0 : 5+i*10]
+ n, err := w.Write(p)
if n != len(p) {
t.Errorf("wrote %d, got %d", len(p), n)
}
if err != nil {
t.Errorf("write: %v", err)
}
- nn := <-c;
+ nn := <-c
if nn != n {
t.Errorf("wrote %d, read got %d", n, nn)
}
}
- w.Close();
- nn := <-c;
+ w.Close()
+ nn := <-c
if nn != 0 {
t.Errorf("final read got %d", nn)
}
}
type pipeReturn struct {
- n int;
- err os.Error;
+ n int
+ err os.Error
}
// Test a large write that requires multiple reads to satisfy.
func writer(w WriteCloser, buf []byte, c chan pipeReturn) {
- n, err := w.Write(buf);
- w.Close();
- c <- pipeReturn{n, err};
+ n, err := w.Write(buf)
+ w.Close()
+ c <- pipeReturn{n, err}
}
func TestPipe3(t *testing.T) {
- c := make(chan pipeReturn);
- r, w := Pipe();
- var wdat = make([]byte, 128);
+ c := make(chan pipeReturn)
+ r, w := Pipe()
+ var wdat = make([]byte, 128)
for i := 0; i < len(wdat); i++ {
wdat[i] = byte(i)
}
- go writer(w, wdat, c);
- var rdat = make([]byte, 1024);
- tot := 0;
+ go writer(w, wdat, c)
+ var rdat = make([]byte, 1024)
+ tot := 0
for n := 1; n <= 256; n *= 2 {
- nn, err := r.Read(rdat[tot : tot+n]);
+ nn, err := r.Read(rdat[tot : tot+n])
if err != nil && err != os.EOF {
t.Fatalf("read: %v", err)
}
// only final two reads should be short - 1 byte, then 0
- expect := n;
+ expect := n
if n == 128 {
expect = 1
} else if n == 256 {
- expect = 0;
+ expect = 0
if err != os.EOF {
t.Fatalf("read at end: %v", err)
}
if nn != expect {
t.Fatalf("read %d, expected %d, got %d", n, expect, nn)
}
- tot += nn;
+ tot += nn
}
- pr := <-c;
+ pr := <-c
if pr.n != 128 || pr.err != nil {
t.Fatalf("write 128: %d, %v", pr.n, pr.err)
}
// Test read after/before writer close.
type closer interface {
- CloseWithError(os.Error) os.Error;
- Close() os.Error;
+ CloseWithError(os.Error) os.Error
+ Close() os.Error
}
type pipeTest struct {
- async bool;
- err os.Error;
- closeWithError bool;
+ async bool
+ err os.Error
+ closeWithError bool
}
func (p pipeTest) String() string {
}
func delayClose(t *testing.T, cl closer, ch chan int, tt pipeTest) {
- time.Sleep(1e6); // 1 ms
- var err os.Error;
+ time.Sleep(1e6) // 1 ms
+ var err os.Error
if tt.closeWithError {
err = cl.CloseWithError(tt.err)
} else {
if err != nil {
t.Errorf("delayClose: %v", err)
}
- ch <- 0;
+ ch <- 0
}
func TestPipeReadClose(t *testing.T) {
for _, tt := range pipeTests {
- c := make(chan int, 1);
- r, w := Pipe();
+ c := make(chan int, 1)
+ r, w := Pipe()
if tt.async {
go delayClose(t, w, c, tt)
} else {
delayClose(t, w, c, tt)
}
- var buf = make([]byte, 64);
- n, err := r.Read(buf);
- <-c;
- want := tt.err;
+ var buf = make([]byte, 64)
+ n, err := r.Read(buf)
+ <-c
+ want := tt.err
if want == nil {
want = os.EOF
}
func TestPipeWriteClose(t *testing.T) {
for _, tt := range pipeTests {
- c := make(chan int, 1);
- r, w := Pipe();
+ c := make(chan int, 1)
+ r, w := Pipe()
if tt.async {
go delayClose(t, r, c, tt)
} else {
delayClose(t, r, c, tt)
}
- n, err := WriteString(w, "hello, world");
- <-c;
- expect := tt.err;
+ n, err := WriteString(w, "hello, world")
+ <-c
+ expect := tt.err
if expect == nil {
expect = os.EPIPE
}
package json
import (
- "container/vector";
- "os";
+ "container/vector"
+ "os"
)
// Decode a JSON string
// If Decode encounters a syntax error, it returns with err set to an
// instance of ParseError. See ParseError documentation for details.
func Decode(s string) (data interface{}, err os.Error) {
- jb := newDecoder(nil, nil);
- ok, errPos, errTok := Parse(s, jb);
+ jb := newDecoder(nil, nil)
+ ok, errPos, errTok := Parse(s, jb)
if ok {
data = jb.Data()
} else {
err = &ParseError{Index: errPos, Token: errTok}
}
- return;
+ return
}
type decoder struct {
// A value being constructed.
- value interface{};
+ value interface{}
// Container entity to flush into. Can be either vector.Vector or
// map[string]interface{}.
- container interface{};
+ container interface{}
// The index into the container interface. Either int or string.
- index interface{};
+ index interface{}
}
func newDecoder(container interface{}, key interface{}) *decoder {
return &decoder{container: container, index: key}
}
-func (j *decoder) Int64(i int64) { j.value = float64(i) }
+func (j *decoder) Int64(i int64) { j.value = float64(i) }
-func (j *decoder) Uint64(i uint64) { j.value = float64(i) }
+func (j *decoder) Uint64(i uint64) { j.value = float64(i) }
-func (j *decoder) Float64(f float64) { j.value = float64(f) }
+func (j *decoder) Float64(f float64) { j.value = float64(f) }
-func (j *decoder) String(s string) { j.value = s }
+func (j *decoder) String(s string) { j.value = s }
-func (j *decoder) Bool(b bool) { j.value = b }
+func (j *decoder) Bool(b bool) { j.value = b }
-func (j *decoder) Null() { j.value = nil }
+func (j *decoder) Null() { j.value = nil }
-func (j *decoder) Array() { j.value = new(vector.Vector) }
+func (j *decoder) Array() { j.value = new(vector.Vector) }
-func (j *decoder) Map() { j.value = make(map[string]interface{}) }
+func (j *decoder) Map() { j.value = make(map[string]interface{}) }
func (j *decoder) Elem(i int) Builder {
- v, ok := j.value.(*vector.Vector);
+ v, ok := j.value.(*vector.Vector)
if !ok {
- v = new(vector.Vector);
- j.value = v;
+ v = new(vector.Vector)
+ j.value = v
}
if v.Len() <= i {
v.Resize(i+1, (i+1)*2)
}
- return newDecoder(v, i);
+ return newDecoder(v, i)
}
func (j *decoder) Key(s string) Builder {
- m, ok := j.value.(map[string]interface{});
+ m, ok := j.value.(map[string]interface{})
if !ok {
- m = make(map[string]interface{});
- j.value = m;
+ m = make(map[string]interface{})
+ j.value = m
}
- return newDecoder(m, s);
+ return newDecoder(m, s)
}
func (j *decoder) Flush() {
switch c := j.container.(type) {
case *vector.Vector:
- index := j.index.(int);
- c.Set(index, j.Data());
+ index := j.index.(int)
+ c.Set(index, j.Data())
case map[string]interface{}:
- index := j.index.(string);
- c[index] = j.Data();
+ index := j.index.(string)
+ c[index] = j.Data()
}
}
case *vector.Vector:
return v.Data()
}
- return j.value;
+ return j.value
}
package json
import (
- "container/vector";
- "reflect";
- "testing";
+ "container/vector"
+ "reflect"
+ "testing"
)
func TestDecodeInt64(t *testing.T) {
- nb := newDecoder(nil, nil);
- nb.Int64(-15);
- assertResult(t, nb.Data(), float64(-15));
+ nb := newDecoder(nil, nil)
+ nb.Int64(-15)
+ assertResult(t, nb.Data(), float64(-15))
}
func TestDecodeUint64(t *testing.T) {
- nb := newDecoder(nil, nil);
- nb.Uint64(15);
- assertResult(t, nb.Data(), float64(15));
+ nb := newDecoder(nil, nil)
+ nb.Uint64(15)
+ assertResult(t, nb.Data(), float64(15))
}
func TestDecodeFloat64(t *testing.T) {
- nb := newDecoder(nil, nil);
- nb.Float64(3.14159);
- assertResult(t, nb.Data(), float64(3.14159));
+ nb := newDecoder(nil, nil)
+ nb.Float64(3.14159)
+ assertResult(t, nb.Data(), float64(3.14159))
}
func TestDecodeString(t *testing.T) {
- nb := newDecoder(nil, nil);
- nb.String("Some string");
- assertResult(t, nb.Data(), "Some string");
+ nb := newDecoder(nil, nil)
+ nb.String("Some string")
+ assertResult(t, nb.Data(), "Some string")
}
func TestDecodeBool(t *testing.T) {
- nb := newDecoder(nil, nil);
- nb.Bool(true);
- assertResult(t, nb.Data(), true);
+ nb := newDecoder(nil, nil)
+ nb.Bool(true)
+ assertResult(t, nb.Data(), true)
}
func TestDecodeNull(t *testing.T) {
- nb := newDecoder(nil, nil);
- nb.Null();
- assertResult(t, nb.Data(), nil);
+ nb := newDecoder(nil, nil)
+ nb.Null()
+ assertResult(t, nb.Data(), nil)
}
func TestDecodeEmptyArray(t *testing.T) {
- nb := newDecoder(nil, nil);
- nb.Array();
- assertResult(t, nb.Data(), []interface{}{});
+ nb := newDecoder(nil, nil)
+ nb.Array()
+ assertResult(t, nb.Data(), []interface{}{})
}
func TestDecodeEmptyMap(t *testing.T) {
- nb := newDecoder(nil, nil);
- nb.Map();
- assertResult(t, nb.Data(), map[string]interface{}{});
+ nb := newDecoder(nil, nil)
+ nb.Map()
+ assertResult(t, nb.Data(), map[string]interface{}{})
}
func TestDecodeFlushElem(t *testing.T) {
- testVec := new(vector.Vector).Resize(2, 2);
- nb := newDecoder(testVec, 1);
- nb.Float64(3.14159);
- nb.Flush();
- assertResult(t, testVec.Data(), []interface{}{nil, float64(3.14159)});
+ testVec := new(vector.Vector).Resize(2, 2)
+ nb := newDecoder(testVec, 1)
+ nb.Float64(3.14159)
+ nb.Flush()
+ assertResult(t, testVec.Data(), []interface{}{nil, float64(3.14159)})
}
func TestDecodeFlushKey(t *testing.T) {
- testMap := make(map[string]interface{});
- nb := newDecoder(testMap, "key");
- nb.Float64(3.14159);
- nb.Flush();
- assertResult(t, testMap, map[string]interface{}{"key": float64(3.14159)});
+ testMap := make(map[string]interface{})
+ nb := newDecoder(testMap, "key")
+ nb.Float64(3.14159)
+ nb.Flush()
+ assertResult(t, testMap, map[string]interface{}{"key": float64(3.14159)})
}
// Elem() and Key() are hard to test in isolation because all they do
// Array(), String(), and Flush().
func TestDecodeElem(t *testing.T) {
- nb := newDecoder(nil, nil);
- nb.Array();
- var b Builder = nb.Elem(0);
- b.String("0");
- b.Flush();
- assertResult(t, nb.Data(), []interface{}{"0"});
+ nb := newDecoder(nil, nil)
+ nb.Array()
+ var b Builder = nb.Elem(0)
+ b.String("0")
+ b.Flush()
+ assertResult(t, nb.Data(), []interface{}{"0"})
}
func TestDecodeKey(t *testing.T) {
- nb := newDecoder(nil, nil);
- nb.Map();
- var b Builder = nb.Key("a");
- b.String("0");
- b.Flush();
- assertResult(t, nb.Data(), map[string]interface{}{"a": "0"});
+ nb := newDecoder(nil, nil)
+ nb.Map()
+ var b Builder = nb.Key("a")
+ b.String("0")
+ b.Flush()
+ assertResult(t, nb.Data(), map[string]interface{}{"a": "0"})
}
func assertResult(t *testing.T, results, expected interface{}) {
}
type decodeTest struct {
- s string;
- r interface{};
+ s string
+ r interface{}
}
var tests = []decodeTest{
// ParseError aggregates information about a JSON parse error. It is
// compatible with the os.Error interface.
type ParseError struct {
- Index int; // A byte index in JSON string where the error occurred
- Token string; // An offending token
+ Index int // A byte index in JSON string where the error occurred
+ Token string // An offending token
}
// Produce a string representation of this ParseError.
package json
import (
- "bytes";
- "strconv";
- "utf8";
+ "bytes"
+ "strconv"
+ "utf8"
)
// Strings
// Have also seen \' and embedded newlines.
func _UnHex(p string, r, l int) (v int, ok bool) {
- v = 0;
+ v = 0
for i := r; i < l; i++ {
if i >= len(p) {
return 0, false
}
- v *= 16;
+ v *= 16
switch {
case '0' <= p[i] && p[i] <= '9':
v += int(p[i] - '0')
return 0, false
}
}
- return v, true;
+ return v, true
}
func _ToHex(b []byte, rune int) {
- const hexDigits = "0123456789abcdef";
- b[0] = hexDigits[rune>>12&0xf];
- b[1] = hexDigits[rune>>8&0xf];
- b[2] = hexDigits[rune>>4&0xf];
- b[3] = hexDigits[rune&0xf];
+ const hexDigits = "0123456789abcdef"
+ b[0] = hexDigits[rune>>12&0xf]
+ b[1] = hexDigits[rune>>8&0xf]
+ b[2] = hexDigits[rune>>4&0xf]
+ b[3] = hexDigits[rune&0xf]
}
// Unquote unquotes the JSON-quoted string s,
if len(s) < 2 || s[0] != '"' || s[len(s)-1] != '"' {
return
}
- b := make([]byte, len(s));
- w := 0;
+ b := make([]byte, len(s))
+ w := 0
for r := 1; r < len(s)-1; {
switch {
case s[r] == '\\':
- r++;
+ r++
if r >= len(s)-1 {
return
}
default:
return
case '"', '\\', '/', '\'':
- b[w] = s[r];
- r++;
- w++;
+ b[w] = s[r]
+ r++
+ w++
case 'b':
- b[w] = '\b';
- r++;
- w++;
+ b[w] = '\b'
+ r++
+ w++
case 'f':
- b[w] = '\f';
- r++;
- w++;
+ b[w] = '\f'
+ r++
+ w++
case 'n':
- b[w] = '\n';
- r++;
- w++;
+ b[w] = '\n'
+ r++
+ w++
case 'r':
- b[w] = '\r';
- r++;
- w++;
+ b[w] = '\r'
+ r++
+ w++
case 't':
- b[w] = '\t';
- r++;
- w++;
+ b[w] = '\t'
+ r++
+ w++
case 'u':
- r++;
- rune, ok := _UnHex(s, r, r+4);
+ r++
+ rune, ok := _UnHex(s, r, r+4)
if !ok {
return
}
- r += 4;
- w += utf8.EncodeRune(rune, b[w:]);
+ r += 4
+ w += utf8.EncodeRune(rune, b[w:])
}
// Control characters are invalid, but we've seen raw \n.
case s[r] < ' ' && s[r] != '\n':
if s[r] == '\n' {
- b[w] = '\n';
- r++;
- w++;
- break;
+ b[w] = '\n'
+ r++
+ w++
+ break
}
- return;
+ return
// ASCII
case s[r] < utf8.RuneSelf:
- b[w] = s[r];
- r++;
- w++;
+ b[w] = s[r]
+ r++
+ w++
// Coerce to well-formed UTF-8.
default:
- rune, size := utf8.DecodeRuneInString(s[r:]);
- r += size;
- w += utf8.EncodeRune(rune, b[w:]);
+ rune, size := utf8.DecodeRuneInString(s[r:])
+ r += size
+ w += utf8.EncodeRune(rune, b[w:])
}
}
- return string(b[0:w]), true;
+ return string(b[0:w]), true
}
// Quote quotes the raw string s using JSON syntax,
// so that Unquote(Quote(s)) = s, true.
func Quote(s string) string {
- chr := make([]byte, 6);
- chr0 := chr[0:1];
- b := new(bytes.Buffer);
- chr[0] = '"';
- b.Write(chr0);
+ chr := make([]byte, 6)
+ chr0 := chr[0:1]
+ b := new(bytes.Buffer)
+ chr[0] = '"'
+ b.Write(chr0)
for _, rune := range s {
switch {
case rune == '"' || rune == '\\':
- chr[0] = '\\';
- chr[1] = byte(rune);
- b.Write(chr[0:2]);
+ chr[0] = '\\'
+ chr[1] = byte(rune)
+ b.Write(chr[0:2])
case rune == '\b':
- chr[0] = '\\';
- chr[1] = 'b';
- b.Write(chr[0:2]);
+ chr[0] = '\\'
+ chr[1] = 'b'
+ b.Write(chr[0:2])
case rune == '\f':
- chr[0] = '\\';
- chr[1] = 'f';
- b.Write(chr[0:2]);
+ chr[0] = '\\'
+ chr[1] = 'f'
+ b.Write(chr[0:2])
case rune == '\n':
- chr[0] = '\\';
- chr[1] = 'n';
- b.Write(chr[0:2]);
+ chr[0] = '\\'
+ chr[1] = 'n'
+ b.Write(chr[0:2])
case rune == '\r':
- chr[0] = '\\';
- chr[1] = 'r';
- b.Write(chr[0:2]);
+ chr[0] = '\\'
+ chr[1] = 'r'
+ b.Write(chr[0:2])
case rune == '\t':
- chr[0] = '\\';
- chr[1] = 't';
- b.Write(chr[0:2]);
+ chr[0] = '\\'
+ chr[1] = 't'
+ b.Write(chr[0:2])
case 0x20 <= rune && rune < utf8.RuneSelf:
- chr[0] = byte(rune);
- b.Write(chr0);
+ chr[0] = byte(rune)
+ b.Write(chr0)
default:
- chr[0] = '\\';
- chr[1] = 'u';
- _ToHex(chr[2:6], rune);
- b.Write(chr);
+ chr[0] = '\\'
+ chr[1] = 'u'
+ _ToHex(chr[2:6], rune)
+ b.Write(chr)
}
}
- chr[0] = '"';
- b.Write(chr0);
- return b.String();
+ chr[0] = '"'
+ b.Write(chr0)
+ return b.String()
}
// _Lexer
type _Lexer struct {
- s string;
- i int;
- kind int;
- token string;
+ s string
+ i int
+ kind int
+ token string
}
func punct(c byte) bool {
return c == '"' || c == '[' || c == ']' || c == ':' || c == '{' || c == '}' || c == ','
}
-func white(c byte) bool { return c == ' ' || c == '\t' || c == '\r' || c == '\n' || c == '\v' }
+func white(c byte) bool { return c == ' ' || c == '\t' || c == '\r' || c == '\n' || c == '\v' }
func skipwhite(p string, i int) int {
for i < len(p) && white(p[i]) {
i++
}
- return i;
+ return i
}
func skiptoken(p string, i int) int {
for i < len(p) && !punct(p[i]) && !white(p[i]) {
i++
}
- return i;
+ return i
}
func skipstring(p string, i int) int {
if i >= len(p) {
return i
}
- return i + 1;
+ return i + 1
}
func (t *_Lexer) Next() {
- i, s := t.i, t.s;
- i = skipwhite(s, i);
+ i, s := t.i, t.s
+ i = skipwhite(s, i)
if i >= len(s) {
- t.kind = 0;
- t.token = "";
- t.i = len(s);
- return;
+ t.kind = 0
+ t.token = ""
+ t.i = len(s)
+ return
}
- c := s[i];
+ c := s[i]
switch {
case c == '-' || '0' <= c && c <= '9':
- j := skiptoken(s, i);
- t.kind = '1';
- t.token = s[i:j];
- i = j;
+ j := skiptoken(s, i)
+ t.kind = '1'
+ t.token = s[i:j]
+ i = j
case 'a' <= c && c <= 'z' || 'A' <= c && c <= 'Z':
- j := skiptoken(s, i);
- t.kind = 'a';
- t.token = s[i:j];
- i = j;
+ j := skiptoken(s, i)
+ t.kind = 'a'
+ t.token = s[i:j]
+ i = j
case c == '"':
- j := skipstring(s, i);
- t.kind = '"';
- t.token = s[i:j];
- i = j;
+ j := skipstring(s, i)
+ t.kind = '"'
+ t.token = s[i:j]
+ i = j
case c == '[', c == ']', c == ':', c == '{', c == '}', c == ',':
- t.kind = int(c);
- t.token = s[i : i+1];
- i++;
+ t.kind = int(c)
+ t.token = s[i : i+1]
+ i++
default:
- t.kind = '?';
- t.token = s[i : i+1];
+ t.kind = '?'
+ t.token = s[i : i+1]
}
- t.i = i;
+ t.i = i
}
// eventual representation returned by the parser.
type Builder interface {
// Set value
- Int64(i int64);
- Uint64(i uint64);
- Float64(f float64);
- String(s string);
- Bool(b bool);
- Null();
- Array();
- Map();
+ Int64(i int64)
+ Uint64(i uint64)
+ Float64(f float64)
+ String(s string)
+ Bool(b bool)
+ Null()
+ Array()
+ Map()
// Create sub-Builders
- Elem(i int) Builder;
- Key(s string) Builder;
+ Elem(i int) Builder
+ Key(s string) Builder
// Flush changes to parent Builder if necessary.
- Flush();
+ Flush()
}
func parse(lex *_Lexer, build Builder) bool {
- ok := false;
+ ok := false
Switch:
switch lex.kind {
case 0:
case '1':
// If the number is exactly an integer, use that.
if i, err := strconv.Atoi64(lex.token); err == nil {
- build.Int64(i);
- ok = true;
+ build.Int64(i)
+ ok = true
} else if i, err := strconv.Atoui64(lex.token); err == nil {
- build.Uint64(i);
- ok = true;
+ build.Uint64(i)
+ ok = true
} else
// Fall back to floating point.
if f, err := strconv.Atof64(lex.token); err == nil {
- build.Float64(f);
- ok = true;
+ build.Float64(f)
+ ok = true
}
case 'a':
switch lex.token {
case "true":
- build.Bool(true);
- ok = true;
+ build.Bool(true)
+ ok = true
case "false":
- build.Bool(false);
- ok = true;
+ build.Bool(false)
+ ok = true
case "null":
- build.Null();
- ok = true;
+ build.Null()
+ ok = true
}
case '"':
if str, ok1 := Unquote(lex.token); ok1 {
- build.String(str);
- ok = true;
+ build.String(str)
+ ok = true
}
case '[':
// array
- build.Array();
- lex.Next();
- n := 0;
+ build.Array()
+ lex.Next()
+ n := 0
for lex.kind != ']' {
if n > 0 {
if lex.kind != ',' {
break Switch
}
- lex.Next();
+ lex.Next()
}
if !parse(lex, build.Elem(n)) {
break Switch
}
- n++;
+ n++
}
- ok = true;
+ ok = true
case '{':
// map
- lex.Next();
- build.Map();
- n := 0;
+ lex.Next()
+ build.Map()
+ n := 0
for lex.kind != '}' {
if n > 0 {
if lex.kind != ',' {
break Switch
}
- lex.Next();
+ lex.Next()
}
if lex.kind != '"' {
break Switch
}
- key, ok := Unquote(lex.token);
+ key, ok := Unquote(lex.token)
if !ok {
break Switch
}
- lex.Next();
+ lex.Next()
if lex.kind != ':' {
break Switch
}
- lex.Next();
+ lex.Next()
if !parse(lex, build.Key(key)) {
break Switch
}
- n++;
+ n++
}
- ok = true;
+ ok = true
}
if ok {
lex.Next()
}
- build.Flush();
- return ok;
+ build.Flush()
+ return ok
}
// Parse parses the JSON syntax string s and makes calls to
// to the byte index in s where a syntax error occurred,
// and errtok set to the offending token.
func Parse(s string, builder Builder) (ok bool, errindx int, errtok string) {
- lex := new(_Lexer);
- lex.s = s;
- lex.Next();
+ lex := new(_Lexer)
+ lex.s = s
+ lex.Next()
if parse(lex, builder) {
- if lex.kind == 0 { // EOF
+ if lex.kind == 0 { // EOF
return true, 0, ""
}
}
- return false, lex.i, lex.token;
+ return false, lex.i, lex.token
}
package json
import (
- "fmt";
- "io";
- "os";
- "reflect";
- "strings";
+ "fmt"
+ "io"
+ "os"
+ "reflect"
+ "strings"
)
type structBuilder struct {
- val reflect.Value;
+ val reflect.Value
// if map_ != nil, write val to map_[key] on each change
- map_ *reflect.MapValue;
- key reflect.Value;
+ map_ *reflect.MapValue
+ key reflect.Value
}
var nobuilder *structBuilder
case *reflect.FloatValue, *reflect.Float32Value, *reflect.Float64Value:
return true
}
- return false;
+ return false
}
func setfloat(v reflect.Value, f float64) {
if b == nil {
return
}
- v := b.val;
+ v := b.val
if isfloat(v) {
setfloat(v, float64(i))
} else {
if b == nil {
return
}
- v := b.val;
+ v := b.val
if isfloat(v) {
setfloat(v, float64(i))
} else {
if b == nil {
return
}
- v := b.val;
+ v := b.val
if isfloat(v) {
setfloat(v, f)
} else {
}
}
-func (b *structBuilder) Null() {}
+func (b *structBuilder) Null() {}
func (b *structBuilder) String(s string) {
if b == nil {
}
case *reflect.SliceValue:
if i >= v.Cap() {
- n := v.Cap();
+ n := v.Cap()
if n < 8 {
n = 8
}
for n <= i {
n *= 2
}
- nv := reflect.MakeSlice(v.Type().(*reflect.SliceType), v.Len(), n);
- reflect.ArrayCopy(nv, v);
- v.Set(nv);
+ nv := reflect.MakeSlice(v.Type().(*reflect.SliceType), v.Len(), n)
+ reflect.ArrayCopy(nv, v)
+ v.Set(nv)
}
if v.Len() <= i && i < v.Cap() {
v.SetLen(i + 1)
return &structBuilder{val: v.Elem(i)}
}
}
- return nobuilder;
+ return nobuilder
}
func (b *structBuilder) Map() {
}
if v, ok := b.val.(*reflect.PtrValue); ok && v.IsNil() {
if v.IsNil() {
- v.PointTo(reflect.MakeZero(v.Type().(*reflect.PtrType).Elem()));
- b.Flush();
+ v.PointTo(reflect.MakeZero(v.Type().(*reflect.PtrType).Elem()))
+ b.Flush()
}
- b.map_ = nil;
- b.val = v.Elem();
+ b.map_ = nil
+ b.val = v.Elem()
}
if v, ok := b.val.(*reflect.MapValue); ok && v.IsNil() {
v.Set(reflect.MakeMap(v.Type().(*reflect.MapType)))
}
switch v := reflect.Indirect(b.val).(type) {
case *reflect.StructValue:
- t := v.Type().(*reflect.StructType);
+ t := v.Type().(*reflect.StructType)
// Case-insensitive field lookup.
- k = strings.ToLower(k);
+ k = strings.ToLower(k)
for i := 0; i < t.NumField(); i++ {
if strings.ToLower(t.Field(i).Name) == k {
return &structBuilder{val: v.Field(i)}
}
}
case *reflect.MapValue:
- t := v.Type().(*reflect.MapType);
+ t := v.Type().(*reflect.MapType)
if t.Key() != reflect.Typeof(k) {
break
}
- key := reflect.NewValue(k);
- elem := v.Elem(key);
+ key := reflect.NewValue(k)
+ elem := v.Elem(key)
if elem == nil {
- v.SetElem(key, reflect.MakeZero(t.Elem()));
- elem = v.Elem(key);
+ v.SetElem(key, reflect.MakeZero(t.Elem()))
+ elem = v.Elem(key)
}
- return &structBuilder{val: elem, map_: v, key: key};
+ return &structBuilder{val: elem, map_: v, key: key}
}
- return nobuilder;
+ return nobuilder
}
// Unmarshal parses the JSON syntax string s and fills in
// On a syntax error, it returns with ok set to false and errtok
// set to the offending token.
func Unmarshal(s string, val interface{}) (ok bool, errtok string) {
- v := reflect.NewValue(val);
- var b *structBuilder;
+ v := reflect.NewValue(val)
+ var b *structBuilder
// If val is a pointer to a slice, we append to the slice.
if ptr, ok := v.(*reflect.PtrValue); ok {
b = &structBuilder{val: v}
}
- ok, _, errtok = Parse(s, b);
+ ok, _, errtok = Parse(s, b)
if !ok {
return false, errtok
}
- return true, "";
+ return true, ""
}
type MarshalError struct {
- T reflect.Type;
+ T reflect.Type
}
func (e *MarshalError) String() string {
return "json cannot encode value of type " + e.T.String()
}
func writeArrayOrSlice(w io.Writer, val reflect.ArrayOrSliceValue) os.Error {
- fmt.Fprint(w, "[");
+ fmt.Fprint(w, "[")
for i := 0; i < val.Len(); i++ {
if err := writeValue(w, val.Elem(i)); err != nil {
}
}
- fmt.Fprint(w, "]");
- return nil;
+ fmt.Fprint(w, "]")
+ return nil
}
func writeMap(w io.Writer, val *reflect.MapValue) os.Error {
- key := val.Type().(*reflect.MapType).Key();
+ key := val.Type().(*reflect.MapType).Key()
if _, ok := key.(*reflect.StringType); !ok {
return &MarshalError{val.Type()}
}
- keys := val.Keys();
- fmt.Fprint(w, "{");
+ keys := val.Keys()
+ fmt.Fprint(w, "{")
for i := 0; i < len(keys); i++ {
- fmt.Fprintf(w, "%q:", keys[i].(*reflect.StringValue).Get());
+ fmt.Fprintf(w, "%q:", keys[i].(*reflect.StringValue).Get())
if err := writeValue(w, val.Elem(keys[i])); err != nil {
return err
}
}
- fmt.Fprint(w, "}");
- return nil;
+ fmt.Fprint(w, "}")
+ return nil
}
func writeStruct(w io.Writer, val *reflect.StructValue) os.Error {
- fmt.Fprint(w, "{");
+ fmt.Fprint(w, "{")
- typ := val.Type().(*reflect.StructType);
+ typ := val.Type().(*reflect.StructType)
for i := 0; i < val.NumField(); i++ {
- fieldValue := val.Field(i);
- fmt.Fprintf(w, "%q:", typ.Field(i).Name);
- writeValue(w, fieldValue);
+ fieldValue := val.Field(i)
+ fmt.Fprintf(w, "%q:", typ.Field(i).Name)
+ writeValue(w, fieldValue)
if i < val.NumField()-1 {
fmt.Fprint(w, ",")
}
}
- fmt.Fprint(w, "}");
- return nil;
+ fmt.Fprint(w, "}")
+ return nil
}
func writeValue(w io.Writer, val reflect.Value) (err os.Error) {
if val == nil {
- fmt.Fprint(w, "null");
- return;
+ fmt.Fprint(w, "null")
+ return
}
switch v := val.(type) {
err = &MarshalError{val.Type()}
}
default:
- value := val.(reflect.Value);
- fmt.Fprint(w, value.Interface());
+ value := val.(reflect.Value)
+ fmt.Fprint(w, value.Interface())
}
- return;
+ return
}
func Marshal(w io.Writer, val interface{}) os.Error {
package json
import (
- "bytes";
- "reflect";
- "strconv";
- "testing";
+ "bytes"
+ "reflect"
+ "strconv"
+ "testing"
)
type myStruct struct {
- T bool;
- F bool;
- S string;
- I8 int8;
- I16 int16;
- I32 int32;
- I64 int64;
- U8 uint8;
- U16 uint16;
- U32 uint32;
- U64 uint64;
- I int;
- U uint;
- Fl float;
- Fl32 float32;
- Fl64 float64;
- A []string;
- My *myStruct;
- Map map[string][]int;
- MapStruct map[string]myStruct;
- MapPtrStruct map[string]*myStruct;
+ T bool
+ F bool
+ S string
+ I8 int8
+ I16 int16
+ I32 int32
+ I64 int64
+ U8 uint8
+ U16 uint16
+ U32 uint32
+ U64 uint64
+ I int
+ U uint
+ Fl float
+ Fl32 float32
+ Fl64 float64
+ A []string
+ My *myStruct
+ Map map[string][]int
+ MapStruct map[string]myStruct
+ MapPtrStruct map[string]*myStruct
}
const encoded = `{"t":true,"f":false,"s":"abc","i8":1,"i16":2,"i32":3,"i64":4,` +
const whiteSpaceEncoded = " \t{\n\"s\"\r:\"string\"\v}"
func TestUnmarshalWhitespace(t *testing.T) {
- var m myStruct;
- ok, errtok := Unmarshal(whiteSpaceEncoded, &m);
+ var m myStruct
+ ok, errtok := Unmarshal(whiteSpaceEncoded, &m)
if !ok {
t.Fatalf("Unmarshal failed near %s", errtok)
}
- check(t, m.S == "string", "string", m.S);
+ check(t, m.S == "string", "string", m.S)
}
func TestUnmarshal(t *testing.T) {
- var m myStruct;
- m.F = true;
- ok, errtok := Unmarshal(encoded, &m);
+ var m myStruct
+ m.F = true
+ ok, errtok := Unmarshal(encoded, &m)
if !ok {
t.Fatalf("Unmarshal failed near %s", errtok)
}
- check(t, m.T == true, "t", m.T);
- check(t, m.F == false, "f", m.F);
- check(t, m.S == "abc", "s", m.S);
- check(t, m.I8 == 1, "i8", m.I8);
- check(t, m.I16 == 2, "i16", m.I16);
- check(t, m.I32 == 3, "i32", m.I32);
- check(t, m.I64 == 4, "i64", m.I64);
- check(t, m.U8 == 5, "u8", m.U8);
- check(t, m.U16 == 6, "u16", m.U16);
- check(t, m.U32 == 7, "u32", m.U32);
- check(t, m.U64 == 8, "u64", m.U64);
- check(t, m.I == -9, "i", m.I);
- check(t, m.U == 10, "u", m.U);
- check(t, m.Fl == 11.5, "fl", m.Fl);
- check(t, m.Fl32 == 12.25, "fl32", m.Fl32);
- check(t, m.Fl64 == 13.75, "fl64", m.Fl64);
- check(t, m.A != nil, "a", m.A);
+ check(t, m.T == true, "t", m.T)
+ check(t, m.F == false, "f", m.F)
+ check(t, m.S == "abc", "s", m.S)
+ check(t, m.I8 == 1, "i8", m.I8)
+ check(t, m.I16 == 2, "i16", m.I16)
+ check(t, m.I32 == 3, "i32", m.I32)
+ check(t, m.I64 == 4, "i64", m.I64)
+ check(t, m.U8 == 5, "u8", m.U8)
+ check(t, m.U16 == 6, "u16", m.U16)
+ check(t, m.U32 == 7, "u32", m.U32)
+ check(t, m.U64 == 8, "u64", m.U64)
+ check(t, m.I == -9, "i", m.I)
+ check(t, m.U == 10, "u", m.U)
+ check(t, m.Fl == 11.5, "fl", m.Fl)
+ check(t, m.Fl32 == 12.25, "fl32", m.Fl32)
+ check(t, m.Fl64 == 13.75, "fl64", m.Fl64)
+ check(t, m.A != nil, "a", m.A)
if m.A != nil {
- check(t, m.A[0] == "x", "a[0]", m.A[0]);
- check(t, m.A[1] == "y", "a[1]", m.A[1]);
- check(t, m.A[2] == "z", "a[2]", m.A[2]);
+ check(t, m.A[0] == "x", "a[0]", m.A[0])
+ check(t, m.A[1] == "y", "a[1]", m.A[1])
+ check(t, m.A[2] == "z", "a[2]", m.A[2])
}
- check(t, m.My != nil, "my", m.My);
+ check(t, m.My != nil, "my", m.My)
if m.My != nil {
check(t, m.My.S == "subguy", "my.s", m.My.S)
}
- check(t, reflect.DeepEqual(m.Map, decodedMap), "map", m.Map);
- check(t, reflect.DeepEqual(m.MapStruct, decodedMapStruct), "mapstruct", m.MapStruct);
- check(t, reflect.DeepEqual(m.MapPtrStruct, decodedMapPtrStruct), "mapptrstruct", m.MapPtrStruct);
+ check(t, reflect.DeepEqual(m.Map, decodedMap), "map", m.Map)
+ check(t, reflect.DeepEqual(m.MapStruct, decodedMapStruct), "mapstruct", m.MapStruct)
+ check(t, reflect.DeepEqual(m.MapPtrStruct, decodedMapPtrStruct), "mapptrstruct", m.MapPtrStruct)
}
type Issue147Text struct {
- Text string;
+ Text string
}
type Issue147 struct {
- Test []Issue147Text;
+ Test []Issue147Text
}
const issue147Input = `{"test": [{"text":"0"},{"text":"1"},{"text":"2"},
{"text":"27"},{"text":"28"},{"text":"29"}]}`
func TestIssue147(t *testing.T) {
- var timeline Issue147;
- Unmarshal(issue147Input, &timeline);
+ var timeline Issue147
+ Unmarshal(issue147Input, &timeline)
if len(timeline.Test) != 30 {
t.Errorf("wrong length: got %d want 30", len(timeline.Test))
}
type Issue114 struct {
- Text string;
+ Text string
}
const issue114Input = `[{"text" : "0"}, {"text" : "1"}, {"text" : "2"}, {"text" : "3"}]`
func TestIssue114(t *testing.T) {
- var items []Issue114;
- Unmarshal(issue114Input, &items);
+ var items []Issue114
+ Unmarshal(issue114Input, &items)
if len(items) != 4 {
t.Errorf("wrong length: got %d want 4", len(items))
}
type marshalTest struct {
- val interface{};
- out string;
+ val interface{}
+ out string
}
var marshalTests = []marshalTest{
marshalTest{struct{ a int }{1}, `{"a":1}`},
marshalTest{struct{ a interface{} }{nil}, `{"a":null}`},
marshalTest{struct {
- a int;
- b string;
+ a int
+ b string
}{1, "hello"},
`{"a":1,"b":"hello"}`,
},
func TestMarshal(t *testing.T) {
for _, tt := range marshalTests {
- var buf bytes.Buffer;
+ var buf bytes.Buffer
- err := Marshal(&buf, tt.val);
+ err := Marshal(&buf, tt.val)
if err != nil {
t.Fatalf("Marshal(%T): %s", tt.val, err)
}
- s := buf.String();
+ s := buf.String()
if s != tt.out {
t.Errorf("Marshal(%T) = %q, want %q\n", tt.val, tt.out, s)
}
}
type marshalErrorTest struct {
- val interface{};
- error string;
+ val interface{}
+ error string
}
type MTE string
func TestMarshalError(t *testing.T) {
for _, tt := range marshalErrorTests {
- var buf bytes.Buffer;
+ var buf bytes.Buffer
- err := Marshal(&buf, tt.val);
+ err := Marshal(&buf, tt.val)
if err == nil {
t.Fatalf("Marshal(%T): no error, want error %s", tt.val, tt.error)
package log
import (
- "fmt";
- "io";
- "runtime";
- "os";
- "time";
+ "fmt"
+ "io"
+ "runtime"
+ "os"
+ "time"
)
// These flags define the properties of the Logger and the output they produce.
const (
// Flags
- Lok = iota;
- Lexit; // terminate execution when written
- Lcrash; // crash (panic) when written
+ Lok = iota
+ Lexit // terminate execution when written
+ Lcrash // crash (panic) when written
// Bits or'ed together to control what's printed. There is no control over the
// order they appear (the order listed here) or the format they present (as
// described in the comments). A colon appears after these items:
// 2009/0123 01:23:23.123123 /a/b/c/d.go:23: message
- Ldate = 1 << iota; // the date: 2009/0123
- Ltime; // the time: 01:23:23
- Lmicroseconds; // microsecond resolution: 01:23:23.123123. assumes Ltime.
- Llongfile; // full file name and line number: /a/b/c/d.go:23
- Lshortfile; // final file name element and line number: d.go:23. overrides Llongfile
- lAllBits = Ldate | Ltime | Lmicroseconds | Llongfile | Lshortfile;
+ Ldate = 1 << iota // the date: 2009/0123
+ Ltime // the time: 01:23:23
+ Lmicroseconds // microsecond resolution: 01:23:23.123123. assumes Ltime.
+ Llongfile // full file name and line number: /a/b/c/d.go:23
+ Lshortfile // final file name element and line number: d.go:23. overrides Llongfile
+ lAllBits = Ldate | Ltime | Lmicroseconds | Llongfile | Lshortfile
)
// Logger represents an active logging object.
type Logger struct {
- out0 io.Writer; // first destination for output
- out1 io.Writer; // second destination for output; may be nil
- prefix string; // prefix to write at beginning of each line
- flag int; // properties
+ out0 io.Writer // first destination for output
+ out1 io.Writer // second destination for output; may be nil
+ prefix string // prefix to write at beginning of each line
+ flag int // properties
}
// New creates a new Logger. The out0 and out1 variables set the
}
var (
- stdout = New(os.Stdout, nil, "", Lok|Ldate|Ltime);
- stderr = New(os.Stderr, nil, "", Lok|Ldate|Ltime);
- exit = New(os.Stderr, nil, "", Lexit|Ldate|Ltime);
- crash = New(os.Stderr, nil, "", Lcrash|Ldate|Ltime);
+ stdout = New(os.Stdout, nil, "", Lok|Ldate|Ltime)
+ stderr = New(os.Stderr, nil, "", Lok|Ldate|Ltime)
+ exit = New(os.Stderr, nil, "", Lexit|Ldate|Ltime)
+ crash = New(os.Stderr, nil, "", Lcrash|Ldate|Ltime)
)
-var shortnames = make(map[string]string) // cache of short names to avoid allocation.
+var shortnames = make(map[string]string) // cache of short names to avoid allocation.
// Cheap integer to fixed-width decimal ASCII. Use a negative width to avoid zero-padding
func itoa(i int, wid int) string {
- var u uint = uint(i);
+ var u uint = uint(i)
if u == 0 && wid <= 1 {
return "0"
}
// Assemble decimal in reverse order.
- var b [32]byte;
- bp := len(b);
+ var b [32]byte
+ bp := len(b)
for ; u > 0 || wid > 0; u /= 10 {
- bp--;
- wid--;
- b[bp] = byte(u%10) + '0';
+ bp--
+ wid--
+ b[bp] = byte(u%10) + '0'
}
- return string(b[bp:]);
+ return string(b[bp:])
}
func (l *Logger) formatHeader(ns int64, calldepth int) string {
- h := l.prefix;
+ h := l.prefix
if l.flag&(Ldate|Ltime|Lmicroseconds) != 0 {
- t := time.SecondsToLocalTime(ns / 1e9);
+ t := time.SecondsToLocalTime(ns / 1e9)
if l.flag&(Ldate) != 0 {
h += itoa(int(t.Year), 4) + "/" + itoa(t.Month, 2) + "/" + itoa(t.Day, 2) + " "
}
if l.flag&(Ltime|Lmicroseconds) != 0 {
- h += itoa(t.Hour, 2) + ":" + itoa(t.Minute, 2) + ":" + itoa(t.Second, 2);
+ h += itoa(t.Hour, 2) + ":" + itoa(t.Minute, 2) + ":" + itoa(t.Second, 2)
if l.flag&Lmicroseconds != 0 {
h += "." + itoa(int(ns%1e9)/1e3, 6)
}
- h += " ";
+ h += " "
}
}
if l.flag&(Lshortfile|Llongfile) != 0 {
- _, file, line, ok := runtime.Caller(calldepth);
+ _, file, line, ok := runtime.Caller(calldepth)
if ok {
if l.flag&Lshortfile != 0 {
- short, ok := shortnames[file];
+ short, ok := shortnames[file]
if !ok {
- short = file;
+ short = file
for i := len(file) - 1; i > 0; i-- {
if file[i] == '/' {
- short = file[i+1:];
- break;
+ short = file[i+1:]
+ break
}
}
- shortnames[file] = short;
+ shortnames[file] = short
}
- file = short;
+ file = short
}
} else {
- file = "???";
- line = 0;
+ file = "???"
+ line = 0
}
- h += file + ":" + itoa(line, -1) + ": ";
+ h += file + ":" + itoa(line, -1) + ": "
}
- return h;
+ return h
}
// Output writes the output for a logging event. The string s contains the text to print after
// the time stamp; calldepth is used to recover the PC. It is provided for generality, although
// at the moment on all pre-defined paths it will be 2.
func (l *Logger) Output(calldepth int, s string) os.Error {
- now := time.Nanoseconds(); // get this early.
- newline := "\n";
+ now := time.Nanoseconds() // get this early.
+ newline := "\n"
if len(s) > 0 && s[len(s)-1] == '\n' {
newline = ""
}
- s = l.formatHeader(now, calldepth+1) + s + newline;
- _, err := io.WriteString(l.out0, s);
+ s = l.formatHeader(now, calldepth+1) + s + newline
+ _, err := io.WriteString(l.out0, s)
if l.out1 != nil {
- _, err1 := io.WriteString(l.out1, s);
+ _, err1 := io.WriteString(l.out1, s)
if err == nil && err1 != nil {
err = err1
}
case Lexit:
os.Exit(1)
}
- return err;
+ return err
}
// Logf is analogous to Printf() for a Logger.
-func (l *Logger) Logf(format string, v ...) { l.Output(2, fmt.Sprintf(format, v)) }
+func (l *Logger) Logf(format string, v ...) { l.Output(2, fmt.Sprintf(format, v)) }
// Log is analogous to Print() for a Logger.
-func (l *Logger) Log(v ...) { l.Output(2, fmt.Sprintln(v)) }
+func (l *Logger) Log(v ...) { l.Output(2, fmt.Sprintln(v)) }
// Stdout is a helper function for easy logging to stdout. It is analogous to Print().
-func Stdout(v ...) { stdout.Output(2, fmt.Sprint(v)) }
+func Stdout(v ...) { stdout.Output(2, fmt.Sprint(v)) }
// Stderr is a helper function for easy logging to stderr. It is analogous to Fprint(os.Stderr).
-func Stderr(v ...) { stderr.Output(2, fmt.Sprintln(v)) }
+func Stderr(v ...) { stderr.Output(2, fmt.Sprintln(v)) }
// Stdoutf is a helper functions for easy formatted logging to stdout. It is analogous to Printf().
-func Stdoutf(format string, v ...) { stdout.Output(2, fmt.Sprintf(format, v)) }
+func Stdoutf(format string, v ...) { stdout.Output(2, fmt.Sprintf(format, v)) }
// Stderrf is a helper function for easy formatted logging to stderr. It is analogous to Fprintf(os.Stderr).
-func Stderrf(format string, v ...) { stderr.Output(2, fmt.Sprintf(format, v)) }
+func Stderrf(format string, v ...) { stderr.Output(2, fmt.Sprintf(format, v)) }
// Exit is equivalent to Stderr() followed by a call to os.Exit(1).
-func Exit(v ...) { exit.Output(2, fmt.Sprintln(v)) }
+func Exit(v ...) { exit.Output(2, fmt.Sprintln(v)) }
// Exitf is equivalent to Stderrf() followed by a call to os.Exit(1).
-func Exitf(format string, v ...) { exit.Output(2, fmt.Sprintf(format, v)) }
+func Exitf(format string, v ...) { exit.Output(2, fmt.Sprintf(format, v)) }
// Crash is equivalent to Stderr() followed by a call to panic().
-func Crash(v ...) { crash.Output(2, fmt.Sprintln(v)) }
+func Crash(v ...) { crash.Output(2, fmt.Sprintln(v)) }
// Crashf is equivalent to Stderrf() followed by a call to panic().
-func Crashf(format string, v ...) { crash.Output(2, fmt.Sprintf(format, v)) }
+func Crashf(format string, v ...) { crash.Output(2, fmt.Sprintf(format, v)) }
// These tests are too simple.
import (
- "bufio";
- "os";
- "regexp";
- "testing";
+ "bufio"
+ "os"
+ "regexp"
+ "testing"
)
const (
- Rdate = `[0-9][0-9][0-9][0-9]/[0-9][0-9]/[0-9][0-9]`;
- Rtime = `[0-9][0-9]:[0-9][0-9]:[0-9][0-9]`;
- Rmicroseconds = `\.[0-9][0-9][0-9][0-9][0-9][0-9]`;
- Rline = `[0-9]+:`;
- Rlongfile = `.*/[A-Za-z0-9_\-]+\.go:` + Rline;
- Rshortfile = `[A-Za-z0-9_\-]+\.go:` + Rline;
+ Rdate = `[0-9][0-9][0-9][0-9]/[0-9][0-9]/[0-9][0-9]`
+ Rtime = `[0-9][0-9]:[0-9][0-9]:[0-9][0-9]`
+ Rmicroseconds = `\.[0-9][0-9][0-9][0-9][0-9][0-9]`
+ Rline = `[0-9]+:`
+ Rlongfile = `.*/[A-Za-z0-9_\-]+\.go:` + Rline
+ Rshortfile = `[A-Za-z0-9_\-]+\.go:` + Rline
)
type tester struct {
- flag int;
- prefix string;
- pattern string; // regexp that log output must match; we add ^ and expected_text$ always
+ flag int
+ prefix string
+ pattern string // regexp that log output must match; we add ^ and expected_text$ always
}
var tests = []tester{
tester{Lok | Ldate, "", Rdate + " "},
tester{Lok | Ltime, "", Rtime + " "},
tester{Lok | Ltime | Lmicroseconds, "", Rtime + Rmicroseconds + " "},
- tester{Lok | Lmicroseconds, "", Rtime + Rmicroseconds + " "}, // microsec implies time
+ tester{Lok | Lmicroseconds, "", Rtime + Rmicroseconds + " "}, // microsec implies time
tester{Lok | Llongfile, "", Rlongfile + " "},
tester{Lok | Lshortfile, "", Rshortfile + " "},
- tester{Lok | Llongfile | Lshortfile, "", Rshortfile + " "}, // shortfile overrides longfile
+ tester{Lok | Llongfile | Lshortfile, "", Rshortfile + " "}, // shortfile overrides longfile
// everything at once:
tester{Lok | Ldate | Ltime | Lmicroseconds | Llongfile, "XXX", "XXX" + Rdate + " " + Rtime + Rmicroseconds + " " + Rlongfile + " "},
tester{Lok | Ldate | Ltime | Lmicroseconds | Lshortfile, "XXX", "XXX" + Rdate + " " + Rtime + Rmicroseconds + " " + Rshortfile + " "},
// Test using Log("hello", 23, "world") or using Logf("hello %d world", 23)
func testLog(t *testing.T, flag int, prefix string, pattern string, useLogf bool) {
- r, w, err1 := os.Pipe();
+ r, w, err1 := os.Pipe()
if err1 != nil {
t.Fatal("pipe", err1)
}
- defer r.Close();
- defer w.Close();
- buf := bufio.NewReader(r);
- l := New(w, nil, prefix, flag);
+ defer r.Close()
+ defer w.Close()
+ buf := bufio.NewReader(r)
+ l := New(w, nil, prefix, flag)
if useLogf {
l.Logf("hello %d world", 23)
} else {
l.Log("hello", 23, "world")
}
- line, err3 := buf.ReadString('\n');
+ line, err3 := buf.ReadString('\n')
if err3 != nil {
t.Fatal("log error", err3)
}
- line = line[0 : len(line)-1];
- pattern = "^" + pattern + "hello 23 world$";
- matched, err4 := regexp.MatchString(pattern, line);
+ line = line[0 : len(line)-1]
+ pattern = "^" + pattern + "hello 23 world$"
+ matched, err4 := regexp.MatchString(pattern, line)
if err4 != nil {
t.Fatal("pattern did not compile:", err4)
}
func TestAllLog(t *testing.T) {
for _, testcase := range tests {
- testLog(t, testcase.flag, testcase.prefix, testcase.pattern, false);
- testLog(t, testcase.flag, testcase.prefix, testcase.pattern, true);
+ testLog(t, testcase.flag, testcase.prefix, testcase.pattern, false)
+ testLog(t, testcase.flag, testcase.prefix, testcase.pattern, true)
}
}
package malloc
type Stats struct {
- Alloc uint64;
- Sys uint64;
- Stacks uint64;
- InusePages uint64;
- NextGC uint64;
- Lookups uint64;
- Mallocs uint64;
- EnableGC bool;
+ Alloc uint64
+ Sys uint64
+ Stacks uint64
+ InusePages uint64
+ NextGC uint64
+ Lookups uint64
+ Mallocs uint64
+ EnableGC bool
}
func Alloc(uintptr) *byte
package math_test
import (
- "fmt";
- . "math";
- "testing";
+ "fmt"
+ . "math"
+ "testing"
)
var vf = []float64{
}
func tolerance(a, b, e float64) bool {
- d := a - b;
+ d := a - b
if d < 0 {
d = -d
}
if a != 0 {
- e = e * a;
+ e = e * a
if e < 0 {
e = -e
}
}
- return d < e;
+ return d < e
}
-func kindaclose(a, b float64) bool { return tolerance(a, b, 1e-8) }
-func close(a, b float64) bool { return tolerance(a, b, 1e-14) }
-func veryclose(a, b float64) bool { return tolerance(a, b, 4e-16) }
+func kindaclose(a, b float64) bool { return tolerance(a, b, 1e-8) }
+func close(a, b float64) bool { return tolerance(a, b, 1e-14) }
+func veryclose(a, b float64) bool { return tolerance(a, b, 4e-16) }
func TestAsin(t *testing.T) {
for i := 0; i < len(vf); i++ {
func TestLog(t *testing.T) {
for i := 0; i < len(vf); i++ {
- a := Fabs(vf[i]);
+ a := Fabs(vf[i])
if f := Log(a); log[i] != f {
t.Errorf("Log(%g) = %g, want %g\n", a, f, log[i])
}
func TestSqrt(t *testing.T) {
for i := 0; i < len(vf); i++ {
- a := Fabs(vf[i]);
+ a := Fabs(vf[i])
if f := Sqrt(a); !veryclose(sqrt[i], f) {
t.Errorf("Sqrt(%g) = %g, want %g\n", a, f, floor[i])
}
func TestHypot(t *testing.T) {
for i := 0; i < len(vf); i++ {
- a := Fabs(tanh[i] * Sqrt(2));
+ a := Fabs(tanh[i] * Sqrt(2))
if f := Hypot(tanh[i], tanh[i]); !veryclose(a, f) {
t.Errorf("Hypot(%g, %g) = %g, want %g\n", tanh[i], tanh[i], f, a)
}
// Check that math functions of high angle values
// return similar results to low angle values
func TestLargeSin(t *testing.T) {
- large := float64(100000 * Pi);
+ large := float64(100000 * Pi)
for i := 0; i < len(vf); i++ {
- f1 := Sin(vf[i]);
- f2 := Sin(vf[i] + large);
+ f1 := Sin(vf[i])
+ f2 := Sin(vf[i] + large)
if !kindaclose(f1, f2) {
t.Errorf("Sin(%g) = %g, want %g\n", vf[i]+large, f1, f2)
}
}
func TestLargeCos(t *testing.T) {
- large := float64(100000 * Pi);
+ large := float64(100000 * Pi)
for i := 0; i < len(vf); i++ {
- f1 := Cos(vf[i]);
- f2 := Cos(vf[i] + large);
+ f1 := Cos(vf[i])
+ f2 := Cos(vf[i] + large)
if !kindaclose(f1, f2) {
t.Errorf("Cos(%g) = %g, want %g\n", vf[i]+large, f1, f2)
}
func TestLargeTan(t *testing.T) {
- large := float64(100000 * Pi);
+ large := float64(100000 * Pi)
for i := 0; i < len(vf); i++ {
- f1 := Tan(vf[i]);
- f2 := Tan(vf[i] + large);
+ f1 := Tan(vf[i])
+ f2 := Tan(vf[i] + large)
if !kindaclose(f1, f2) {
t.Errorf("Tan(%g) = %g, want %g\n", vf[i]+large, f1, f2)
}
// http://code.google.com/p/go/issues/detail?id=201
type floatTest struct {
- val interface{};
- name string;
- str string;
+ val interface{}
+ name string
+ str string
}
var floatTests = []floatTest{
func TestFloatMinMax(t *testing.T) {
for _, tt := range floatTests {
- s := fmt.Sprint(tt.val);
+ s := fmt.Sprint(tt.val)
if s != tt.str {
t.Errorf("Sprint(%v) = %s, want %s", tt.name, s, tt.str)
}
// Asin returns the arc sine of x.
func Asin(x float64) float64 {
- sign := false;
+ sign := false
if x < 0 {
- x = -x;
- sign = true;
+ x = -x
+ sign = true
}
if x > 1 {
return NaN()
}
- temp := Sqrt(1 - x*x);
+ temp := Sqrt(1 - x*x)
if x > 0.7 {
temp = Pi/2 - Atan(temp/x)
} else {
if sign {
temp = -temp
}
- return temp;
+ return temp
}
// Acos returns the arc cosine of x.
if x > 1 || x < -1 {
return NaN()
}
- return Pi/2 - Asin(x);
+ return Pi/2 - Asin(x)
}
*/
func xatan(arg float64) float64 {
const (
- P4 = .161536412982230228262e2;
- P3 = .26842548195503973794141e3;
- P2 = .11530293515404850115428136e4;
- P1 = .178040631643319697105464587e4;
- P0 = .89678597403663861959987488e3;
- Q4 = .5895697050844462222791e2;
- Q3 = .536265374031215315104235e3;
- Q2 = .16667838148816337184521798e4;
- Q1 = .207933497444540981287275926e4;
- Q0 = .89678597403663861962481162e3;
+ P4 = .161536412982230228262e2
+ P3 = .26842548195503973794141e3
+ P2 = .11530293515404850115428136e4
+ P1 = .178040631643319697105464587e4
+ P0 = .89678597403663861959987488e3
+ Q4 = .5895697050844462222791e2
+ Q3 = .536265374031215315104235e3
+ Q2 = .16667838148816337184521798e4
+ Q1 = .207933497444540981287275926e4
+ Q0 = .89678597403663861962481162e3
)
- sq := arg * arg;
- value := ((((P4*sq+P3)*sq+P2)*sq+P1)*sq + P0);
- value = value / (((((sq+Q4)*sq+Q3)*sq+Q2)*sq+Q1)*sq + Q0);
- return value * arg;
+ sq := arg * arg
+ value := ((((P4*sq+P3)*sq+P2)*sq+P1)*sq + P0)
+ value = value / (((((sq+Q4)*sq+Q3)*sq+Q2)*sq+Q1)*sq + Q0)
+ return value * arg
}
/*
if arg > Sqrt2+1 {
return Pi/2 - xatan(1/arg)
}
- return Pi/4 + xatan((arg-1)/(arg+1));
+ return Pi/4 + xatan((arg-1)/(arg+1))
}
/*
if x > 0 {
return satan(x)
}
- return -satan(-x);
+ return -satan(-x)
}
if y >= 0 {
return Pi / 2
}
- return -Pi / 2;
+ return -Pi / 2
}
- q := Atan(y / x);
+ q := Atan(y / x)
if x < 0 {
if q <= 0 {
return q + Pi
}
- return q - Pi;
+ return q - Pi
}
- return q;
+ return q
}
package math
const (
- uvnan = 0x7FF0000000000001;
- uvinf = 0x7FF0000000000000;
- uvneginf = 0xFFF0000000000000;
- mask = 0x7FF;
- shift = 64 - 11 - 1;
- bias = 1022;
+ uvnan = 0x7FF0000000000001
+ uvinf = 0x7FF0000000000000
+ uvneginf = 0xFFF0000000000000
+ mask = 0x7FF
+ shift = 64 - 11 - 1
+ bias = 1022
)
// Inf returns positive infinity if sign >= 0, negative infinity if sign < 0.
func Inf(sign int) float64 {
- var v uint64;
+ var v uint64
if sign >= 0 {
v = uvinf
} else {
v = uvneginf
}
- return Float64frombits(v);
+ return Float64frombits(v)
}
// NaN returns an IEEE 754 ``not-a-number'' value.
-func NaN() float64 { return Float64frombits(uvnan) }
+func NaN() float64 { return Float64frombits(uvnan) }
// IsNaN returns whether f is an IEEE 754 ``not-a-number'' value.
func IsNaN(f float64) (is bool) {
- x := Float64bits(f);
- return uint32(x>>shift)&mask == mask && x != uvinf && x != uvneginf;
+ x := Float64bits(f)
+ return uint32(x>>shift)&mask == mask && x != uvinf && x != uvneginf
}
// IsInf returns whether f is an infinity, according to sign.
// If sign < 0, IsInf returns whether f is negative infinity.
// If sign == 0, IsInf returns whether f is either infinity.
func IsInf(f float64, sign int) bool {
- x := Float64bits(f);
- return sign >= 0 && x == uvinf || sign <= 0 && x == uvneginf;
+ x := Float64bits(f)
+ return sign >= 0 && x == uvinf || sign <= 0 && x == uvneginf
}
// Frexp breaks f into a normalized fraction
if f == 0 {
return
}
- x := Float64bits(f);
- exp = int((x>>shift)&mask) - bias;
- x &^= mask << shift;
- x |= bias << shift;
- frac = Float64frombits(x);
- return;
+ x := Float64bits(f)
+ exp = int((x>>shift)&mask) - bias
+ x &^= mask << shift
+ x |= bias << shift
+ frac = Float64frombits(x)
+ return
}
// Ldexp is the inverse of Frexp.
// It returns frac × 2<sup>exp</sup>.
func Ldexp(frac float64, exp int) float64 {
- x := Float64bits(frac);
- exp += int(x>>shift) & mask;
+ x := Float64bits(frac)
+ exp += int(x>>shift) & mask
if exp <= 0 {
- return 0 // underflow
+ return 0 // underflow
}
- if exp >= mask { // overflow
+ if exp >= mask { // overflow
if frac < 0 {
return Inf(-1)
}
- return Inf(1);
+ return Inf(1)
}
- x &^= mask << shift;
- x |= uint64(exp) << shift;
- return Float64frombits(x);
+ x &^= mask << shift
+ x |= uint64(exp) << shift
+ return Float64frombits(x)
}
// Modf returns integer and fractional floating-point numbers
func Modf(f float64) (int float64, frac float64) {
if f < 1 {
if f < 0 {
- int, frac = Modf(-f);
- return -int, -frac;
+ int, frac = Modf(-f)
+ return -int, -frac
}
- return 0, f;
+ return 0, f
}
- x := Float64bits(f);
- e := uint(x>>shift)&mask - bias;
+ x := Float64bits(f)
+ e := uint(x>>shift)&mask - bias
// Keep the top 11+e bits, the integer part; clear the rest.
if e < 64-11 {
x &^= 1<<(64-11-e) - 1
}
- int = Float64frombits(x);
- frac = f - int;
- return;
+ int = Float64frombits(x)
+ frac = f - int
+ return
}
// Mathematical constants.
// Reference: http://www.research.att.com/~njas/sequences/Axxxxxx
const (
- E = 2.71828182845904523536028747135266249775724709369995957496696763; // A001113
- Pi = 3.14159265358979323846264338327950288419716939937510582097494459; // A000796
- Phi = 1.61803398874989484820458683436563811772030917980576286213544862; // A001622
-
- Sqrt2 = 1.41421356237309504880168872420969807856967187537694807317667974; // A002193
- SqrtE = 1.64872127070012814684865078781416357165377610071014801157507931; // A019774
- SqrtPi = 1.77245385090551602729816748334114518279754945612238712821380779; // A002161
- SqrtPhi = 1.27201964951406896425242246173749149171560804184009624861664038; // A139339
-
- Ln2 = 0.693147180559945309417232121458176568075500134360255254120680009; // A002162
- Log2E = 1 / Ln2;
- Ln10 = 2.30258509299404568401799145468436420760110148862877297603332790; // A002392
- Log10E = 1 / Ln10;
+ E = 2.71828182845904523536028747135266249775724709369995957496696763 // A001113
+ Pi = 3.14159265358979323846264338327950288419716939937510582097494459 // A000796
+ Phi = 1.61803398874989484820458683436563811772030917980576286213544862 // A001622
+
+ Sqrt2 = 1.41421356237309504880168872420969807856967187537694807317667974 // A002193
+ SqrtE = 1.64872127070012814684865078781416357165377610071014801157507931 // A019774
+ SqrtPi = 1.77245385090551602729816748334114518279754945612238712821380779 // A002161
+ SqrtPhi = 1.27201964951406896425242246173749149171560804184009624861664038 // A139339
+
+ Ln2 = 0.693147180559945309417232121458176568075500134360255254120680009 // A002162
+ Log2E = 1 / Ln2
+ Ln10 = 2.30258509299404568401799145468436420760110148862877297603332790 // A002392
+ Log10E = 1 / Ln10
)
// Floating-point limit values.
// Max is the largest finite value representable by the type.
// Min is the smallest nonzero value representable by the type.
const (
- MaxFloat32 = 3.40282346638528859811704183484516925440e+38; /* 2^127 * (2^24 - 1) / 2^23 */
- MinFloat32 = 1.401298464324817070923729583289916131280e-45; /* 1 / 2^(127 - 1 + 23) */
+ MaxFloat32 = 3.40282346638528859811704183484516925440e+38 /* 2^127 * (2^24 - 1) / 2^23 */
+ MinFloat32 = 1.401298464324817070923729583289916131280e-45 /* 1 / 2^(127 - 1 + 23) */
- MaxFloat64 = 1.797693134862315708145274237317043567981e+308; /* 2^1023 * (2^53 - 1) / 2^52 */
- MinFloat64 = 4.940656458412465441765687928682213723651e-324; /* 1 / 2^(1023 - 1 + 52) */
+ MaxFloat64 = 1.797693134862315708145274237317043567981e+308 /* 2^1023 * (2^53 - 1) / 2^52 */
+ MinFloat64 = 4.940656458412465441765687928682213723651e-324 /* 1 / 2^(1023 - 1 + 52) */
)
// Integer limit values.
const (
- MaxInt8 = 1<<7 - 1;
- MinInt8 = -1 << 7;
- MaxInt16 = 1<<15 - 1;
- MinInt16 = -1 << 15;
- MaxInt32 = 1<<31 - 1;
- MinInt32 = -1 << 31;
- MaxInt64 = 1<<63 - 1;
- MinInt64 = -1 << 63;
- MaxUint8 = 1<<8 - 1;
- MaxUint16 = 1<<16 - 1;
- MaxUint32 = 1<<32 - 1;
- MaxUint64 = 1<<64 - 1;
+ MaxInt8 = 1<<7 - 1
+ MinInt8 = -1 << 7
+ MaxInt16 = 1<<15 - 1
+ MinInt16 = -1 << 15
+ MaxInt32 = 1<<31 - 1
+ MinInt32 = -1 << 31
+ MaxInt64 = 1<<63 - 1
+ MinInt64 = -1 << 63
+ MaxUint8 = 1<<8 - 1
+ MaxUint16 = 1<<16 - 1
+ MaxUint32 = 1<<32 - 1
+ MaxUint64 = 1<<64 - 1
)
// BUG(rsc): The manual should define the special cases for all of these functions.
// Very small values underflow to 1.
func Exp(x float64) float64 {
const (
- Ln2Hi = 6.93147180369123816490e-01;
- Ln2Lo = 1.90821492927058770002e-10;
- Log2e = 1.44269504088896338700e+00;
- P1 = 1.66666666666666019037e-01; /* 0x3FC55555; 0x5555553E */
- P2 = -2.77777777770155933842e-03; /* 0xBF66C16C; 0x16BEBD93 */
- P3 = 6.61375632143793436117e-05; /* 0x3F11566A; 0xAF25DE2C */
- P4 = -1.65339022054652515390e-06; /* 0xBEBBBD41; 0xC5D26BF1 */
- P5 = 4.13813679705723846039e-08; /* 0x3E663769; 0x72BEA4D0 */
+ Ln2Hi = 6.93147180369123816490e-01
+ Ln2Lo = 1.90821492927058770002e-10
+ Log2e = 1.44269504088896338700e+00
+ P1 = 1.66666666666666019037e-01 /* 0x3FC55555; 0x5555553E */
+ P2 = -2.77777777770155933842e-03 /* 0xBF66C16C; 0x16BEBD93 */
+ P3 = 6.61375632143793436117e-05 /* 0x3F11566A; 0xAF25DE2C */
+ P4 = -1.65339022054652515390e-06 /* 0xBEBBBD41; 0xC5D26BF1 */
+ P5 = 4.13813679705723846039e-08 /* 0x3E663769; 0x72BEA4D0 */
- Overflow = 7.09782712893383973096e+02;
- Underflow = -7.45133219101941108420e+02;
- NearZero = 1.0 / (1 << 28); // 2^-28
+ Overflow = 7.09782712893383973096e+02
+ Underflow = -7.45133219101941108420e+02
+ NearZero = 1.0 / (1 << 28) // 2^-28
)
// special cases
}
// reduce; computed as r = hi - lo for extra precision.
- var k int;
+ var k int
switch {
case x < 0:
k = int(Log2e*x - 0.5)
case x > 0:
k = int(Log2e*x + 0.5)
}
- hi := x - float64(k)*Ln2Hi;
- lo := float64(k) * Ln2Lo;
- r := hi - lo;
+ hi := x - float64(k)*Ln2Hi
+ lo := float64(k) * Ln2Lo
+ r := hi - lo
// compute
- t := r * r;
- c := r - t*(P1+t*(P2+t*(P3+t*(P4+t*P5))));
- y := 1 - ((lo - (r*c)/(2-c)) - hi);
+ t := r * r
+ c := r - t*(P1+t*(P2+t*(P3+t*(P4+t*P5))))
+ y := 1 - ((lo - (r*c)/(2-c)) - hi)
// TODO(rsc): make sure Ldexp can handle boundary k
- return Ldexp(y, k);
+ return Ldexp(y, k)
}
if x < 0 {
return -x
}
- return x;
+ return x
}
// Floor returns the greatest integer value less than or equal to x.
func Floor(x float64) float64 {
if x < 0 {
- d, fract := Modf(-x);
+ d, fract := Modf(-x)
if fract != 0.0 {
d = d + 1
}
- return -d;
+ return -d
}
- d, _ := Modf(x);
- return d;
+ d, _ := Modf(x)
+ return d
}
// Ceil returns the least integer value greater than or equal to x.
-func Ceil(x float64) float64 { return -Floor(-x) }
+func Ceil(x float64) float64 { return -Floor(-x) }
y = -y
}
- yfr, yexp := Frexp(y);
- sign := false;
- r := x;
+ yfr, yexp := Frexp(y)
+ sign := false
+ r := x
if x < 0 {
- r = -x;
- sign = true;
+ r = -x
+ sign = true
}
for r >= y {
- rfr, rexp := Frexp(r);
+ rfr, rexp := Frexp(r)
if rfr < yfr {
rexp = rexp - 1
}
- r = r - Ldexp(y, rexp-yexp);
+ r = r - Ldexp(y, rexp-yexp)
}
if sign {
r = -r
}
- return r;
+ return r
}
return 0
}
- pfac := p;
- q = q / p;
- r := q;
- p = 1;
+ pfac := p
+ q = q / p
+ r := q
+ p = 1
for {
- r = r * r;
- s := r + 4;
+ r = r * r
+ s := r + 4
if s == 4 {
return p * pfac
}
- r = r / s;
- p = p + 2*r*p;
- q = q * r;
- r = q / p;
+ r = r / s
+ p = p + 2*r*p
+ q = q * r
+ r = q / p
}
- panic("unreachable");
+ panic("unreachable")
}
// Log(NaN) = NaN
func Log(x float64) float64 {
const (
- Ln2Hi = 6.93147180369123816490e-01; /* 3fe62e42 fee00000 */
- Ln2Lo = 1.90821492927058770002e-10; /* 3dea39ef 35793c76 */
- L1 = 6.666666666666735130e-01; /* 3FE55555 55555593 */
- L2 = 3.999999999940941908e-01; /* 3FD99999 9997FA04 */
- L3 = 2.857142874366239149e-01; /* 3FD24924 94229359 */
- L4 = 2.222219843214978396e-01; /* 3FCC71C5 1D8E78AF */
- L5 = 1.818357216161805012e-01; /* 3FC74664 96CB03DE */
- L6 = 1.531383769920937332e-01; /* 3FC39A09 D078C69F */
- L7 = 1.479819860511658591e-01; /* 3FC2F112 DF3E5244 */
+ Ln2Hi = 6.93147180369123816490e-01 /* 3fe62e42 fee00000 */
+ Ln2Lo = 1.90821492927058770002e-10 /* 3dea39ef 35793c76 */
+ L1 = 6.666666666666735130e-01 /* 3FE55555 55555593 */
+ L2 = 3.999999999940941908e-01 /* 3FD99999 9997FA04 */
+ L3 = 2.857142874366239149e-01 /* 3FD24924 94229359 */
+ L4 = 2.222219843214978396e-01 /* 3FCC71C5 1D8E78AF */
+ L5 = 1.818357216161805012e-01 /* 3FC74664 96CB03DE */
+ L6 = 1.531383769920937332e-01 /* 3FC39A09 D078C69F */
+ L7 = 1.479819860511658591e-01 /* 3FC2F112 DF3E5244 */
)
// special cases
}
// reduce
- f1, ki := Frexp(x);
+ f1, ki := Frexp(x)
if f1 < Sqrt2/2 {
- f1 *= 2;
- ki--;
+ f1 *= 2
+ ki--
}
- f := f1 - 1;
- k := float64(ki);
+ f := f1 - 1
+ k := float64(ki)
// compute
- s := f / (2 + f);
- s2 := s * s;
- s4 := s2 * s2;
- t1 := s2 * (L1 + s4*(L3+s4*(L5+s4*L7)));
- t2 := s4 * (L2 + s4*(L4+s4*L6));
- R := t1 + t2;
- hfsq := 0.5 * f * f;
- return k*Ln2Hi - ((hfsq - (s*(hfsq+R) + k*Ln2Lo)) - f);
+ s := f / (2 + f)
+ s2 := s * s
+ s4 := s2 * s2
+ t1 := s2 * (L1 + s4*(L3+s4*(L5+s4*L7)))
+ t2 := s4 * (L2 + s4*(L4+s4*L6))
+ R := t1 + t2
+ hfsq := 0.5 * f * f
+ return k*Ln2Hi - ((hfsq - (s*(hfsq+R) + k*Ln2Lo)) - f)
}
// Log10 returns the decimal logarithm of x.
if x <= 0 {
return NaN()
}
- return Log(x) * (1 / Ln10);
+ return Log(x) * (1 / Ln10)
}
return 1 / Sqrt(x)
}
- absy := y;
- flip := false;
+ absy := y
+ flip := false
if absy < 0 {
- absy = -absy;
- flip = true;
+ absy = -absy
+ flip = true
}
- yi, yf := Modf(absy);
+ yi, yf := Modf(absy)
if yf != 0 && x < 0 {
return NaN()
}
}
// ans = a1 * 2^ae (= 1 for now).
- a1 := float64(1);
- ae := 0;
+ a1 := float64(1)
+ ae := 0
// ans *= x^yf
if yf != 0 {
if yf > 0.5 {
- yf--;
- yi++;
+ yf--
+ yi++
}
- a1 = Exp(yf * Log(x));
+ a1 = Exp(yf * Log(x))
}
// ans *= x^yi
// by multiplying in successive squarings
// of x according to bits of yi.
// accumulate powers of two into exp.
- x1, xe := Frexp(x);
+ x1, xe := Frexp(x)
for i := int64(yi); i != 0; i >>= 1 {
if i&1 == 1 {
- a1 *= x1;
- ae += xe;
+ a1 *= x1
+ ae += xe
}
- x1 *= x1;
- xe <<= 1;
+ x1 *= x1
+ xe <<= 1
if x1 < .5 {
- x1 += x1;
- xe--;
+ x1 += x1
+ xe--
}
}
// if flip { ans = 1 / ans }
// but in the opposite order
if flip {
- a1 = 1 / a1;
- ae = -ae;
+ a1 = 1 / a1
+ ae = -ae
}
- return Ldexp(a1, ae);
+ return Ldexp(a1, ae)
}
if e < len(pow10tab) {
return pow10tab[e]
}
- m := e / 2;
- return Pow10(m) * Pow10(e-m);
+ m := e / 2
+ return Pow10(m) * Pow10(e-m)
}
func init() {
- pow10tab[0] = 1.0e0;
- pow10tab[1] = 1.0e1;
+ pow10tab[0] = 1.0e0
+ pow10tab[1] = 1.0e1
for i := 2; i < len(pow10tab); i++ {
- m := i / 2;
- pow10tab[i] = pow10tab[m] * pow10tab[i-m];
+ m := i / 2
+ pow10tab[i] = pow10tab[m] * pow10tab[i-m]
}
}
func sinus(x float64, quad int) float64 {
// Coefficients are #3370 from Hart & Cheney (18.80D).
const (
- P0 = .1357884097877375669092680e8;
- P1 = -.4942908100902844161158627e7;
- P2 = .4401030535375266501944918e6;
- P3 = -.1384727249982452873054457e5;
- P4 = .1459688406665768722226959e3;
- Q0 = .8644558652922534429915149e7;
- Q1 = .4081792252343299749395779e6;
- Q2 = .9463096101538208180571257e4;
- Q3 = .1326534908786136358911494e3;
+ P0 = .1357884097877375669092680e8
+ P1 = -.4942908100902844161158627e7
+ P2 = .4401030535375266501944918e6
+ P3 = -.1384727249982452873054457e5
+ P4 = .1459688406665768722226959e3
+ Q0 = .8644558652922534429915149e7
+ Q1 = .4081792252343299749395779e6
+ Q2 = .9463096101538208180571257e4
+ Q3 = .1326534908786136358911494e3
)
if x < 0 {
- x = -x;
- quad = quad + 2;
+ x = -x
+ quad = quad + 2
}
- x = x * (2 / Pi); /* underflow? */
- var y float64;
+ x = x * (2 / Pi) /* underflow? */
+ var y float64
if x > 32764 {
- var e float64;
- e, y = Modf(x);
- e = e + float64(quad);
- f, _ := Modf(0.25 * e);
- quad = int(e - 4*f);
+ var e float64
+ e, y = Modf(x)
+ e = e + float64(quad)
+ f, _ := Modf(0.25 * e)
+ quad = int(e - 4*f)
} else {
- k := int32(x);
- y = x - float64(k);
- quad = (quad + int(k)) & 3;
+ k := int32(x)
+ y = x - float64(k)
+ quad = (quad + int(k)) & 3
}
if quad&1 != 0 {
y = -y
}
- yy := y * y;
- temp1 := ((((P4*yy+P3)*yy+P2)*yy+P1)*yy + P0) * y;
- temp2 := ((((yy+Q3)*yy+Q2)*yy+Q1)*yy + Q0);
- return temp1 / temp2;
+ yy := y * y
+ temp1 := ((((P4*yy+P3)*yy+P2)*yy+P1)*yy + P0) * y
+ temp2 := ((((yy+Q3)*yy+Q2)*yy+Q1)*yy + Q0)
+ return temp1 / temp2
}
// Cos returns the cosine of x.
if x < 0 {
x = -x
}
- return sinus(x, 1);
+ return sinus(x, 1)
}
// Sin returns the sine of x.
-func Sin(x float64) float64 { return sinus(x, 0) }
+func Sin(x float64) float64 { return sinus(x, 0) }
func Sinh(x float64) float64 {
// The coefficients are #2029 from Hart & Cheney. (20.36D)
const (
- P0 = -0.6307673640497716991184787251e+6;
- P1 = -0.8991272022039509355398013511e+5;
- P2 = -0.2894211355989563807284660366e+4;
- P3 = -0.2630563213397497062819489e+2;
- Q0 = -0.6307673640497716991212077277e+6;
- Q1 = 0.1521517378790019070696485176e+5;
- Q2 = -0.173678953558233699533450911e+3;
+ P0 = -0.6307673640497716991184787251e+6
+ P1 = -0.8991272022039509355398013511e+5
+ P2 = -0.2894211355989563807284660366e+4
+ P3 = -0.2630563213397497062819489e+2
+ Q0 = -0.6307673640497716991212077277e+6
+ Q1 = 0.1521517378790019070696485176e+5
+ Q2 = -0.173678953558233699533450911e+3
)
- sign := false;
+ sign := false
if x < 0 {
- x = -x;
- sign = true;
+ x = -x
+ sign = true
}
- var temp float64;
+ var temp float64
switch true {
case x > 21:
temp = Exp(x) / 2
temp = (Exp(x) - Exp(-x)) / 2
default:
- sq := x * x;
- temp = (((P3*sq+P2)*sq+P1)*sq + P0) * x;
- temp = temp / (((sq+Q2)*sq+Q1)*sq + Q0);
+ sq := x * x
+ temp = (((P3*sq+P2)*sq+P1)*sq + P0) * x
+ temp = temp / (((sq+Q2)*sq+Q1)*sq + Q0)
}
if sign {
temp = -temp
}
- return temp;
+ return temp
}
// Cosh returns the hyperbolic cosine of x.
if x > 21 {
return Exp(x) / 2
}
- return (Exp(x) + Exp(-x)) / 2;
+ return (Exp(x) + Exp(-x)) / 2
}
if x < 0 {
return NaN()
}
- return 0;
+ return 0
}
- y, exp := Frexp(x);
+ y, exp := Frexp(x)
for y < 0.5 {
- y = y * 2;
- exp = exp - 1;
+ y = y * 2
+ exp = exp - 1
}
if exp&1 != 0 {
- y = y * 2;
- exp = exp - 1;
+ y = y * 2
+ exp = exp - 1
}
- temp := 0.5 * (1 + y);
+ temp := 0.5 * (1 + y)
for exp > 60 {
- temp = temp * float64(1<<30);
- exp = exp - 60;
+ temp = temp * float64(1<<30)
+ exp = exp - 60
}
for exp < -60 {
- temp = temp / float64(1<<30);
- exp = exp + 60;
+ temp = temp / float64(1<<30)
+ exp = exp + 60
}
if exp >= 0 {
- exp = 1 << uint(exp/2);
- temp = temp * float64(exp);
+ exp = 1 << uint(exp/2)
+ temp = temp * float64(exp)
} else {
- exp = 1 << uint(-exp/2);
- temp = temp / float64(exp);
+ exp = 1 << uint(-exp/2)
+ temp = temp / float64(exp)
}
for i := 0; i <= 4; i++ {
temp = 0.5 * (temp + x/temp)
}
- return temp;
+ return temp
}
func Tan(x float64) float64 {
// Coefficients are #4285 from Hart & Cheney. (19.74D)
const (
- P0 = -.1306820264754825668269611177e+5;
- P1 = .1055970901714953193602353981e+4;
- P2 = -.1550685653483266376941705728e+2;
- P3 = .3422554387241003435328470489e-1;
- P4 = .3386638642677172096076369e-4;
- Q0 = -.1663895238947119001851464661e+5;
- Q1 = .4765751362916483698926655581e+4;
- Q2 = -.1555033164031709966900124574e+3;
+ P0 = -.1306820264754825668269611177e+5
+ P1 = .1055970901714953193602353981e+4
+ P2 = -.1550685653483266376941705728e+2
+ P3 = .3422554387241003435328470489e-1
+ P4 = .3386638642677172096076369e-4
+ Q0 = -.1663895238947119001851464661e+5
+ Q1 = .4765751362916483698926655581e+4
+ Q2 = -.1555033164031709966900124574e+3
)
- flag := false;
- sign := false;
+ flag := false
+ sign := false
if x < 0 {
- x = -x;
- sign = true;
+ x = -x
+ sign = true
}
- x = x * (4 / Pi); /* overflow? */
- var e float64;
- e, x = Modf(x);
- i := int32(e);
+ x = x * (4 / Pi) /* overflow? */
+ var e float64
+ e, x = Modf(x)
+ i := int32(e)
switch i & 3 {
case 1:
- x = 1 - x;
- flag = true;
+ x = 1 - x
+ flag = true
case 2:
- sign = !sign;
- flag = true;
+ sign = !sign
+ flag = true
case 3:
- x = 1 - x;
- sign = !sign;
+ x = 1 - x
+ sign = !sign
}
- xsq := x * x;
- temp := ((((P4*xsq+P3)*xsq+P2)*xsq+P1)*xsq + P0) * x;
- temp = temp / (((xsq+Q2)*xsq+Q1)*xsq + Q0);
+ xsq := x * x
+ temp := ((((P4*xsq+P3)*xsq+P2)*xsq+P1)*xsq + P0) * x
+ temp = temp / (((xsq+Q2)*xsq+Q1)*xsq + Q0)
if flag {
if temp == 0 {
panic(NaN())
}
- temp = 1 / temp;
+ temp = 1 / temp
}
if sign {
temp = -temp
}
- return temp;
+ return temp
}
// Tanh computes the hyperbolic tangent of x.
func Tanh(x float64) float64 {
if x < 0 {
- x = -x;
+ x = -x
if x > 21 {
return -1
}
- return -Sinh(x) / Cosh(x);
+ return -Sinh(x) / Cosh(x)
}
if x > 21 {
return 1
}
- return Sinh(x) / Cosh(x);
+ return Sinh(x) / Cosh(x)
}
import "unsafe"
// Float32bits returns the IEEE 754 binary representation of f.
-func Float32bits(f float32) uint32 { return *(*uint32)(unsafe.Pointer(&f)) }
+func Float32bits(f float32) uint32 { return *(*uint32)(unsafe.Pointer(&f)) }
// Float32frombits returns the floating point number corresponding
// to the IEEE 754 binary representation b.
-func Float32frombits(b uint32) float32 { return *(*float32)(unsafe.Pointer(&b)) }
+func Float32frombits(b uint32) float32 { return *(*float32)(unsafe.Pointer(&b)) }
// Float64bits returns the IEEE 754 binary representation of f.
-func Float64bits(f float64) uint64 { return *(*uint64)(unsafe.Pointer(&f)) }
+func Float64bits(f float64) uint64 { return *(*uint64)(unsafe.Pointer(&f)) }
// Float64frombits returns the floating point number corresponding
// the IEEE 754 binary representation b.
-func Float64frombits(b uint64) float64 { return *(*float64)(unsafe.Pointer(&b)) }
+func Float64frombits(b uint64) float64 { return *(*float64)(unsafe.Pointer(&b)) }
package net
import (
- "flag";
- "io";
- "strings";
- "syscall";
- "testing";
+ "flag"
+ "io"
+ "strings"
+ "syscall"
+ "testing"
)
// If an IPv6 tunnel is running (see go/stubl), we can try dialing a real IPv6 address.
// fd is already connected to the destination, port 80.
// Run an HTTP request to fetch the appropriate page.
func fetchGoogle(t *testing.T, fd Conn, network, addr string) {
- req := strings.Bytes("GET /intl/en/privacy.html HTTP/1.0\r\nHost: www.google.com\r\n\r\n");
- n, err := fd.Write(req);
+ req := strings.Bytes("GET /intl/en/privacy.html HTTP/1.0\r\nHost: www.google.com\r\n\r\n")
+ n, err := fd.Write(req)
- buf := make([]byte, 1000);
- n, err = io.ReadFull(fd, buf);
+ buf := make([]byte, 1000)
+ n, err = io.ReadFull(fd, buf)
if n < 1000 {
- t.Errorf("fetchGoogle: short HTTP read from %s %s - %v", network, addr, err);
- return;
+ t.Errorf("fetchGoogle: short HTTP read from %s %s - %v", network, addr, err)
+ return
}
}
func doDial(t *testing.T, network, addr string) {
- fd, err := Dial(network, "", addr);
+ fd, err := Dial(network, "", addr)
if err != nil {
- t.Errorf("Dial(%q, %q, %q) = _, %v", network, "", addr, err);
- return;
+ t.Errorf("Dial(%q, %q, %q) = _, %v", network, "", addr, err)
+ return
}
- fetchGoogle(t, fd, network, addr);
- fd.Close();
+ fetchGoogle(t, fd, network, addr)
+ fd.Close()
}
var googleaddrs = []string{
"[0:0:0:0:0000:ffff:74.125.19.99]:80",
"[0:0:0:0:000000:ffff:74.125.19.99]:80",
"[0:0:0:0:0:ffff::74.125.19.99]:80",
- "[2001:4860:0:2001::68]:80", // ipv6.google.com; removed if ipv6 flag not set
+ "[2001:4860:0:2001::68]:80", // ipv6.google.com; removed if ipv6 flag not set
}
func TestDialGoogle(t *testing.T) {
}
for i := 0; i < len(googleaddrs); i++ {
- addr := googleaddrs[i];
+ addr := googleaddrs[i]
if addr == "" {
continue
}
- t.Logf("-- %s --", addr);
- doDial(t, "tcp", addr);
+ t.Logf("-- %s --", addr)
+ doDial(t, "tcp", addr)
if addr[0] != '[' {
- doDial(t, "tcp4", addr);
+ doDial(t, "tcp4", addr)
if !preferIPv4 {
// make sure preferIPv4 flag works.
- preferIPv4 = true;
- syscall.SocketDisableIPv6 = true;
- doDial(t, "tcp4", addr);
- syscall.SocketDisableIPv6 = false;
- preferIPv4 = false;
+ preferIPv4 = true
+ syscall.SocketDisableIPv6 = true
+ doDial(t, "tcp4", addr)
+ syscall.SocketDisableIPv6 = false
+ preferIPv4 = false
}
}
package net
import (
- "once";
- "os";
+ "once"
+ "os"
)
// DNSError represents a DNS lookup error.
type DNSError struct {
- Error string; // description of the error
- Name string; // name looked for
- Server string; // server used
+ Error string // description of the error
+ Name string // name looked for
+ Server string // server used
}
func (e *DNSError) String() string {
- s := "lookup " + e.Name;
+ s := "lookup " + e.Name
if e.Server != "" {
s += " on " + e.Server
}
- s += ": " + e.Error;
- return s;
+ s += ": " + e.Error
+ return s
}
const noSuchHost = "no such host"
if len(name) >= 256 {
return nil, &DNSError{"name too long", name, ""}
}
- out := new(_DNS_Msg);
- out.id = 0x1234;
+ out := new(_DNS_Msg)
+ out.id = 0x1234
out.question = []_DNS_Question{
_DNS_Question{name, _DNS_TypeA, _DNS_ClassINET},
- };
- out.recursion_desired = true;
- msg, ok := out.Pack();
+ }
+ out.recursion_desired = true
+ msg, ok := out.Pack()
if !ok {
return nil, &DNSError{"internal error - cannot pack message", name, ""}
}
for attempt := 0; attempt < cfg.attempts; attempt++ {
- n, err := c.Write(msg);
+ n, err := c.Write(msg)
if err != nil {
return nil, err
}
- c.SetReadTimeout(1e9); // nanoseconds
+ c.SetReadTimeout(1e9) // nanoseconds
- buf := make([]byte, 2000); // More than enough.
- n, err = c.Read(buf);
+ buf := make([]byte, 2000) // More than enough.
+ n, err = c.Read(buf)
if isEAGAIN(err) {
- err = nil;
- continue;
+ err = nil
+ continue
}
if err != nil {
return nil, err
}
- buf = buf[0:n];
- in := new(_DNS_Msg);
+ buf = buf[0:n]
+ in := new(_DNS_Msg)
if !in.Unpack(buf) || in.id != out.id {
continue
}
- return in, nil;
+ return in, nil
}
- var server string;
+ var server string
if a := c.RemoteAddr(); a != nil {
server = a.String()
}
- return nil, &DNSError{"no answer from server", name, server};
+ return nil, &DNSError{"no answer from server", name, server}
}
// Find answer for name in dns message.
// On return, if err == nil, addrs != nil.
func answer(name, server string, dns *_DNS_Msg) (addrs []string, err *DNSError) {
- addrs = make([]string, 0, len(dns.answer));
+ addrs = make([]string, 0, len(dns.answer))
if dns.rcode == _DNS_RcodeNameError && dns.recursion_available {
return nil, &DNSError{noSuchHost, name, ""}
// all the answers we need in this one packet.
Cname:
for cnameloop := 0; cnameloop < 10; cnameloop++ {
- addrs = addrs[0:0];
+ addrs = addrs[0:0]
for i := 0; i < len(dns.answer); i++ {
- rr := dns.answer[i];
- h := rr.Header();
+ rr := dns.answer[i]
+ h := rr.Header()
if h.Class == _DNS_ClassINET && h.Name == name {
switch h.Rrtype {
case _DNS_TypeA:
- n := len(addrs);
- a := rr.(*_DNS_RR_A).A;
- addrs = addrs[0 : n+1];
- addrs[n] = IPv4(byte(a>>24), byte(a>>16), byte(a>>8), byte(a)).String();
+ n := len(addrs)
+ a := rr.(*_DNS_RR_A).A
+ addrs = addrs[0 : n+1]
+ addrs[n] = IPv4(byte(a>>24), byte(a>>16), byte(a>>8), byte(a)).String()
case _DNS_TypeCNAME:
// redirect to cname
- name = rr.(*_DNS_RR_CNAME).Cname;
- continue Cname;
+ name = rr.(*_DNS_RR_CNAME).Cname
+ continue Cname
}
}
}
if len(addrs) == 0 {
return nil, &DNSError{noSuchHost, name, server}
}
- return addrs, nil;
+ return addrs, nil
}
- return nil, &DNSError{"too many redirects", name, server};
+ return nil, &DNSError{"too many redirects", name, server}
}
// Do a lookup for a single name, which must be rooted
// The DNS config parser has already checked that
// all the cfg.servers[i] are IP addresses, which
// Dial will use without a DNS lookup.
- server := cfg.servers[i] + ":53";
- c, cerr := Dial("udp", "", server);
+ server := cfg.servers[i] + ":53"
+ c, cerr := Dial("udp", "", server)
if cerr != nil {
- err = cerr;
- continue;
+ err = cerr
+ continue
}
- msg, merr := _Exchange(cfg, c, name);
- c.Close();
+ msg, merr := _Exchange(cfg, c, name)
+ c.Close()
if merr != nil {
- err = merr;
- continue;
+ err = merr
+ continue
}
- var dnserr *DNSError;
- addrs, dnserr = answer(name, server, msg);
+ var dnserr *DNSError
+ addrs, dnserr = answer(name, server, msg)
if dnserr != nil {
err = dnserr
} else {
- err = nil // nil os.Error, not nil *DNSError
+ err = nil // nil os.Error, not nil *DNSError
}
if dnserr == nil || dnserr.Error == noSuchHost {
break
}
}
- return;
+ return
}
var cfg *_DNS_Config
var dnserr os.Error
-func loadConfig() { cfg, dnserr = _DNS_ReadConfig() }
+func loadConfig() { cfg, dnserr = _DNS_ReadConfig() }
func isDomainName(s string) bool {
// Requirements on DNS name:
if len(s) == 0 {
return false
}
- if s[len(s)-1] != '.' { // simplify checking loop: make name end in dot
+ if s[len(s)-1] != '.' { // simplify checking loop: make name end in dot
s += "."
}
- last := byte('.');
- ok := false; // ok once we've seen a letter
+ last := byte('.')
+ ok := false // ok once we've seen a letter
for i := 0; i < len(s); i++ {
- c := s[i];
+ c := s[i]
switch {
default:
return false
return false
}
}
- last = c;
+ last = c
}
- return ok;
+ return ok
}
// LookupHost looks up the host name using the local DNS resolver.
if !isDomainName(name) {
return name, nil, &DNSError{"invalid domain name", name, ""}
}
- once.Do(loadConfig);
+ once.Do(loadConfig)
if dnserr != nil || cfg == nil {
- err = dnserr;
- return;
+ err = dnserr
+ return
}
// If name is rooted (trailing dot) or has enough dots,
// try it by itself first.
- rooted := len(name) > 0 && name[len(name)-1] == '.';
+ rooted := len(name) > 0 && name[len(name)-1] == '.'
if rooted || count(name, '.') >= cfg.ndots {
- rname := name;
+ rname := name
if !rooted {
rname += "."
}
// Can try as ordinary name.
- addrs, err = tryOneName(cfg, rname);
+ addrs, err = tryOneName(cfg, rname)
if err == nil {
- cname = rname;
- return;
+ cname = rname
+ return
}
}
if rooted {
// Otherwise, try suffixes.
for i := 0; i < len(cfg.search); i++ {
- rname := name + "." + cfg.search[i];
+ rname := name + "." + cfg.search[i]
if rname[len(rname)-1] != '.' {
rname += "."
}
- addrs, err = tryOneName(cfg, rname);
+ addrs, err = tryOneName(cfg, rname)
if err == nil {
- cname = rname;
- return;
+ cname = rname
+ return
}
}
// Last ditch effort: try unsuffixed.
- rname := name;
+ rname := name
if !rooted {
rname += "."
}
- addrs, err = tryOneName(cfg, rname);
+ addrs, err = tryOneName(cfg, rname)
if err == nil {
- cname = rname;
- return;
+ cname = rname
+ return
}
- return;
+ return
}
import "os"
type _DNS_Config struct {
- servers []string; // servers to use
- search []string; // suffixes to append to local name
- ndots int; // number of dots in name to trigger absolute lookup
- timeout int; // seconds before giving up on packet
- attempts int; // lost packets before giving up on server
- rotate bool; // round robin among servers
+ servers []string // servers to use
+ search []string // suffixes to append to local name
+ ndots int // number of dots in name to trigger absolute lookup
+ timeout int // seconds before giving up on packet
+ attempts int // lost packets before giving up on server
+ rotate bool // round robin among servers
}
var _DNS_configError os.Error
// of the host name to get the default search domain.
// We assume it's in resolv.conf anyway.
func _DNS_ReadConfig() (*_DNS_Config, os.Error) {
- file, err := open("/etc/resolv.conf");
+ file, err := open("/etc/resolv.conf")
if err != nil {
return nil, err
}
- conf := new(_DNS_Config);
- conf.servers = make([]string, 3)[0:0]; // small, but the standard limit
- conf.search = make([]string, 0);
- conf.ndots = 1;
- conf.timeout = 1;
- conf.attempts = 1;
- conf.rotate = false;
+ conf := new(_DNS_Config)
+ conf.servers = make([]string, 3)[0:0] // small, but the standard limit
+ conf.search = make([]string, 0)
+ conf.ndots = 1
+ conf.timeout = 1
+ conf.attempts = 1
+ conf.rotate = false
for line, ok := file.readLine(); ok; line, ok = file.readLine() {
- f := getFields(line);
+ f := getFields(line)
if len(f) < 1 {
continue
}
switch f[0] {
- case "nameserver": // add one name server
- a := conf.servers;
- n := len(a);
+ case "nameserver": // add one name server
+ a := conf.servers
+ n := len(a)
if len(f) > 1 && n < cap(a) {
// One more check: make sure server name is
// just an IP address. Otherwise we need DNS
// to look it up.
- name := f[1];
+ name := f[1]
if len(ParseIP(name)) != 0 {
- a = a[0 : n+1];
- a[n] = name;
- conf.servers = a;
+ a = a[0 : n+1]
+ a[n] = name
+ conf.servers = a
}
}
- case "domain": // set search path to just this domain
+ case "domain": // set search path to just this domain
if len(f) > 1 {
- conf.search = make([]string, 1);
- conf.search[0] = f[1];
+ conf.search = make([]string, 1)
+ conf.search[0] = f[1]
} else {
conf.search = make([]string, 0)
}
- case "search": // set search path to given servers
- conf.search = make([]string, len(f)-1);
+ case "search": // set search path to given servers
+ conf.search = make([]string, len(f)-1)
for i := 0; i < len(conf.search); i++ {
conf.search[i] = f[i+1]
}
- case "options": // magic options
+ case "options": // magic options
for i := 1; i < len(f); i++ {
- s := f[i];
+ s := f[i]
switch {
case len(s) >= 6 && s[0:6] == "ndots:":
- n, _, _ := dtoi(s, 6);
+ n, _, _ := dtoi(s, 6)
if n < 1 {
n = 1
}
- conf.ndots = n;
+ conf.ndots = n
case len(s) >= 8 && s[0:8] == "timeout:":
- n, _, _ := dtoi(s, 8);
+ n, _, _ := dtoi(s, 8)
if n < 1 {
n = 1
}
- conf.timeout = n;
+ conf.timeout = n
case len(s) >= 8 && s[0:9] == "attempts:":
- n, _, _ := dtoi(s, 9);
+ n, _, _ := dtoi(s, 9)
if n < 1 {
n = 1
}
- conf.attempts = n;
+ conf.attempts = n
case s == "rotate":
conf.rotate = true
}
}
}
}
- file.close();
+ file.close()
- return conf, nil;
+ return conf, nil
}
package net
import (
- "fmt";
- "os";
- "reflect";
+ "fmt"
+ "os"
+ "reflect"
)
// Packet formats
// Wire constants.
const (
// valid _DNS_RR_Header.Rrtype and _DNS_Question.qtype
- _DNS_TypeA = 1;
- _DNS_TypeNS = 2;
- _DNS_TypeMD = 3;
- _DNS_TypeMF = 4;
- _DNS_TypeCNAME = 5;
- _DNS_TypeSOA = 6;
- _DNS_TypeMB = 7;
- _DNS_TypeMG = 8;
- _DNS_TypeMR = 9;
- _DNS_TypeNULL = 10;
- _DNS_TypeWKS = 11;
- _DNS_TypePTR = 12;
- _DNS_TypeHINFO = 13;
- _DNS_TypeMINFO = 14;
- _DNS_TypeMX = 15;
- _DNS_TypeTXT = 16;
+ _DNS_TypeA = 1
+ _DNS_TypeNS = 2
+ _DNS_TypeMD = 3
+ _DNS_TypeMF = 4
+ _DNS_TypeCNAME = 5
+ _DNS_TypeSOA = 6
+ _DNS_TypeMB = 7
+ _DNS_TypeMG = 8
+ _DNS_TypeMR = 9
+ _DNS_TypeNULL = 10
+ _DNS_TypeWKS = 11
+ _DNS_TypePTR = 12
+ _DNS_TypeHINFO = 13
+ _DNS_TypeMINFO = 14
+ _DNS_TypeMX = 15
+ _DNS_TypeTXT = 16
// valid _DNS_Question.qtype only
- _DNS_TypeAXFR = 252;
- _DNS_TypeMAILB = 253;
- _DNS_TypeMAILA = 254;
- _DNS_TypeALL = 255;
+ _DNS_TypeAXFR = 252
+ _DNS_TypeMAILB = 253
+ _DNS_TypeMAILA = 254
+ _DNS_TypeALL = 255
// valid _DNS_Question.qclass
- _DNS_ClassINET = 1;
- _DNS_ClassCSNET = 2;
- _DNS_ClassCHAOS = 3;
- _DNS_ClassHESIOD = 4;
- _DNS_ClassANY = 255;
+ _DNS_ClassINET = 1
+ _DNS_ClassCSNET = 2
+ _DNS_ClassCHAOS = 3
+ _DNS_ClassHESIOD = 4
+ _DNS_ClassANY = 255
// _DNS_Msg.rcode
- _DNS_RcodeSuccess = 0;
- _DNS_RcodeFormatError = 1;
- _DNS_RcodeServerFailure = 2;
- _DNS_RcodeNameError = 3;
- _DNS_RcodeNotImplemented = 4;
- _DNS_RcodeRefused = 5;
+ _DNS_RcodeSuccess = 0
+ _DNS_RcodeFormatError = 1
+ _DNS_RcodeServerFailure = 2
+ _DNS_RcodeNameError = 3
+ _DNS_RcodeNotImplemented = 4
+ _DNS_RcodeRefused = 5
)
// The wire format for the DNS packet header.
type __DNS_Header struct {
- Id uint16;
- Bits uint16;
- Qdcount, Ancount, Nscount, Arcount uint16;
+ Id uint16
+ Bits uint16
+ Qdcount, Ancount, Nscount, Arcount uint16
}
const (
// __DNS_Header.Bits
- _QR = 1 << 15; // query/response (response=1)
- _AA = 1 << 10; // authoritative
- _TC = 1 << 9; // truncated
- _RD = 1 << 8; // recursion desired
- _RA = 1 << 7; // recursion available
+ _QR = 1 << 15 // query/response (response=1)
+ _AA = 1 << 10 // authoritative
+ _TC = 1 << 9 // truncated
+ _RD = 1 << 8 // recursion desired
+ _RA = 1 << 7 // recursion available
)
// DNS queries.
type _DNS_Question struct {
- Name string "domain-name"; // "domain-name" specifies encoding; see packers below
- Qtype uint16;
- Qclass uint16;
+ Name string "domain-name" // "domain-name" specifies encoding; see packers below
+ Qtype uint16
+ Qclass uint16
}
// DNS responses (resource records).
// There are many types of messages,
// but they all share the same header.
type _DNS_RR_Header struct {
- Name string "domain-name";
- Rrtype uint16;
- Class uint16;
- Ttl uint32;
- Rdlength uint16; // length of data after header
+ Name string "domain-name"
+ Rrtype uint16
+ Class uint16
+ Ttl uint32
+ Rdlength uint16 // length of data after header
}
func (h *_DNS_RR_Header) Header() *_DNS_RR_Header {
}
type _DNS_RR interface {
- Header() *_DNS_RR_Header;
+ Header() *_DNS_RR_Header
}
// Specific DNS RR formats for each query type.
type _DNS_RR_CNAME struct {
- Hdr _DNS_RR_Header;
- Cname string "domain-name";
+ Hdr _DNS_RR_Header
+ Cname string "domain-name"
}
func (rr *_DNS_RR_CNAME) Header() *_DNS_RR_Header {
}
type _DNS_RR_HINFO struct {
- Hdr _DNS_RR_Header;
- Cpu string;
- Os string;
+ Hdr _DNS_RR_Header
+ Cpu string
+ Os string
}
func (rr *_DNS_RR_HINFO) Header() *_DNS_RR_Header {
}
type _DNS_RR_MB struct {
- Hdr _DNS_RR_Header;
- Mb string "domain-name";
+ Hdr _DNS_RR_Header
+ Mb string "domain-name"
}
func (rr *_DNS_RR_MB) Header() *_DNS_RR_Header {
}
type _DNS_RR_MG struct {
- Hdr _DNS_RR_Header;
- Mg string "domain-name";
+ Hdr _DNS_RR_Header
+ Mg string "domain-name"
}
func (rr *_DNS_RR_MG) Header() *_DNS_RR_Header {
}
type _DNS_RR_MINFO struct {
- Hdr _DNS_RR_Header;
- Rmail string "domain-name";
- Email string "domain-name";
+ Hdr _DNS_RR_Header
+ Rmail string "domain-name"
+ Email string "domain-name"
}
func (rr *_DNS_RR_MINFO) Header() *_DNS_RR_Header {
}
type _DNS_RR_MR struct {
- Hdr _DNS_RR_Header;
- Mr string "domain-name";
+ Hdr _DNS_RR_Header
+ Mr string "domain-name"
}
func (rr *_DNS_RR_MR) Header() *_DNS_RR_Header {
}
type _DNS_RR_MX struct {
- Hdr _DNS_RR_Header;
- Pref uint16;
- Mx string "domain-name";
+ Hdr _DNS_RR_Header
+ Pref uint16
+ Mx string "domain-name"
}
func (rr *_DNS_RR_MX) Header() *_DNS_RR_Header {
}
type _DNS_RR_NS struct {
- Hdr _DNS_RR_Header;
- Ns string "domain-name";
+ Hdr _DNS_RR_Header
+ Ns string "domain-name"
}
func (rr *_DNS_RR_NS) Header() *_DNS_RR_Header {
}
type _DNS_RR_PTR struct {
- Hdr _DNS_RR_Header;
- Ptr string "domain-name";
+ Hdr _DNS_RR_Header
+ Ptr string "domain-name"
}
func (rr *_DNS_RR_PTR) Header() *_DNS_RR_Header {
}
type _DNS_RR_SOA struct {
- Hdr _DNS_RR_Header;
- Ns string "domain-name";
- Mbox string "domain-name";
- Serial uint32;
- Refresh uint32;
- Retry uint32;
- Expire uint32;
- Minttl uint32;
+ Hdr _DNS_RR_Header
+ Ns string "domain-name"
+ Mbox string "domain-name"
+ Serial uint32
+ Refresh uint32
+ Retry uint32
+ Expire uint32
+ Minttl uint32
}
func (rr *_DNS_RR_SOA) Header() *_DNS_RR_Header {
}
type _DNS_RR_TXT struct {
- Hdr _DNS_RR_Header;
- Txt string; // not domain name
+ Hdr _DNS_RR_Header
+ Txt string // not domain name
}
func (rr *_DNS_RR_TXT) Header() *_DNS_RR_Header {
}
type _DNS_RR_A struct {
- Hdr _DNS_RR_Header;
- A uint32 "ipv4";
+ Hdr _DNS_RR_Header
+ A uint32 "ipv4"
}
-func (rr *_DNS_RR_A) Header() *_DNS_RR_Header { return &rr.Hdr }
+func (rr *_DNS_RR_A) Header() *_DNS_RR_Header { return &rr.Hdr }
// Packing and unpacking.
// We trade each dot byte for a length byte.
// There is also a trailing zero.
// Check that we have all the space we need.
- tot := len(s) + 1;
+ tot := len(s) + 1
if off+tot > len(msg) {
return len(msg), false
}
// Emit sequence of counted strings, chopping at dots.
- begin := 0;
+ begin := 0
for i := 0; i < len(s); i++ {
if s[i] == '.' {
- if i-begin >= 1<<6 { // top two bits of length must be clear
+ if i-begin >= 1<<6 { // top two bits of length must be clear
return len(msg), false
}
- msg[off] = byte(i - begin);
- off++;
+ msg[off] = byte(i - begin)
+ off++
for j := begin; j < i; j++ {
- msg[off] = s[j];
- off++;
+ msg[off] = s[j]
+ off++
}
- begin = i + 1;
+ begin = i + 1
}
}
- msg[off] = 0;
- off++;
- return off, true;
+ msg[off] = 0
+ off++
+ return off, true
}
// Unpack a domain name.
// In theory, the pointers are only allowed to jump backward.
// We let them jump anywhere and stop jumping after a while.
func unpackDomainName(msg []byte, off int) (s string, off1 int, ok bool) {
- s = "";
- ptr := 0; // number of pointers followed
+ s = ""
+ ptr := 0 // number of pointers followed
Loop:
for {
if off >= len(msg) {
return "", len(msg), false
}
- c := int(msg[off]);
- off++;
+ c := int(msg[off])
+ off++
switch c & 0xC0 {
case 0x00:
if c == 0x00 {
if off+c > len(msg) {
return "", len(msg), false
}
- s += string(msg[off:off+c]) + ".";
- off += c;
+ s += string(msg[off:off+c]) + "."
+ off += c
case 0xC0:
// pointer to somewhere else in msg.
// remember location after first ptr,
if off >= len(msg) {
return "", len(msg), false
}
- c1 := msg[off];
- off++;
+ c1 := msg[off]
+ off++
if ptr == 0 {
off1 = off
}
if ptr++; ptr > 10 {
return "", len(msg), false
}
- off = (c^0xC0)<<8 | int(c1);
+ off = (c^0xC0)<<8 | int(c1)
default:
// 0x80 and 0x40 are reserved
return "", len(msg), false
if ptr == 0 {
off1 = off
}
- return s, off1, true;
+ return s, off1, true
}
// TODO(rsc): Move into generic library?
// and other (often anonymous) structs.
func packStructValue(val *reflect.StructValue, msg []byte, off int) (off1 int, ok bool) {
for i := 0; i < val.NumField(); i++ {
- f := val.Type().(*reflect.StructType).Field(i);
+ f := val.Type().(*reflect.StructType).Field(i)
switch fv := val.Field(i).(type) {
default:
- fmt.Fprintf(os.Stderr, "net: dns: unknown packing type %v", f.Type);
- return len(msg), false;
+ fmt.Fprintf(os.Stderr, "net: dns: unknown packing type %v", f.Type)
+ return len(msg), false
case *reflect.StructValue:
off, ok = packStructValue(fv, msg, off)
case *reflect.Uint16Value:
- i := fv.Get();
+ i := fv.Get()
if off+2 > len(msg) {
return len(msg), false
}
- msg[off] = byte(i >> 8);
- msg[off+1] = byte(i);
- off += 2;
+ msg[off] = byte(i >> 8)
+ msg[off+1] = byte(i)
+ off += 2
case *reflect.Uint32Value:
- i := fv.Get();
+ i := fv.Get()
if off+4 > len(msg) {
return len(msg), false
}
- msg[off] = byte(i >> 24);
- msg[off+1] = byte(i >> 16);
- msg[off+2] = byte(i >> 8);
- msg[off+4] = byte(i);
- off += 4;
+ msg[off] = byte(i >> 24)
+ msg[off+1] = byte(i >> 16)
+ msg[off+2] = byte(i >> 8)
+ msg[off+4] = byte(i)
+ off += 4
case *reflect.StringValue:
// There are multiple string encodings.
// The tag distinguishes ordinary strings from domain names.
- s := fv.Get();
+ s := fv.Get()
switch f.Tag {
default:
- fmt.Fprintf(os.Stderr, "net: dns: unknown string tag %v", f.Tag);
- return len(msg), false;
+ fmt.Fprintf(os.Stderr, "net: dns: unknown string tag %v", f.Tag)
+ return len(msg), false
case "domain-name":
- off, ok = packDomainName(s, msg, off);
+ off, ok = packDomainName(s, msg, off)
if !ok {
return len(msg), false
}
if len(s) > 255 || off+1+len(s) > len(msg) {
return len(msg), false
}
- msg[off] = byte(len(s));
- off++;
+ msg[off] = byte(len(s))
+ off++
for i := 0; i < len(s); i++ {
msg[off+i] = s[i]
}
- off += len(s);
+ off += len(s)
}
}
}
- return off, true;
+ return off, true
}
func structValue(any interface{}) *reflect.StructValue {
}
func packStruct(any interface{}, msg []byte, off int) (off1 int, ok bool) {
- off, ok = packStructValue(structValue(any), msg, off);
- return off, ok;
+ off, ok = packStructValue(structValue(any), msg, off)
+ return off, ok
}
// TODO(rsc): Move into generic library?
// Same restrictions as packStructValue.
func unpackStructValue(val *reflect.StructValue, msg []byte, off int) (off1 int, ok bool) {
for i := 0; i < val.NumField(); i++ {
- f := val.Type().(*reflect.StructType).Field(i);
+ f := val.Type().(*reflect.StructType).Field(i)
switch fv := val.Field(i).(type) {
default:
- fmt.Fprintf(os.Stderr, "net: dns: unknown packing type %v", f.Type);
- return len(msg), false;
+ fmt.Fprintf(os.Stderr, "net: dns: unknown packing type %v", f.Type)
+ return len(msg), false
case *reflect.StructValue:
off, ok = unpackStructValue(fv, msg, off)
case *reflect.Uint16Value:
if off+2 > len(msg) {
return len(msg), false
}
- i := uint16(msg[off])<<8 | uint16(msg[off+1]);
- fv.Set(i);
- off += 2;
+ i := uint16(msg[off])<<8 | uint16(msg[off+1])
+ fv.Set(i)
+ off += 2
case *reflect.Uint32Value:
if off+4 > len(msg) {
return len(msg), false
}
- i := uint32(msg[off])<<24 | uint32(msg[off+1])<<16 | uint32(msg[off+2])<<8 | uint32(msg[off+3]);
- fv.Set(i);
- off += 4;
+ i := uint32(msg[off])<<24 | uint32(msg[off+1])<<16 | uint32(msg[off+2])<<8 | uint32(msg[off+3])
+ fv.Set(i)
+ off += 4
case *reflect.StringValue:
- var s string;
+ var s string
switch f.Tag {
default:
- fmt.Fprintf(os.Stderr, "net: dns: unknown string tag %v", f.Tag);
- return len(msg), false;
+ fmt.Fprintf(os.Stderr, "net: dns: unknown string tag %v", f.Tag)
+ return len(msg), false
case "domain-name":
- s, off, ok = unpackDomainName(msg, off);
+ s, off, ok = unpackDomainName(msg, off)
if !ok {
return len(msg), false
}
if off >= len(msg) || off+1+int(msg[off]) > len(msg) {
return len(msg), false
}
- n := int(msg[off]);
- off++;
- b := make([]byte, n);
+ n := int(msg[off])
+ off++
+ b := make([]byte, n)
for i := 0; i < n; i++ {
b[i] = msg[off+i]
}
- off += n;
- s = string(b);
+ off += n
+ s = string(b)
}
- fv.Set(s);
+ fv.Set(s)
}
}
- return off, true;
+ return off, true
}
func unpackStruct(any interface{}, msg []byte, off int) (off1 int, ok bool) {
- off, ok = unpackStructValue(structValue(any), msg, off);
- return off, ok;
+ off, ok = unpackStructValue(structValue(any), msg, off)
+ return off, ok
}
// Generic struct printer.
// but does look for an "ipv4" tag on uint32 variables,
// printing them as IP addresses.
func printStructValue(val *reflect.StructValue) string {
- s := "{";
+ s := "{"
for i := 0; i < val.NumField(); i++ {
if i > 0 {
s += ", "
}
- f := val.Type().(*reflect.StructType).Field(i);
+ f := val.Type().(*reflect.StructType).Field(i)
if !f.Anonymous {
s += f.Name + "="
}
- fval := val.Field(i);
+ fval := val.Field(i)
if fv, ok := fval.(*reflect.StructValue); ok {
s += printStructValue(fv)
} else if fv, ok := fval.(*reflect.Uint32Value); ok && f.Tag == "ipv4" {
- i := fv.Get();
- s += IPv4(byte(i>>24), byte(i>>16), byte(i>>8), byte(i)).String();
+ i := fv.Get()
+ s += IPv4(byte(i>>24), byte(i>>16), byte(i>>8), byte(i)).String()
} else {
s += fmt.Sprint(fval.Interface())
}
}
- s += "}";
- return s;
+ s += "}"
+ return s
}
-func printStruct(any interface{}) string { return printStructValue(structValue(any)) }
+func printStruct(any interface{}) string { return printStructValue(structValue(any)) }
// Resource record packer.
func packRR(rr _DNS_RR, msg []byte, off int) (off2 int, ok bool) {
- var off1 int;
+ var off1 int
// pack twice, once to find end of header
// and again to find end of packet.
// a bit inefficient but this doesn't need to be fast.
// off1 is end of header
// off2 is end of rr
- off1, ok = packStruct(rr.Header(), msg, off);
- off2, ok = packStruct(rr, msg, off);
+ off1, ok = packStruct(rr.Header(), msg, off)
+ off2, ok = packStruct(rr, msg, off)
if !ok {
return len(msg), false
}
// pack a third time; redo header with correct data length
- rr.Header().Rdlength = uint16(off2 - off1);
- packStruct(rr.Header(), msg, off);
- return off2, true;
+ rr.Header().Rdlength = uint16(off2 - off1)
+ packStruct(rr.Header(), msg, off)
+ return off2, true
}
// Resource record unpacker.
func unpackRR(msg []byte, off int) (rr _DNS_RR, off1 int, ok bool) {
// unpack just the header, to find the rr type and length
- var h _DNS_RR_Header;
- off0 := off;
+ var h _DNS_RR_Header
+ off0 := off
if off, ok = unpackStruct(&h, msg, off); !ok {
return nil, len(msg), false
}
- end := off + int(h.Rdlength);
+ end := off + int(h.Rdlength)
// make an rr of that type and re-unpack.
// again inefficient but doesn't need to be fast.
- mk, known := rr_mk[int(h.Rrtype)];
+ mk, known := rr_mk[int(h.Rrtype)]
if !known {
return &h, end, true
}
- rr = mk();
- off, ok = unpackStruct(rr, msg, off0);
+ rr = mk()
+ off, ok = unpackStruct(rr, msg, off0)
if off != end {
return &h, end, true
}
- return rr, off, ok;
+ return rr, off, ok
}
// Usable representation of a DNS packet.
// A manually-unpacked version of (id, bits).
// This is in its own struct for easy printing.
type __DNS_Msg_Top struct {
- id uint16;
- response bool;
- opcode int;
- authoritative bool;
- truncated bool;
- recursion_desired bool;
- recursion_available bool;
- rcode int;
+ id uint16
+ response bool
+ opcode int
+ authoritative bool
+ truncated bool
+ recursion_desired bool
+ recursion_available bool
+ rcode int
}
type _DNS_Msg struct {
- __DNS_Msg_Top;
- question []_DNS_Question;
- answer []_DNS_RR;
- ns []_DNS_RR;
- extra []_DNS_RR;
+ __DNS_Msg_Top
+ question []_DNS_Question
+ answer []_DNS_RR
+ ns []_DNS_RR
+ extra []_DNS_RR
}
func (dns *_DNS_Msg) Pack() (msg []byte, ok bool) {
- var dh __DNS_Header;
+ var dh __DNS_Header
// Convert convenient _DNS_Msg into wire-like __DNS_Header.
- dh.Id = dns.id;
- dh.Bits = uint16(dns.opcode)<<11 | uint16(dns.rcode);
+ dh.Id = dns.id
+ dh.Bits = uint16(dns.opcode)<<11 | uint16(dns.rcode)
if dns.recursion_available {
dh.Bits |= _RA
}
}
// Prepare variable sized arrays.
- question := dns.question;
- answer := dns.answer;
- ns := dns.ns;
- extra := dns.extra;
+ question := dns.question
+ answer := dns.answer
+ ns := dns.ns
+ extra := dns.extra
- dh.Qdcount = uint16(len(question));
- dh.Ancount = uint16(len(answer));
- dh.Nscount = uint16(len(ns));
- dh.Arcount = uint16(len(extra));
+ dh.Qdcount = uint16(len(question))
+ dh.Ancount = uint16(len(answer))
+ dh.Nscount = uint16(len(ns))
+ dh.Arcount = uint16(len(extra))
// Could work harder to calculate message size,
// but this is far more than we need and not
// big enough to hurt the allocator.
- msg = make([]byte, 2000);
+ msg = make([]byte, 2000)
// Pack it in: header and then the pieces.
- off := 0;
- off, ok = packStruct(&dh, msg, off);
+ off := 0
+ off, ok = packStruct(&dh, msg, off)
for i := 0; i < len(question); i++ {
off, ok = packStruct(&question[i], msg, off)
}
if !ok {
return nil, false
}
- return msg[0:off], true;
+ return msg[0:off], true
}
func (dns *_DNS_Msg) Unpack(msg []byte) bool {
// Header.
- var dh __DNS_Header;
- off := 0;
- var ok bool;
+ var dh __DNS_Header
+ off := 0
+ var ok bool
if off, ok = unpackStruct(&dh, msg, off); !ok {
return false
}
- dns.id = dh.Id;
- dns.response = (dh.Bits & _QR) != 0;
- dns.opcode = int(dh.Bits>>11) & 0xF;
- dns.authoritative = (dh.Bits & _AA) != 0;
- dns.truncated = (dh.Bits & _TC) != 0;
- dns.recursion_desired = (dh.Bits & _RD) != 0;
- dns.recursion_available = (dh.Bits & _RA) != 0;
- dns.rcode = int(dh.Bits & 0xF);
+ dns.id = dh.Id
+ dns.response = (dh.Bits & _QR) != 0
+ dns.opcode = int(dh.Bits>>11) & 0xF
+ dns.authoritative = (dh.Bits & _AA) != 0
+ dns.truncated = (dh.Bits & _TC) != 0
+ dns.recursion_desired = (dh.Bits & _RD) != 0
+ dns.recursion_available = (dh.Bits & _RA) != 0
+ dns.rcode = int(dh.Bits & 0xF)
// Arrays.
- dns.question = make([]_DNS_Question, dh.Qdcount);
- dns.answer = make([]_DNS_RR, dh.Ancount);
- dns.ns = make([]_DNS_RR, dh.Nscount);
- dns.extra = make([]_DNS_RR, dh.Arcount);
+ dns.question = make([]_DNS_Question, dh.Qdcount)
+ dns.answer = make([]_DNS_RR, dh.Ancount)
+ dns.ns = make([]_DNS_RR, dh.Nscount)
+ dns.extra = make([]_DNS_RR, dh.Arcount)
for i := 0; i < len(dns.question); i++ {
off, ok = unpackStruct(&dns.question[i], msg, off)
// if off != len(msg) {
// println("extra bytes in dns packet", off, "<", len(msg));
// }
- return true;
+ return true
}
func (dns *_DNS_Msg) String() string {
- s := "DNS: " + printStruct(&dns.__DNS_Msg_Top) + "\n";
+ s := "DNS: " + printStruct(&dns.__DNS_Msg_Top) + "\n"
if len(dns.question) > 0 {
- s += "-- Questions\n";
+ s += "-- Questions\n"
for i := 0; i < len(dns.question); i++ {
s += printStruct(&dns.question[i]) + "\n"
}
}
if len(dns.answer) > 0 {
- s += "-- Answers\n";
+ s += "-- Answers\n"
for i := 0; i < len(dns.answer); i++ {
s += printStruct(dns.answer[i]) + "\n"
}
}
if len(dns.ns) > 0 {
- s += "-- Name servers\n";
+ s += "-- Name servers\n"
for i := 0; i < len(dns.ns); i++ {
s += printStruct(dns.ns[i]) + "\n"
}
}
if len(dns.extra) > 0 {
- s += "-- Extra\n";
+ s += "-- Extra\n"
for i := 0; i < len(dns.extra); i++ {
s += printStruct(dns.extra[i]) + "\n"
}
}
- return s;
+ return s
}
package net
import (
- "once";
- "os";
- "sync";
- "syscall";
+ "once"
+ "os"
+ "sync"
+ "syscall"
)
// Network file descriptor.
type netFD struct {
// locking/lifetime of sysfd
- sysmu sync.Mutex;
- sysref int;
- closing bool;
+ sysmu sync.Mutex
+ sysref int
+ closing bool
// immutable until Close
- sysfd int;
- family int;
- proto int;
- sysfile *os.File;
- cr chan *netFD;
- cw chan *netFD;
- net string;
- laddr Addr;
- raddr Addr;
+ sysfd int
+ family int
+ proto int
+ sysfile *os.File
+ cr chan *netFD
+ cw chan *netFD
+ net string
+ laddr Addr
+ raddr Addr
// owned by client
- rdeadline_delta int64;
- rdeadline int64;
- rio sync.Mutex;
- wdeadline_delta int64;
- wdeadline int64;
- wio sync.Mutex;
+ rdeadline_delta int64
+ rdeadline int64
+ rio sync.Mutex
+ wdeadline_delta int64
+ wdeadline int64
+ wio sync.Mutex
// owned by fd wait server
- ncr, ncw int;
+ ncr, ncw int
}
// A pollServer helps FDs determine when to retry a non-blocking
// will the fd be closed.
type pollServer struct {
- cr, cw chan *netFD; // buffered >= 1
- pr, pw *os.File;
- pending map[int]*netFD;
- poll *pollster; // low-level OS hooks
- deadline int64; // next deadline (nsec since 1970)
+ cr, cw chan *netFD // buffered >= 1
+ pr, pw *os.File
+ pending map[int]*netFD
+ poll *pollster // low-level OS hooks
+ deadline int64 // next deadline (nsec since 1970)
}
func newPollServer() (s *pollServer, err os.Error) {
- s = new(pollServer);
- s.cr = make(chan *netFD, 1);
- s.cw = make(chan *netFD, 1);
+ s = new(pollServer)
+ s.cr = make(chan *netFD, 1)
+ s.cw = make(chan *netFD, 1)
if s.pr, s.pw, err = os.Pipe(); err != nil {
return nil, err
}
- var e int;
+ var e int
if e = syscall.SetNonblock(s.pr.Fd(), true); e != 0 {
Errno:
- err = &os.PathError{"setnonblock", s.pr.Name(), os.Errno(e)};
+ err = &os.PathError{"setnonblock", s.pr.Name(), os.Errno(e)}
Error:
- s.pr.Close();
- s.pw.Close();
- return nil, err;
+ s.pr.Close()
+ s.pw.Close()
+ return nil, err
}
if e = syscall.SetNonblock(s.pw.Fd(), true); e != 0 {
goto Errno
goto Error
}
if err = s.poll.AddFD(s.pr.Fd(), 'r', true); err != nil {
- s.poll.Close();
- goto Error;
+ s.poll.Close()
+ goto Error
}
- s.pending = make(map[int]*netFD);
- go s.Run();
- return s, nil;
+ s.pending = make(map[int]*netFD)
+ go s.Run()
+ return s, nil
}
func (s *pollServer) AddFD(fd *netFD, mode int) {
- intfd := fd.sysfd;
+ intfd := fd.sysfd
if intfd < 0 {
// fd closed underfoot
if mode == 'r' {
} else {
fd.cw <- fd
}
- return;
+ return
}
if err := s.poll.AddFD(intfd, mode, false); err != nil {
- panicln("pollServer AddFD ", intfd, ": ", err.String(), "\n");
- return;
+ panicln("pollServer AddFD ", intfd, ": ", err.String(), "\n")
+ return
}
- var t int64;
- key := intfd << 1;
+ var t int64
+ key := intfd << 1
if mode == 'r' {
- fd.ncr++;
- t = fd.rdeadline;
+ fd.ncr++
+ t = fd.rdeadline
} else {
- fd.ncw++;
- key++;
- t = fd.wdeadline;
+ fd.ncw++
+ key++
+ t = fd.wdeadline
}
- s.pending[key] = fd;
+ s.pending[key] = fd
if t > 0 && (s.deadline == 0 || t < s.deadline) {
s.deadline = t
}
}
func (s *pollServer) LookupFD(fd int, mode int) *netFD {
- key := fd << 1;
+ key := fd << 1
if mode == 'w' {
key++
}
- netfd, ok := s.pending[key];
+ netfd, ok := s.pending[key]
if !ok {
return nil
}
- s.pending[key] = nil, false;
- return netfd;
+ s.pending[key] = nil, false
+ return netfd
}
func (s *pollServer) WakeFD(fd *netFD, mode int) {
if mode == 'r' {
for fd.ncr > 0 {
- fd.ncr--;
- fd.cr <- fd;
+ fd.ncr--
+ fd.cr <- fd
}
} else {
for fd.ncw > 0 {
- fd.ncw--;
- fd.cw <- fd;
+ fd.ncw--
+ fd.cw <- fd
}
}
}
func (s *pollServer) Now() int64 {
- sec, nsec, err := os.Time();
+ sec, nsec, err := os.Time()
if err != nil {
panic("net: os.Time: ", err.String())
}
- nsec += sec * 1e9;
- return nsec;
+ nsec += sec * 1e9
+ return nsec
}
func (s *pollServer) CheckDeadlines() {
- now := s.Now();
+ now := s.Now()
// TODO(rsc): This will need to be handled more efficiently,
// probably with a heap indexed by wakeup time.
- var next_deadline int64;
+ var next_deadline int64
for key, fd := range s.pending {
- var t int64;
- var mode int;
+ var t int64
+ var mode int
if key&1 == 0 {
mode = 'r'
} else {
}
if t > 0 {
if t <= now {
- s.pending[key] = nil, false;
+ s.pending[key] = nil, false
if mode == 'r' {
- s.poll.DelFD(fd.sysfd, mode);
- fd.rdeadline = -1;
+ s.poll.DelFD(fd.sysfd, mode)
+ fd.rdeadline = -1
} else {
- s.poll.DelFD(fd.sysfd, mode);
- fd.wdeadline = -1;
+ s.poll.DelFD(fd.sysfd, mode)
+ fd.wdeadline = -1
}
- s.WakeFD(fd, mode);
+ s.WakeFD(fd, mode)
} else if next_deadline == 0 || t < next_deadline {
next_deadline = t
}
}
}
- s.deadline = next_deadline;
+ s.deadline = next_deadline
}
func (s *pollServer) Run() {
- var scratch [100]byte;
+ var scratch [100]byte
for {
- var t = s.deadline;
+ var t = s.deadline
if t > 0 {
- t = t - s.Now();
+ t = t - s.Now()
if t < 0 {
- s.CheckDeadlines();
- continue;
+ s.CheckDeadlines()
+ continue
}
}
- fd, mode, err := s.poll.WaitFD(t);
+ fd, mode, err := s.poll.WaitFD(t)
if err != nil {
- print("pollServer WaitFD: ", err.String(), "\n");
- return;
+ print("pollServer WaitFD: ", err.String(), "\n")
+ return
}
if fd < 0 {
// Timeout happened.
- s.CheckDeadlines();
- continue;
+ s.CheckDeadlines()
+ continue
}
if fd == s.pr.Fd() {
// Drain our wakeup pipe.
s.AddFD(fd, 'w')
}
} else {
- netfd := s.LookupFD(fd, mode);
+ netfd := s.LookupFD(fd, mode)
if netfd == nil {
- print("pollServer: unexpected wakeup for fd=", netfd, " mode=", string(mode), "\n");
- continue;
+ print("pollServer: unexpected wakeup for fd=", netfd, " mode=", string(mode), "\n")
+ continue
}
- s.WakeFD(netfd, mode);
+ s.WakeFD(netfd, mode)
}
}
}
var wakeupbuf [1]byte
-func (s *pollServer) Wakeup() { s.pw.Write(&wakeupbuf) }
+func (s *pollServer) Wakeup() { s.pw.Write(&wakeupbuf) }
func (s *pollServer) WaitRead(fd *netFD) {
- s.cr <- fd;
- s.Wakeup();
- <-fd.cr;
+ s.cr <- fd
+ s.Wakeup()
+ <-fd.cr
}
func (s *pollServer) WaitWrite(fd *netFD) {
- s.cw <- fd;
- s.Wakeup();
- <-fd.cw;
+ s.cw <- fd
+ s.Wakeup()
+ <-fd.cw
}
// Network FD methods.
var pollserver *pollServer
func startServer() {
- p, err := newPollServer();
+ p, err := newPollServer()
if err != nil {
print("Start pollServer: ", err.String(), "\n")
}
- pollserver = p;
+ pollserver = p
}
func newFD(fd, family, proto int, net string, laddr, raddr Addr) (f *netFD, err os.Error) {
- once.Do(startServer);
+ once.Do(startServer)
if e := syscall.SetNonblock(fd, true); e != 0 {
return nil, &OpError{"setnonblock", net, laddr, os.Errno(e)}
}
net: net,
laddr: laddr,
raddr: raddr,
- };
- var ls, rs string;
+ }
+ var ls, rs string
if laddr != nil {
ls = laddr.String()
}
if raddr != nil {
rs = raddr.String()
}
- f.sysfile = os.NewFile(fd, net+":"+ls+"->"+rs);
- f.cr = make(chan *netFD, 1);
- f.cw = make(chan *netFD, 1);
- return f, nil;
+ f.sysfile = os.NewFile(fd, net+":"+ls+"->"+rs)
+ f.cr = make(chan *netFD, 1)
+ f.cw = make(chan *netFD, 1)
+ return f, nil
}
// Add a reference to this fd.
func (fd *netFD) incref() {
- fd.sysmu.Lock();
- fd.sysref++;
- fd.sysmu.Unlock();
+ fd.sysmu.Lock()
+ fd.sysref++
+ fd.sysmu.Unlock()
}
// Remove a reference to this FD and close if we've been asked to do so (and
// there are no references left.
func (fd *netFD) decref() {
- fd.sysmu.Lock();
- fd.sysref--;
+ fd.sysmu.Lock()
+ fd.sysref--
if fd.closing && fd.sysref == 0 && fd.sysfd >= 0 {
// In case the user has set linger, switch to blocking mode so
// the close blocks. As long as this doesn't happen often, we
// can handle the extra OS processes. Otherwise we'll need to
// use the pollserver for Close too. Sigh.
- syscall.SetNonblock(fd.sysfd, false);
- fd.sysfile.Close();
- fd.sysfile = nil;
- fd.sysfd = -1;
+ syscall.SetNonblock(fd.sysfd, false)
+ fd.sysfile.Close()
+ fd.sysfile = nil
+ fd.sysfd = -1
}
- fd.sysmu.Unlock();
+ fd.sysmu.Unlock()
}
func isEAGAIN(e os.Error) bool {
if e1, ok := e.(*os.PathError); ok {
return e1.Error == os.EAGAIN
}
- return e == os.EAGAIN;
+ return e == os.EAGAIN
}
func (fd *netFD) Close() os.Error {
return os.EINVAL
}
- fd.incref();
- syscall.Shutdown(fd.sysfd, syscall.SHUT_RDWR);
- fd.closing = true;
- fd.decref();
- return nil;
+ fd.incref()
+ syscall.Shutdown(fd.sysfd, syscall.SHUT_RDWR)
+ fd.closing = true
+ fd.decref()
+ return nil
}
func (fd *netFD) Read(p []byte) (n int, err os.Error) {
if fd == nil || fd.sysfile == nil {
return 0, os.EINVAL
}
- fd.rio.Lock();
- defer fd.rio.Unlock();
- fd.incref();
- defer fd.decref();
+ fd.rio.Lock()
+ defer fd.rio.Unlock()
+ fd.incref()
+ defer fd.decref()
if fd.rdeadline_delta > 0 {
fd.rdeadline = pollserver.Now() + fd.rdeadline_delta
} else {
fd.rdeadline = 0
}
for {
- n, err = fd.sysfile.Read(p);
+ n, err = fd.sysfile.Read(p)
if isEAGAIN(err) && fd.rdeadline >= 0 {
- pollserver.WaitRead(fd);
- continue;
+ pollserver.WaitRead(fd)
+ continue
}
- break;
+ break
}
if fd.proto == syscall.SOCK_DGRAM && err == os.EOF {
// 0 in datagram protocol just means 0-length packet
err = nil
}
- return;
+ return
}
func (fd *netFD) ReadFrom(p []byte) (n int, sa syscall.Sockaddr, err os.Error) {
if fd == nil || fd.sysfile == nil {
return 0, nil, os.EINVAL
}
- fd.rio.Lock();
- defer fd.rio.Unlock();
- fd.incref();
- defer fd.decref();
+ fd.rio.Lock()
+ defer fd.rio.Unlock()
+ fd.incref()
+ defer fd.decref()
if fd.rdeadline_delta > 0 {
fd.rdeadline = pollserver.Now() + fd.rdeadline_delta
} else {
fd.rdeadline = 0
}
for {
- var errno int;
- n, sa, errno = syscall.Recvfrom(fd.sysfd, p, 0);
+ var errno int
+ n, sa, errno = syscall.Recvfrom(fd.sysfd, p, 0)
if errno == syscall.EAGAIN && fd.rdeadline >= 0 {
- pollserver.WaitRead(fd);
- continue;
+ pollserver.WaitRead(fd)
+ continue
}
if errno != 0 {
- n = 0;
- err = &os.PathError{"recvfrom", fd.sysfile.Name(), os.Errno(errno)};
+ n = 0
+ err = &os.PathError{"recvfrom", fd.sysfile.Name(), os.Errno(errno)}
}
- break;
+ break
}
- return;
+ return
}
func (fd *netFD) Write(p []byte) (n int, err os.Error) {
if fd == nil || fd.sysfile == nil {
return 0, os.EINVAL
}
- fd.wio.Lock();
- defer fd.wio.Unlock();
- fd.incref();
- defer fd.decref();
+ fd.wio.Lock()
+ defer fd.wio.Unlock()
+ fd.incref()
+ defer fd.decref()
if fd.wdeadline_delta > 0 {
fd.wdeadline = pollserver.Now() + fd.wdeadline_delta
} else {
fd.wdeadline = 0
}
- err = nil;
- nn := 0;
- first := true; // force at least one Write, to send 0-length datagram packets
+ err = nil
+ nn := 0
+ first := true // force at least one Write, to send 0-length datagram packets
for nn < len(p) || first {
- first = false;
- n, err = fd.sysfile.Write(p[nn:]);
+ first = false
+ n, err = fd.sysfile.Write(p[nn:])
if n > 0 {
nn += n
}
break
}
if isEAGAIN(err) && fd.wdeadline >= 0 {
- pollserver.WaitWrite(fd);
- continue;
+ pollserver.WaitWrite(fd)
+ continue
}
if n == 0 || err != nil {
break
}
}
- return nn, err;
+ return nn, err
}
func (fd *netFD) WriteTo(p []byte, sa syscall.Sockaddr) (n int, err os.Error) {
if fd == nil || fd.sysfile == nil {
return 0, os.EINVAL
}
- fd.wio.Lock();
- defer fd.wio.Unlock();
- fd.incref();
- defer fd.decref();
+ fd.wio.Lock()
+ defer fd.wio.Unlock()
+ fd.incref()
+ defer fd.decref()
if fd.wdeadline_delta > 0 {
fd.wdeadline = pollserver.Now() + fd.wdeadline_delta
} else {
fd.wdeadline = 0
}
- err = nil;
+ err = nil
for {
- errno := syscall.Sendto(fd.sysfd, p, 0, sa);
+ errno := syscall.Sendto(fd.sysfd, p, 0, sa)
if errno == syscall.EAGAIN && fd.wdeadline >= 0 {
- pollserver.WaitWrite(fd);
- continue;
+ pollserver.WaitWrite(fd)
+ continue
}
if errno != 0 {
err = &os.PathError{"sendto", fd.sysfile.Name(), os.Errno(errno)}
}
- break;
+ break
}
if err == nil {
n = len(p)
}
- return;
+ return
}
func (fd *netFD) accept(toAddr func(syscall.Sockaddr) Addr) (nfd *netFD, err os.Error) {
return nil, os.EINVAL
}
- fd.incref();
- defer fd.decref();
+ fd.incref()
+ defer fd.decref()
// See ../syscall/exec.go for description of ForkLock.
// It is okay to hold the lock across syscall.Accept
// because we have put fd.sysfd into non-blocking mode.
- syscall.ForkLock.RLock();
- var s, e int;
- var sa syscall.Sockaddr;
+ syscall.ForkLock.RLock()
+ var s, e int
+ var sa syscall.Sockaddr
for {
- s, sa, e = syscall.Accept(fd.sysfd);
+ s, sa, e = syscall.Accept(fd.sysfd)
if e != syscall.EAGAIN {
break
}
- syscall.ForkLock.RUnlock();
- pollserver.WaitRead(fd);
- syscall.ForkLock.RLock();
+ syscall.ForkLock.RUnlock()
+ pollserver.WaitRead(fd)
+ syscall.ForkLock.RLock()
}
if e != 0 {
- syscall.ForkLock.RUnlock();
- return nil, &OpError{"accept", fd.net, fd.laddr, os.Errno(e)};
+ syscall.ForkLock.RUnlock()
+ return nil, &OpError{"accept", fd.net, fd.laddr, os.Errno(e)}
}
- syscall.CloseOnExec(s);
- syscall.ForkLock.RUnlock();
+ syscall.CloseOnExec(s)
+ syscall.ForkLock.RUnlock()
if nfd, err = newFD(s, fd.family, fd.proto, fd.net, fd.laddr, toAddr(sa)); err != nil {
- syscall.Close(s);
- return nil, err;
+ syscall.Close(s)
+ return nil, err
}
- return nfd, nil;
+ return nfd, nil
}
package net
import (
- "os";
- "syscall";
+ "os"
+ "syscall"
)
type pollster struct {
- kq int;
- eventbuf [10]syscall.Kevent_t;
- events []syscall.Kevent_t;
+ kq int
+ eventbuf [10]syscall.Kevent_t
+ events []syscall.Kevent_t
}
func newpollster() (p *pollster, err os.Error) {
- p = new(pollster);
- var e int;
+ p = new(pollster)
+ var e int
if p.kq, e = syscall.Kqueue(); e != 0 {
return nil, os.NewSyscallError("kqueue", e)
}
- p.events = p.eventbuf[0:0];
- return p, nil;
+ p.events = p.eventbuf[0:0]
+ return p, nil
}
func (p *pollster) AddFD(fd int, mode int, repeat bool) os.Error {
- var kmode int;
+ var kmode int
if mode == 'r' {
kmode = syscall.EVFILT_READ
} else {
kmode = syscall.EVFILT_WRITE
}
- var events [1]syscall.Kevent_t;
- ev := &events[0];
+ var events [1]syscall.Kevent_t
+ ev := &events[0]
// EV_ADD - add event to kqueue list
// EV_RECEIPT - generate fake EV_ERROR as result of add,
// rather than waiting for real event
// EV_ONESHOT - delete the event the first time it triggers
- flags := syscall.EV_ADD | syscall.EV_RECEIPT;
+ flags := syscall.EV_ADD | syscall.EV_RECEIPT
if !repeat {
flags |= syscall.EV_ONESHOT
}
- syscall.SetKevent(ev, fd, kmode, flags);
+ syscall.SetKevent(ev, fd, kmode, flags)
- n, e := syscall.Kevent(p.kq, &events, &events, nil);
+ n, e := syscall.Kevent(p.kq, &events, &events, nil)
if e != 0 {
return os.NewSyscallError("kevent", e)
}
if ev.Data != 0 {
return os.Errno(int(ev.Data))
}
- return nil;
+ return nil
}
func (p *pollster) DelFD(fd int, mode int) {
- var kmode int;
+ var kmode int
if mode == 'r' {
kmode = syscall.EVFILT_READ
} else {
kmode = syscall.EVFILT_WRITE
}
- var events [1]syscall.Kevent_t;
- ev := &events[0];
+ var events [1]syscall.Kevent_t
+ ev := &events[0]
// EV_DELETE - delete event from kqueue list
// EV_RECEIPT - generate fake EV_ERROR as result of add,
// rather than waiting for real event
- syscall.SetKevent(ev, fd, kmode, syscall.EV_DELETE|syscall.EV_RECEIPT);
- syscall.Kevent(p.kq, &events, &events, nil);
+ syscall.SetKevent(ev, fd, kmode, syscall.EV_DELETE|syscall.EV_RECEIPT)
+ syscall.Kevent(p.kq, &events, &events, nil)
}
func (p *pollster) WaitFD(nsec int64) (fd int, mode int, err os.Error) {
- var t *syscall.Timespec;
+ var t *syscall.Timespec
for len(p.events) == 0 {
if nsec > 0 {
if t == nil {
t = new(syscall.Timespec)
}
- *t = syscall.NsecToTimespec(nsec);
+ *t = syscall.NsecToTimespec(nsec)
}
- nn, e := syscall.Kevent(p.kq, nil, &p.eventbuf, t);
+ nn, e := syscall.Kevent(p.kq, nil, &p.eventbuf, t)
if e != 0 {
if e == syscall.EINTR {
continue
}
- return -1, 0, os.NewSyscallError("kevent", e);
+ return -1, 0, os.NewSyscallError("kevent", e)
}
if nn == 0 {
return -1, 0, nil
}
- p.events = p.eventbuf[0:nn];
+ p.events = p.eventbuf[0:nn]
}
- ev := &p.events[0];
- p.events = p.events[1:];
- fd = int(ev.Ident);
+ ev := &p.events[0]
+ p.events = p.events[1:]
+ fd = int(ev.Ident)
if ev.Filter == syscall.EVFILT_READ {
mode = 'r'
} else {
mode = 'w'
}
- return fd, mode, nil;
+ return fd, mode, nil
}
-func (p *pollster) Close() os.Error { return os.NewSyscallError("close", syscall.Close(p.kq)) }
+func (p *pollster) Close() os.Error { return os.NewSyscallError("close", syscall.Close(p.kq)) }
package net
import (
- "os";
- "syscall";
+ "os"
+ "syscall"
)
type pollster struct {
- kq int;
- eventbuf [10]syscall.Kevent_t;
- events []syscall.Kevent_t;
+ kq int
+ eventbuf [10]syscall.Kevent_t
+ events []syscall.Kevent_t
}
func newpollster() (p *pollster, err os.Error) {
- p = new(pollster);
- var e int;
+ p = new(pollster)
+ var e int
if p.kq, e = syscall.Kqueue(); e != 0 {
return nil, os.NewSyscallError("kqueue", e)
}
- p.events = p.eventbuf[0:0];
- return p, nil;
+ p.events = p.eventbuf[0:0]
+ return p, nil
}
func (p *pollster) AddFD(fd int, mode int, repeat bool) os.Error {
- var kmode int;
+ var kmode int
if mode == 'r' {
kmode = syscall.EVFILT_READ
} else {
kmode = syscall.EVFILT_WRITE
}
- var events [1]syscall.Kevent_t;
- ev := &events[0];
+ var events [1]syscall.Kevent_t
+ ev := &events[0]
// EV_ADD - add event to kqueue list
// EV_ONESHOT - delete the event the first time it triggers
- flags := syscall.EV_ADD;
+ flags := syscall.EV_ADD
if !repeat {
flags |= syscall.EV_ONESHOT
}
- syscall.SetKevent(ev, fd, kmode, flags);
+ syscall.SetKevent(ev, fd, kmode, flags)
- n, e := syscall.Kevent(p.kq, &events, nil, nil);
+ n, e := syscall.Kevent(p.kq, &events, nil, nil)
if e != 0 {
return os.NewSyscallError("kevent", e)
}
if ev.Data != 0 {
return os.Errno(int(ev.Data))
}
- return nil;
+ return nil
}
func (p *pollster) DelFD(fd int, mode int) {
- var kmode int;
+ var kmode int
if mode == 'r' {
kmode = syscall.EVFILT_READ
} else {
kmode = syscall.EVFILT_WRITE
}
- var events [1]syscall.Kevent_t;
- ev := &events[0];
+ var events [1]syscall.Kevent_t
+ ev := &events[0]
// EV_DELETE - delete event from kqueue list
- syscall.SetKevent(ev, fd, kmode, syscall.EV_DELETE);
- syscall.Kevent(p.kq, &events, nil, nil);
+ syscall.SetKevent(ev, fd, kmode, syscall.EV_DELETE)
+ syscall.Kevent(p.kq, &events, nil, nil)
}
func (p *pollster) WaitFD(nsec int64) (fd int, mode int, err os.Error) {
- var t *syscall.Timespec;
+ var t *syscall.Timespec
for len(p.events) == 0 {
if nsec > 0 {
if t == nil {
t = new(syscall.Timespec)
}
- *t = syscall.NsecToTimespec(nsec);
+ *t = syscall.NsecToTimespec(nsec)
}
- nn, e := syscall.Kevent(p.kq, nil, &p.eventbuf, t);
+ nn, e := syscall.Kevent(p.kq, nil, &p.eventbuf, t)
if e != 0 {
if e == syscall.EINTR {
continue
}
- return -1, 0, os.NewSyscallError("kevent", e);
+ return -1, 0, os.NewSyscallError("kevent", e)
}
if nn == 0 {
return -1, 0, nil
}
- p.events = p.eventbuf[0:nn];
+ p.events = p.eventbuf[0:nn]
}
- ev := &p.events[0];
- p.events = p.events[1:];
- fd = int(ev.Ident);
+ ev := &p.events[0]
+ p.events = p.events[1:]
+ fd = int(ev.Ident)
if ev.Filter == syscall.EVFILT_READ {
mode = 'r'
} else {
mode = 'w'
}
- return fd, mode, nil;
+ return fd, mode, nil
}
-func (p *pollster) Close() os.Error { return os.NewSyscallError("close", syscall.Close(p.kq)) }
+func (p *pollster) Close() os.Error { return os.NewSyscallError("close", syscall.Close(p.kq)) }
package net
import (
- "os";
- "syscall";
+ "os"
+ "syscall"
)
const (
- readFlags = syscall.EPOLLIN | syscall.EPOLLRDHUP;
- writeFlags = syscall.EPOLLOUT;
+ readFlags = syscall.EPOLLIN | syscall.EPOLLRDHUP
+ writeFlags = syscall.EPOLLOUT
)
type pollster struct {
- epfd int;
+ epfd int
// Events we're already waiting for
- events map[int]uint32;
+ events map[int]uint32
}
func newpollster() (p *pollster, err os.Error) {
- p = new(pollster);
- var e int;
+ p = new(pollster)
+ var e int
// The arg to epoll_create is a hint to the kernel
// about the number of FDs we will care about.
if p.epfd, e = syscall.EpollCreate(16); e != 0 {
return nil, os.NewSyscallError("epoll_create", e)
}
- p.events = make(map[int]uint32);
- return p, nil;
+ p.events = make(map[int]uint32)
+ return p, nil
}
func (p *pollster) AddFD(fd int, mode int, repeat bool) os.Error {
- var ev syscall.EpollEvent;
- var already bool;
- ev.Fd = int32(fd);
- ev.Events, already = p.events[fd];
+ var ev syscall.EpollEvent
+ var already bool
+ ev.Fd = int32(fd)
+ ev.Events, already = p.events[fd]
if !repeat {
ev.Events |= syscall.EPOLLONESHOT
}
ev.Events |= writeFlags
}
- var op int;
+ var op int
if already {
op = syscall.EPOLL_CTL_MOD
} else {
if e := syscall.EpollCtl(p.epfd, op, fd, &ev); e != 0 {
return os.NewSyscallError("epoll_ctl", e)
}
- p.events[fd] = ev.Events;
- return nil;
+ p.events[fd] = ev.Events
+ return nil
}
func (p *pollster) StopWaiting(fd int, bits uint) {
- events, already := p.events[fd];
+ events, already := p.events[fd]
if !already {
- print("Epoll unexpected fd=", fd, "\n");
- return;
+ print("Epoll unexpected fd=", fd, "\n")
+ return
}
// If syscall.EPOLLONESHOT is not set, the wait
// Disable the given bits.
// If we're still waiting for other events, modify the fd
// event in the kernel. Otherwise, delete it.
- events &= ^uint32(bits);
+ events &= ^uint32(bits)
if int32(events)&^syscall.EPOLLONESHOT != 0 {
- var ev syscall.EpollEvent;
- ev.Fd = int32(fd);
- ev.Events = events;
+ var ev syscall.EpollEvent
+ ev.Fd = int32(fd)
+ ev.Events = events
if e := syscall.EpollCtl(p.epfd, syscall.EPOLL_CTL_MOD, fd, &ev); e != 0 {
print("Epoll modify fd=", fd, ": ", os.Errno(e).String(), "\n")
}
- p.events[fd] = events;
+ p.events[fd] = events
} else {
if e := syscall.EpollCtl(p.epfd, syscall.EPOLL_CTL_DEL, fd, nil); e != 0 {
print("Epoll delete fd=", fd, ": ", os.Errno(e).String(), "\n")
}
- p.events[fd] = 0, false;
+ p.events[fd] = 0, false
}
}
func (p *pollster) WaitFD(nsec int64) (fd int, mode int, err os.Error) {
// Get an event.
- var evarray [1]syscall.EpollEvent;
- ev := &evarray[0];
- var msec int = -1;
+ var evarray [1]syscall.EpollEvent
+ ev := &evarray[0]
+ var msec int = -1
if nsec > 0 {
msec = int((nsec + 1e6 - 1) / 1e6)
}
- n, e := syscall.EpollWait(p.epfd, &evarray, msec);
+ n, e := syscall.EpollWait(p.epfd, &evarray, msec)
for e == syscall.EAGAIN || e == syscall.EINTR {
n, e = syscall.EpollWait(p.epfd, &evarray, msec)
}
if n == 0 {
return -1, 0, nil
}
- fd = int(ev.Fd);
+ fd = int(ev.Fd)
if ev.Events&writeFlags != 0 {
- p.StopWaiting(fd, writeFlags);
- return fd, 'w', nil;
+ p.StopWaiting(fd, writeFlags)
+ return fd, 'w', nil
}
if ev.Events&readFlags != 0 {
- p.StopWaiting(fd, readFlags);
- return fd, 'r', nil;
+ p.StopWaiting(fd, readFlags)
+ return fd, 'r', nil
}
// Other events are error conditions - wake whoever is waiting.
- events, _ := p.events[fd];
+ events, _ := p.events[fd]
if events&writeFlags != 0 {
- p.StopWaiting(fd, writeFlags);
- return fd, 'w', nil;
+ p.StopWaiting(fd, writeFlags)
+ return fd, 'w', nil
}
- p.StopWaiting(fd, readFlags);
- return fd, 'r', nil;
+ p.StopWaiting(fd, readFlags)
+ return fd, 'r', nil
}
func (p *pollster) Close() os.Error {
package net
import (
- "os";
- "syscall";
+ "os"
+ "syscall"
)
type pollster struct{}
}
func (p *pollster) AddFD(fd int, mode int, repeat bool) os.Error {
- _, err := newpollster();
- return err;
+ _, err := newpollster()
+ return err
}
func (p *pollster) StopWaiting(fd int, bits uint) {
}
-func (p *pollster) DelFD(fd int, mode int) {}
+func (p *pollster) DelFD(fd int, mode int) {}
func (p *pollster) WaitFD(nsec int64) (fd int, mode int, err os.Error) {
- _, err = newpollster();
- return;
+ _, err = newpollster()
+ return
}
-func (p *pollster) Close() os.Error { return nil }
+func (p *pollster) Close() os.Error { return nil }
// IP address lengths (bytes).
const (
- IPv4len = 4;
- IPv6len = 16;
+ IPv4len = 4
+ IPv6len = 16
)
// An IP is a single IP address, an array of bytes.
// IPv4 returns the IP address (in 16-byte form) of the
// IPv4 address a.b.c.d.
func IPv4(a, b, c, d byte) IP {
- p := make(IP, IPv6len);
+ p := make(IP, IPv6len)
for i := 0; i < 10; i++ {
p[i] = 0
}
- p[10] = 0xff;
- p[11] = 0xff;
- p[12] = a;
- p[13] = b;
- p[14] = c;
- p[15] = d;
- return p;
+ p[10] = 0xff
+ p[11] = 0xff
+ p[12] = a
+ p[13] = b
+ p[14] = c
+ p[15] = d
+ return p
}
// Well-known IPv4 addresses
var (
- IPv4bcast = IPv4(255, 255, 255, 255); // broadcast
- IPv4allsys = IPv4(224, 0, 0, 1); // all systems
- IPv4allrouter = IPv4(224, 0, 0, 2); // all routers
- IPv4zero = IPv4(0, 0, 0, 0); // all zeros
+ IPv4bcast = IPv4(255, 255, 255, 255) // broadcast
+ IPv4allsys = IPv4(224, 0, 0, 1) // all systems
+ IPv4allrouter = IPv4(224, 0, 0, 2) // all routers
+ IPv4zero = IPv4(0, 0, 0, 0) // all zeros
)
// Well-known IPv6 addresses
var (
- IPzero = make(IP, IPv6len); // all zeros
+ IPzero = make(IP, IPv6len) // all zeros
)
// Is p all zeros?
return false
}
}
- return true;
+ return true
}
// To4 converts the IPv4 address ip to a 4-byte representation.
ip[11] == 0xff {
return ip[12:16]
}
- return nil;
+ return nil
}
// To16 converts the IP address ip to a 16-byte representation.
if len(ip) == IPv6len {
return ip
}
- return nil;
+ return nil
}
// Default route masks for IPv4.
var (
- classAMask = IPMask(IPv4(0xff, 0, 0, 0));
- classBMask = IPMask(IPv4(0xff, 0xff, 0, 0));
- classCMask = IPMask(IPv4(0xff, 0xff, 0xff, 0));
+ classAMask = IPMask(IPv4(0xff, 0, 0, 0))
+ classBMask = IPMask(IPv4(0xff, 0xff, 0, 0))
+ classCMask = IPMask(IPv4(0xff, 0xff, 0xff, 0))
)
// DefaultMask returns the default IP mask for the IP address ip.
default:
return classCMask
}
- return nil; // not reached
+ return nil // not reached
}
// Mask returns the result of masking the IP address ip with mask.
func (ip IP) Mask(mask IPMask) IP {
- n := len(ip);
+ n := len(ip)
if n != len(mask) {
return nil
}
- out := make(IP, n);
+ out := make(IP, n)
for i := 0; i < n; i++ {
out[i] = ip[i] & mask[i]
}
- return out;
+ return out
}
// Convert i to decimal string.
}
// Assemble decimal in reverse order.
- var b [32]byte;
- bp := len(b);
+ var b [32]byte
+ bp := len(b)
for ; i > 0; i /= 10 {
- bp--;
- b[bp] = byte(i%10) + '0';
+ bp--
+ b[bp] = byte(i%10) + '0'
}
- return string(b[bp:]);
+ return string(b[bp:])
}
// Convert i to hexadecimal string.
}
// Assemble hexadecimal in reverse order.
- var b [32]byte;
- bp := len(b);
+ var b [32]byte
+ bp := len(b)
for ; i > 0; i /= 16 {
- bp--;
- b[bp] = "0123456789abcdef"[byte(i%16)];
+ bp--
+ b[bp] = "0123456789abcdef"[byte(i%16)]
}
- return string(b[bp:]);
+ return string(b[bp:])
}
// String returns the string form of the IP address ip.
// is dotted decimal ("74.125.19.99"). Otherwise the representation
// is IPv6 ("2001:4860:0:2001::68").
func (ip IP) String() string {
- p := ip;
+ p := ip
if len(ip) == 0 {
return ""
}
// Find longest run of zeros.
- e0 := -1;
- e1 := -1;
+ e0 := -1
+ e1 := -1
for i := 0; i < 16; i += 2 {
- j := i;
+ j := i
for j < 16 && p[j] == 0 && p[j+1] == 0 {
j += 2
}
if j > i && j-i > e1-e0 {
- e0 = i;
- e1 = j;
+ e0 = i
+ e1 = j
}
}
// Print with possible :: in place of run of zeros
- var s string;
+ var s string
for i := 0; i < 16; i += 2 {
if i == e0 {
- s += "::";
- i = e1;
+ s += "::"
+ i = e1
if i >= 16 {
break
}
} else if i > 0 {
s += ":"
}
- s += itox((uint(p[i]) << 8) | uint(p[i+1]));
+ s += itox((uint(p[i]) << 8) | uint(p[i+1]))
}
- return s;
+ return s
}
// If mask is a sequence of 1 bits followed by 0 bits,
// return the number of 1 bits.
func simpleMaskLength(mask IPMask) int {
- var i int;
+ var i int
for i = 0; i < len(mask); i++ {
if mask[i] != 0xFF {
break
}
}
- n := 8 * i;
- v := mask[i];
+ n := 8 * i
+ v := mask[i]
for v&0x80 != 0 {
- n++;
- v <<= 1;
+ n++
+ v <<= 1
}
if v != 0 {
return -1
return -1
}
}
- return n;
+ return n
}
// String returns the string representation of mask.
func (mask IPMask) String() string {
switch len(mask) {
case 4:
- n := simpleMaskLength(mask);
+ n := simpleMaskLength(mask)
if n >= 0 {
return itod(uint(n + (IPv6len-IPv4len)*8))
}
case 16:
- n := simpleMaskLength(mask);
+ n := simpleMaskLength(mask)
if n >= 0 {
return itod(uint(n))
}
}
- return IP(mask).String();
+ return IP(mask).String()
}
// Parse IPv4 address (d.d.d.d).
func parseIPv4(s string) IP {
- var p [IPv4len]byte;
- i := 0;
+ var p [IPv4len]byte
+ i := 0
for j := 0; j < IPv4len; j++ {
if j > 0 {
if s[i] != '.' {
return nil
}
- i++;
+ i++
}
var (
- n int;
- ok bool;
+ n int
+ ok bool
)
- n, i, ok = dtoi(s, i);
+ n, i, ok = dtoi(s, i)
if !ok || n > 0xFF {
return nil
}
- p[j] = byte(n);
+ p[j] = byte(n)
}
if i != len(s) {
return nil
}
- return IPv4(p[0], p[1], p[2], p[3]);
+ return IPv4(p[0], p[1], p[2], p[3])
}
// Parse IPv6 address. Many forms.
// * The last 32 bits can be in IPv4 form.
// Thus, ::ffff:1.2.3.4 is the IPv4 address 1.2.3.4.
func parseIPv6(s string) IP {
- p := make(IP, 16);
- ellipsis := -1; // position of ellipsis in p
- i := 0; // index in string s
+ p := make(IP, 16)
+ ellipsis := -1 // position of ellipsis in p
+ i := 0 // index in string s
// Might have leading ellipsis
if len(s) >= 2 && s[0] == ':' && s[1] == ':' {
- ellipsis = 0;
- i = 2;
+ ellipsis = 0
+ i = 2
// Might be only ellipsis
if i == len(s) {
return p
}
// Loop, parsing hex numbers followed by colon.
- j := 0;
-L: for j < IPv6len {
+ j := 0
+L: for j < IPv6len {
// Hex number.
- n, i1, ok := xtoi(s, i);
+ n, i1, ok := xtoi(s, i)
if !ok || n > 0xFFFF {
return nil
}
// Not enough room.
return nil
}
- p4 := parseIPv4(s[i:]);
+ p4 := parseIPv4(s[i:])
if p4 == nil {
return nil
}
- p[j] = p4[12];
- p[j+1] = p4[13];
- p[j+2] = p4[14];
- p[j+3] = p4[15];
- i = len(s);
- j += 4;
- break;
+ p[j] = p4[12]
+ p[j+1] = p4[13]
+ p[j+2] = p4[14]
+ p[j+3] = p4[15]
+ i = len(s)
+ j += 4
+ break
}
// Save this 16-bit chunk.
- p[j] = byte(n >> 8);
- p[j+1] = byte(n);
- j += 2;
+ p[j] = byte(n >> 8)
+ p[j+1] = byte(n)
+ j += 2
// Stop at end of string.
- i = i1;
+ i = i1
if i == len(s) {
break
}
if s[i] != ':' && i+1 == len(s) {
return nil
}
- i++;
+ i++
// Look for ellipsis.
if s[i] == ':' {
- if ellipsis >= 0 { // already have one
+ if ellipsis >= 0 { // already have one
return nil
}
- ellipsis = j;
- if i++; i == len(s) { // can be at end
+ ellipsis = j
+ if i++; i == len(s) { // can be at end
break
}
}
if ellipsis < 0 {
return nil
}
- n := IPv6len - j;
+ n := IPv6len - j
for k := j - 1; k >= ellipsis; k-- {
p[k+n] = p[k]
}
p[k] = 0
}
}
- return p;
+ return p
}
// ParseIP parses s as an IP address, returning the result.
// If s is not a valid textual representation of an IP address,
// ParseIP returns nil.
func ParseIP(s string) IP {
- p := parseIPv4(s);
+ p := parseIPv4(s)
if p != nil {
return p
}
- return parseIPv6(s);
+ return parseIPv6(s)
}
package net
import (
- "testing";
+ "testing"
)
func isEqual(a, b IP) bool {
return false
}
}
- return true;
+ return true
}
type parseIPTest struct {
- in string;
- out IP;
+ in string
+ out IP
}
var parseiptests = []parseIPTest{
func TestParseIP(t *testing.T) {
for i := 0; i < len(parseiptests); i++ {
- tt := parseiptests[i];
+ tt := parseiptests[i]
if out := ParseIP(tt.in); !isEqual(out, tt.out) {
t.Errorf("ParseIP(%#q) = %v, want %v", tt.in, out, tt.out)
}
package net
import (
- "os";
- "syscall";
+ "os"
+ "syscall"
)
// Should we try to use the IPv4 socket interface if we're
if syscall.OS == "freebsd" {
return false
}
- fd, e := syscall.Socket(syscall.AF_INET6, syscall.SOCK_STREAM, syscall.IPPROTO_TCP);
+ fd, e := syscall.Socket(syscall.AF_INET6, syscall.SOCK_STREAM, syscall.IPPROTO_TCP)
if fd >= 0 {
syscall.Close(fd)
}
- return e == 0;
+ return e == 0
}
var preferIPv4 = !kernelSupportsIPv6()
// TODO(rsc): if syscall.OS == "linux", we're supposd to read
// /proc/sys/net/core/somaxconn,
// to take advantage of kernels that have raised the limit.
-func listenBacklog() int { return syscall.SOMAXCONN }
+func listenBacklog() int { return syscall.SOMAXCONN }
// Internet sockets (TCP, UDP)
// A sockaddr represents a TCP or UDP network address that can
// be converted into a syscall.Sockaddr.
type sockaddr interface {
- Addr;
- sockaddr(family int) (syscall.Sockaddr, os.Error);
- family() int;
+ Addr
+ sockaddr(family int) (syscall.Sockaddr, os.Error)
+ family() int
}
func internetSocket(net string, laddr, raddr sockaddr, proto int, mode string, toAddr func(syscall.Sockaddr) Addr) (fd *netFD, err os.Error) {
// Figure out IP version.
// If network has a suffix like "tcp4", obey it.
- family := syscall.AF_INET6;
+ family := syscall.AF_INET6
switch net[len(net)-1] {
case '4':
family = syscall.AF_INET
}
}
- var la, ra syscall.Sockaddr;
+ var la, ra syscall.Sockaddr
if laddr != nil {
if la, err = laddr.sockaddr(family); err != nil {
goto Error
goto Error
}
}
- fd, err = socket(net, family, proto, 0, la, ra, toAddr);
+ fd, err = socket(net, family, proto, 0, la, ra, toAddr)
if err != nil {
goto Error
}
- return fd, nil;
+ return fd, nil
Error:
- addr := raddr;
+ addr := raddr
if mode == "listen" {
addr = laddr
}
- return nil, &OpError{mode, net, addr, err};
+ return nil, &OpError{mode, net, addr, err}
}
func getip(fd int, remote bool) (ip []byte, port int, ok bool) {
// No attempt at error reporting because
// there are no possible errors, and the
// caller won't report them anyway.
- var sa syscall.Sockaddr;
+ var sa syscall.Sockaddr
if remote {
sa, _ = syscall.Getpeername(fd)
} else {
case *syscall.SockaddrInet6:
return &sa.Addr, sa.Port, true
}
- return;
+ return
}
func ipToSockaddr(family int, ip IP, port int) (syscall.Sockaddr, os.Error) {
if ip = ip.To4(); ip == nil {
return nil, os.EINVAL
}
- s := new(syscall.SockaddrInet4);
+ s := new(syscall.SockaddrInet4)
for i := 0; i < IPv4len; i++ {
s.Addr[i] = ip[i]
}
- s.Port = port;
- return s, nil;
+ s.Port = port
+ return s, nil
case syscall.AF_INET6:
if len(ip) == 0 {
ip = IPzero
if ip = ip.To16(); ip == nil {
return nil, os.EINVAL
}
- s := new(syscall.SockaddrInet6);
+ s := new(syscall.SockaddrInet6)
for i := 0; i < IPv6len; i++ {
s.Addr[i] = ip[i]
}
- s.Port = port;
- return s, nil;
+ s.Port = port
+ return s, nil
}
- return nil, os.EINVAL;
+ return nil, os.EINVAL
}
// Split "host:port" into "host" and "port".
// Host cannot contain colons unless it is bracketed.
func splitHostPort(hostport string) (host, port string, err os.Error) {
// The port starts after the last colon.
- i := last(hostport, ':');
+ i := last(hostport, ':')
if i < 0 {
- err = &AddrError{"missing port in address", hostport};
- return;
+ err = &AddrError{"missing port in address", hostport}
+ return
}
- host, port = hostport[0:i], hostport[i+1:];
+ host, port = hostport[0:i], hostport[i+1:]
// Can put brackets around host ...
if len(host) > 0 && host[0] == '[' && host[len(host)-1] == ']' {
} else {
// ... but if there are no brackets, no colons.
if byteIndex(host, ':') >= 0 {
- err = &AddrError{"too many colons in address", hostport};
- return;
+ err = &AddrError{"too many colons in address", hostport}
+ return
}
}
- return;
+ return
}
// Join "host" and "port" into "host:port".
if byteIndex(host, ':') >= 0 {
return "[" + host + "]:" + port
}
- return host + ":" + port;
+ return host + ":" + port
}
// Convert "host:port" into IP address and port.
func hostPortToIP(net, hostport string) (ip IP, iport int, err os.Error) {
- host, port, err := splitHostPort(hostport);
+ host, port, err := splitHostPort(hostport)
if err != nil {
goto Error
}
- var addr IP;
+ var addr IP
if host != "" {
// Try as an IP address.
- addr = ParseIP(host);
+ addr = ParseIP(host)
if addr == nil {
// Not an IP address. Try as a DNS name.
- _, addrs, err1 := LookupHost(host);
+ _, addrs, err1 := LookupHost(host)
if err1 != nil {
- err = err1;
- goto Error;
+ err = err1
+ goto Error
}
- addr = ParseIP(addrs[0]);
+ addr = ParseIP(addrs[0])
if addr == nil {
// should not happen
- err = &AddrError{"LookupHost returned invalid address", addrs[0]};
- goto Error;
+ err = &AddrError{"LookupHost returned invalid address", addrs[0]}
+ goto Error
}
}
}
- p, i, ok := dtoi(port, 0);
+ p, i, ok := dtoi(port, 0)
if !ok || i != len(port) {
- p, err = LookupPort(net, port);
+ p, err = LookupPort(net, port)
if err != nil {
goto Error
}
}
if p < 0 || p > 0xFFFF {
- err = &AddrError{"invalid port", port};
- goto Error;
+ err = &AddrError{"invalid port", port}
+ goto Error
}
- return addr, p, nil;
+ return addr, p, nil
Error:
- return nil, 0, err;
+ return nil, 0, err
}
// Addr represents a network end point address.
type Addr interface {
- Network() string; // name of the network
- String() string; // string form of address
+ Network() string // name of the network
+ String() string // string form of address
}
// Conn is a generic stream-oriented network connection.
// Read reads data from the connection.
// Read can be made to time out and return err == os.EAGAIN
// after a fixed time limit; see SetTimeout and SetReadTimeout.
- Read(b []byte) (n int, err os.Error);
+ Read(b []byte) (n int, err os.Error)
// Write writes data to the connection.
// Write can be made to time out and return err == os.EAGAIN
// after a fixed time limit; see SetTimeout and SetReadTimeout.
- Write(b []byte) (n int, err os.Error);
+ Write(b []byte) (n int, err os.Error)
// Close closes the connection.
- Close() os.Error;
+ Close() os.Error
// LocalAddr returns the local network address.
- LocalAddr() Addr;
+ LocalAddr() Addr
// RemoteAddr returns the remote network address.
- RemoteAddr() Addr;
+ RemoteAddr() Addr
// SetTimeout sets the read and write deadlines associated
// with the connection.
- SetTimeout(nsec int64) os.Error;
+ SetTimeout(nsec int64) os.Error
// SetReadTimeout sets the time (in nanoseconds) that
// Read will wait for data before returning os.EAGAIN.
// Setting nsec == 0 (the default) disables the deadline.
- SetReadTimeout(nsec int64) os.Error;
+ SetReadTimeout(nsec int64) os.Error
// SetWriteTimeout sets the time (in nanoseconds) that
// Write will wait to send its data before returning os.EAGAIN.
// Setting nsec == 0 (the default) disables the deadline.
// Even if write times out, it may return n > 0, indicating that
// some of the data was successfully written.
- SetWriteTimeout(nsec int64) os.Error;
+ SetWriteTimeout(nsec int64) os.Error
}
// PacketConn is a generic packet-oriented network connection.
// was on the packet.
// ReadFrom can be made to time out and return err == os.EAGAIN
// after a fixed time limit; see SetTimeout and SetReadTimeout.
- ReadFrom(b []byte) (n int, addr Addr, err os.Error);
+ ReadFrom(b []byte) (n int, addr Addr, err os.Error)
// WriteTo writes a packet with payload b to addr.
// WriteTo can be made to time out and return err == os.EAGAIN
// after a fixed time limit; see SetTimeout and SetWriteTimeout.
// On packet-oriented connections, write timeouts are rare.
- WriteTo(b []byte, addr Addr) (n int, err os.Error);
+ WriteTo(b []byte, addr Addr) (n int, err os.Error)
// Close closes the connection.
- Close() os.Error;
+ Close() os.Error
// LocalAddr returns the local network address.
- LocalAddr() Addr;
+ LocalAddr() Addr
// SetTimeout sets the read and write deadlines associated
// with the connection.
- SetTimeout(nsec int64) os.Error;
+ SetTimeout(nsec int64) os.Error
// SetReadTimeout sets the time (in nanoseconds) that
// Read will wait for data before returning os.EAGAIN.
// Setting nsec == 0 (the default) disables the deadline.
- SetReadTimeout(nsec int64) os.Error;
+ SetReadTimeout(nsec int64) os.Error
// SetWriteTimeout sets the time (in nanoseconds) that
// Write will wait to send its data before returning os.EAGAIN.
// Setting nsec == 0 (the default) disables the deadline.
// Even if write times out, it may return n > 0, indicating that
// some of the data was successfully written.
- SetWriteTimeout(nsec int64) os.Error;
+ SetWriteTimeout(nsec int64) os.Error
}
// A Listener is a generic network listener for stream-oriented protocols.
// Accept waits for the next connection and Close closes the connection.
type Listener interface {
- Accept() (c Conn, err os.Error);
- Close() os.Error;
- Addr() Addr; // Listener's network address
+ Accept() (c Conn, err os.Error)
+ Close() os.Error
+ Addr() Addr // Listener's network address
}
// Dial connects to the remote address raddr on the network net.
func Dial(net, laddr, raddr string) (c Conn, err os.Error) {
switch net {
case "tcp", "tcp4", "tcp6":
- var la, ra *TCPAddr;
+ var la, ra *TCPAddr
if laddr != "" {
if la, err = ResolveTCPAddr(laddr); err != nil {
goto Error
goto Error
}
}
- return DialTCP(net, la, ra);
+ return DialTCP(net, la, ra)
case "udp", "udp4", "upd6":
- var la, ra *UDPAddr;
+ var la, ra *UDPAddr
if laddr != "" {
if la, err = ResolveUDPAddr(laddr); err != nil {
goto Error
goto Error
}
}
- return DialUDP(net, la, ra);
+ return DialUDP(net, la, ra)
case "unix", "unixgram":
- var la, ra *UnixAddr;
+ var la, ra *UnixAddr
if raddr != "" {
if ra, err = ResolveUnixAddr(net, raddr); err != nil {
goto Error
goto Error
}
}
- return DialUnix(net, la, ra);
+ return DialUnix(net, la, ra)
}
- err = UnknownNetworkError(net);
+ err = UnknownNetworkError(net)
Error:
- return nil, &OpError{"dial", net + " " + raddr, nil, err};
+ return nil, &OpError{"dial", net + " " + raddr, nil, err}
}
// Listen announces on the local network address laddr.
func Listen(net, laddr string) (l Listener, err os.Error) {
switch net {
case "tcp", "tcp4", "tcp6":
- var la *TCPAddr;
+ var la *TCPAddr
if laddr != "" {
if la, err = ResolveTCPAddr(laddr); err != nil {
return nil, err
}
}
- l, err := ListenTCP(net, la);
+ l, err := ListenTCP(net, la)
if err != nil {
return nil, err
}
- return l, nil;
+ return l, nil
case "unix":
- var la *UnixAddr;
+ var la *UnixAddr
if laddr != "" {
if la, err = ResolveUnixAddr(net, laddr); err != nil {
return nil, err
}
}
- l, err := ListenUnix(net, la);
+ l, err := ListenUnix(net, la)
if err != nil {
return nil, err
}
- return l, nil;
+ return l, nil
}
- return nil, UnknownNetworkError(net);
+ return nil, UnknownNetworkError(net)
}
// ListenPacket announces on the local network address laddr.
func ListenPacket(net, laddr string) (c PacketConn, err os.Error) {
switch net {
case "udp", "udp4", "udp6":
- var la *UDPAddr;
+ var la *UDPAddr
if laddr != "" {
if la, err = ResolveUDPAddr(laddr); err != nil {
return nil, err
}
}
- c, err := ListenUDP(net, la);
+ c, err := ListenUDP(net, la)
if err != nil {
return nil, err
}
- return c, nil;
+ return c, nil
case "unixgram":
- var la *UnixAddr;
+ var la *UnixAddr
if laddr != "" {
if la, err = ResolveUnixAddr(net, laddr); err != nil {
return nil, err
}
}
- c, err := DialUnix(net, la, nil);
+ c, err := DialUnix(net, la, nil)
if err != nil {
return nil, err
}
- return c, nil;
+ return c, nil
}
- return nil, UnknownNetworkError(net);
+ return nil, UnknownNetworkError(net)
}
var errMissingAddress = os.ErrorString("missing address")
type OpError struct {
- Op string;
- Net string;
- Addr Addr;
- Error os.Error;
+ Op string
+ Net string
+ Addr Addr
+ Error os.Error
}
func (e *OpError) String() string {
- s := e.Op;
+ s := e.Op
if e.Net != "" {
s += " " + e.Net
}
if e.Addr != nil {
s += " " + e.Addr.String()
}
- s += ": " + e.Error.String();
- return s;
+ s += ": " + e.Error.String()
+ return s
}
type AddrError struct {
- Error string;
- Addr string;
+ Error string
+ Addr string
}
func (e *AddrError) String() string {
- s := e.Error;
+ s := e.Error
if e.Addr != "" {
s += " " + e.Addr
}
- return s;
+ return s
}
type UnknownNetworkError string
-func (e UnknownNetworkError) String() string { return "unknown network " + string(e) }
+func (e UnknownNetworkError) String() string { return "unknown network " + string(e) }
package net
import (
- "flag";
- "regexp";
- "testing";
+ "flag"
+ "regexp"
+ "testing"
)
var runErrorTest = flag.Bool("run_error_test", false, "let TestDialError check for dns errors")
type DialErrorTest struct {
- Net string;
- Laddr string;
- Raddr string;
- Pattern string;
+ Net string
+ Laddr string
+ Raddr string
+ Pattern string
}
var dialErrorTests = []DialErrorTest{
func TestDialError(t *testing.T) {
if !*runErrorTest {
- t.Logf("test disabled; use --run_error_test to enable");
- return;
+ t.Logf("test disabled; use --run_error_test to enable")
+ return
}
for i, tt := range dialErrorTests {
- c, e := Dial(tt.Net, tt.Laddr, tt.Raddr);
+ c, e := Dial(tt.Net, tt.Laddr, tt.Raddr)
if c != nil {
c.Close()
}
if e == nil {
- t.Errorf("#%d: nil error, want match for %#q", i, tt.Pattern);
- continue;
+ t.Errorf("#%d: nil error, want match for %#q", i, tt.Pattern)
+ continue
}
- s := e.String();
- match, _ := regexp.MatchString(tt.Pattern, s);
+ s := e.String()
+ match, _ := regexp.MatchString(tt.Pattern, s)
if !match {
t.Errorf("#%d: %q, want match for %#q", i, s, tt.Pattern)
}
package net
import (
- "io";
- "os";
+ "io"
+ "os"
)
type file struct {
- file *os.File;
- data []byte;
+ file *os.File
+ data []byte
}
-func (f *file) close() { f.file.Close() }
+func (f *file) close() { f.file.Close() }
func (f *file) getLineFromData() (s string, ok bool) {
- data := f.data;
+ data := f.data
for i := 0; i < len(data); i++ {
if data[i] == '\n' {
- s = string(data[0:i]);
- ok = true;
+ s = string(data[0:i])
+ ok = true
// move data
- i++;
- n := len(data) - i;
+ i++
+ n := len(data) - i
for j := 0; j < n; j++ {
data[j] = data[i+j]
}
- f.data = data[0:n];
- return;
+ f.data = data[0:n]
+ return
}
}
- return;
+ return
}
func (f *file) readLine() (s string, ok bool) {
return
}
if len(f.data) < cap(f.data) {
- ln := len(f.data);
- n, _ := io.ReadFull(f.file, f.data[ln:cap(f.data)]);
+ ln := len(f.data)
+ n, _ := io.ReadFull(f.file, f.data[ln:cap(f.data)])
if n >= 0 {
f.data = f.data[0 : ln+n]
}
}
- s, ok = f.getLineFromData();
- return;
+ s, ok = f.getLineFromData()
+ return
}
func open(name string) (*file, os.Error) {
- fd, err := os.Open(name, os.O_RDONLY, 0);
+ fd, err := os.Open(name, os.O_RDONLY, 0)
if err != nil {
return nil, err
}
- return &file{fd, make([]byte, 1024)[0:0]}, nil;
+ return &file{fd, make([]byte, 1024)[0:0]}, nil
}
func byteIndex(s string, c byte) int {
return i
}
}
- return -1;
+ return -1
}
// Count occurrences in s of any bytes in t.
func countAnyByte(s string, t string) int {
- n := 0;
+ n := 0
for i := 0; i < len(s); i++ {
if byteIndex(t, s[i]) >= 0 {
n++
}
}
- return n;
+ return n
}
// Split s at any bytes in t.
func splitAtBytes(s string, t string) []string {
- a := make([]string, 1+countAnyByte(s, t));
- n := 0;
- last := 0;
+ a := make([]string, 1+countAnyByte(s, t))
+ n := 0
+ last := 0
for i := 0; i < len(s); i++ {
if byteIndex(t, s[i]) >= 0 {
if last < i {
- a[n] = string(s[last:i]);
- n++;
+ a[n] = string(s[last:i])
+ n++
}
- last = i + 1;
+ last = i + 1
}
}
if last < len(s) {
- a[n] = string(s[last:]);
- n++;
+ a[n] = string(s[last:])
+ n++
}
- return a[0:n];
+ return a[0:n]
}
-func getFields(s string) []string { return splitAtBytes(s, " \r\t\n") }
+func getFields(s string) []string { return splitAtBytes(s, " \r\t\n") }
// Bigger than we need, not too big to worry about overflow
const big = 0xFFFFFF
// Decimal to integer starting at &s[i0].
// Returns number, new offset, success.
func dtoi(s string, i0 int) (n int, i int, ok bool) {
- n = 0;
+ n = 0
for i = i0; i < len(s) && '0' <= s[i] && s[i] <= '9'; i++ {
- n = n*10 + int(s[i]-'0');
+ n = n*10 + int(s[i]-'0')
if n >= big {
return 0, i, false
}
if i == i0 {
return 0, i, false
}
- return n, i, true;
+ return n, i, true
}
// Hexadecimal to integer starting at &s[i0].
// Returns number, new offset, success.
func xtoi(s string, i0 int) (n int, i int, ok bool) {
- n = 0;
+ n = 0
for i = i0; i < len(s); i++ {
if '0' <= s[i] && s[i] <= '9' {
- n *= 16;
- n += int(s[i] - '0');
+ n *= 16
+ n += int(s[i] - '0')
} else if 'a' <= s[i] && s[i] <= 'f' {
- n *= 16;
- n += int(s[i]-'a') + 10;
+ n *= 16
+ n += int(s[i]-'a') + 10
} else if 'A' <= s[i] && s[i] <= 'F' {
- n *= 16;
- n += int(s[i]-'A') + 10;
+ n *= 16
+ n += int(s[i]-'A') + 10
} else {
break
}
if i == i0 {
return 0, i, false
}
- return n, i, true;
+ return n, i, true
}
// Integer to decimal.
func itoa(i int) string {
- var buf [30]byte;
- n := len(buf);
- neg := false;
+ var buf [30]byte
+ n := len(buf)
+ neg := false
if i < 0 {
- i = -i;
- neg = true;
+ i = -i
+ neg = true
}
- ui := uint(i);
+ ui := uint(i)
for ui > 0 || n == len(buf) {
- n--;
- buf[n] = byte('0' + ui%10);
- ui /= 10;
+ n--
+ buf[n] = byte('0' + ui%10)
+ ui /= 10
}
if neg {
- n--;
- buf[n] = '-';
+ n--
+ buf[n] = '-'
}
- return string(buf[n:]);
+ return string(buf[n:])
}
// Number of occurrences of b in s.
func count(s string, b byte) int {
- n := 0;
+ n := 0
for i := 0; i < len(s); i++ {
if s[i] == b {
n++
}
}
- return n;
+ return n
}
// Index of rightmost occurrence of b in s.
func last(s string, b byte) int {
- i := len(s);
+ i := len(s)
for i--; i >= 0; i-- {
if s[i] == b {
break
}
}
- return i;
+ return i
}
package net
import (
- "bufio";
- "os";
- "testing";
+ "bufio"
+ "os"
+ "testing"
)
func TestReadLine(t *testing.T) {
- filename := "/etc/services"; // a nice big file
+ filename := "/etc/services" // a nice big file
- fd, err := os.Open(filename, os.O_RDONLY, 0);
+ fd, err := os.Open(filename, os.O_RDONLY, 0)
if err != nil {
t.Fatalf("open %s: %v", filename, err)
}
- br := bufio.NewReader(fd);
+ br := bufio.NewReader(fd)
- var file *file;
- file, err = open(filename);
+ var file *file
+ file, err = open(filename)
if file == nil {
t.Fatalf("net.open(%s) = nil", filename)
}
- lineno := 1;
- byteno := 0;
+ lineno := 1
+ byteno := 0
for {
- bline, berr := br.ReadString('\n');
+ bline, berr := br.ReadString('\n')
if n := len(bline); n > 0 {
bline = bline[0 : n-1]
}
- line, ok := file.readLine();
+ line, ok := file.readLine()
if (berr != nil) != !ok || bline != line {
t.Fatalf("%s:%d (#%d)\nbufio => %q, %v\nnet => %q, %v",
filename, lineno, byteno, bline, berr, line, ok)
if !ok {
break
}
- lineno++;
- byteno += len(line) + 1;
+ lineno++
+ byteno += len(line) + 1
}
}
package net
import (
- "once";
- "os";
+ "once"
+ "os"
)
var services map[string]map[string]int
var servicesError os.Error
func readServices() {
- services = make(map[string]map[string]int);
- var file *file;
- file, servicesError = open("/etc/services");
+ services = make(map[string]map[string]int)
+ var file *file
+ file, servicesError = open("/etc/services")
for line, ok := file.readLine(); ok; line, ok = file.readLine() {
// "http 80/tcp www www-http # World Wide Web HTTP"
if i := byteIndex(line, '#'); i >= 0 {
line = line[0:i]
}
- f := getFields(line);
+ f := getFields(line)
if len(f) < 2 {
continue
}
- portnet := f[1]; // "tcp/80"
- port, j, ok := dtoi(portnet, 0);
+ portnet := f[1] // "tcp/80"
+ port, j, ok := dtoi(portnet, 0)
if !ok || port <= 0 || j >= len(portnet) || portnet[j] != '/' {
continue
}
- netw := portnet[j+1:]; // "tcp"
- m, ok1 := services[netw];
+ netw := portnet[j+1:] // "tcp"
+ m, ok1 := services[netw]
if !ok1 {
- m = make(map[string]int);
- services[netw] = m;
+ m = make(map[string]int)
+ services[netw] = m
}
for i := 0; i < len(f); i++ {
- if i != 1 { // f[1] was port/net
+ if i != 1 { // f[1] was port/net
m[f[i]] = port
}
}
}
- file.close();
+ file.close()
}
// LookupPort looks up the port for the given network and service.
func LookupPort(network, service string) (port int, err os.Error) {
- once.Do(readServices);
+ once.Do(readServices)
switch network {
case "tcp4", "tcp6":
return
}
}
- return 0, &AddrError{"unknown port", network + "/" + service};
+ return 0, &AddrError{"unknown port", network + "/" + service}
}
package net
import (
- "testing";
+ "testing"
)
type portTest struct {
- netw string;
- name string;
- port int;
- ok bool;
+ netw string
+ name string
+ port int
+ ok bool
}
var porttests = []portTest{
func TestLookupPort(t *testing.T) {
for i := 0; i < len(porttests); i++ {
- tt := porttests[i];
+ tt := porttests[i]
if port, err := LookupPort(tt.netw, tt.name); port != tt.port || (err == nil) != tt.ok {
t.Errorf("LookupPort(%q, %q) = %v, %s; want %v",
tt.netw, tt.name, port, err, tt.port)
package net
import (
- "flag";
- "io";
- "os";
- "strings";
- "syscall";
- "testing";
+ "flag"
+ "io"
+ "os"
+ "strings"
+ "syscall"
+ "testing"
)
// Do not test empty datagrams by default.
var testEmptyDatagrams = flag.Bool("empty_datagrams", false, "whether to test empty datagrams")
func runEcho(fd io.ReadWriter, done chan<- int) {
- var buf [1024]byte;
+ var buf [1024]byte
for {
- n, err := fd.Read(&buf);
+ n, err := fd.Read(&buf)
if err != nil || n == 0 {
break
}
- fd.Write(buf[0:n]);
+ fd.Write(buf[0:n])
}
- done <- 1;
+ done <- 1
}
func runServe(t *testing.T, network, addr string, listening chan<- string, done chan<- int) {
- l, err := Listen(network, addr);
+ l, err := Listen(network, addr)
if err != nil {
t.Fatalf("net.Listen(%q, %q) = _, %v", network, addr, err)
}
- listening <- l.Addr().String();
+ listening <- l.Addr().String()
for {
- fd, err := l.Accept();
+ fd, err := l.Accept()
if err != nil {
break
}
- echodone := make(chan int);
- go runEcho(fd, echodone);
- <-echodone; // make sure Echo stops
- l.Close();
+ echodone := make(chan int)
+ go runEcho(fd, echodone)
+ <-echodone // make sure Echo stops
+ l.Close()
}
- done <- 1;
+ done <- 1
}
func connect(t *testing.T, network, addr string, isEmpty bool) {
- var laddr string;
+ var laddr string
if network == "unixgram" {
laddr = addr + ".local"
}
- fd, err := Dial(network, laddr, addr);
+ fd, err := Dial(network, laddr, addr)
if err != nil {
t.Fatalf("net.Dial(%q, %q, %q) = _, %v", network, laddr, addr, err)
}
- fd.SetReadTimeout(1e9); // 1s
+ fd.SetReadTimeout(1e9) // 1s
- var b []byte;
+ var b []byte
if !isEmpty {
b = strings.Bytes("hello, world\n")
}
- var b1 [100]byte;
+ var b1 [100]byte
- n, err := fd.Write(b);
+ n, err := fd.Write(b)
if n != len(b) {
t.Fatalf("fd.Write(%q) = %d, %v", b, n, err)
}
- n, err = fd.Read(&b1);
+ n, err = fd.Read(&b1)
if n != len(b) || err != nil {
t.Fatalf("fd.Read() = %d, %v (want %d, nil)", n, err, len(b))
}
- fd.Close();
+ fd.Close()
}
func doTest(t *testing.T, network, listenaddr, dialaddr string) {
- t.Logf("Test %s %s %s\n", network, listenaddr, dialaddr);
- listening := make(chan string);
- done := make(chan int);
+ t.Logf("Test %s %s %s\n", network, listenaddr, dialaddr)
+ listening := make(chan string)
+ done := make(chan int)
if network == "tcp" {
- listenaddr += ":0" // any available port
+ listenaddr += ":0" // any available port
}
- go runServe(t, network, listenaddr, listening, done);
- addr := <-listening; // wait for server to start
+ go runServe(t, network, listenaddr, listening, done)
+ addr := <-listening // wait for server to start
if network == "tcp" {
dialaddr += addr[strings.LastIndex(addr, ":"):]
}
- connect(t, network, dialaddr, false);
- <-done; // make sure server stopped
+ connect(t, network, dialaddr, false)
+ <-done // make sure server stopped
}
func TestTCPServer(t *testing.T) {
- doTest(t, "tcp", "0.0.0.0", "127.0.0.1");
- doTest(t, "tcp", "", "127.0.0.1");
+ doTest(t, "tcp", "0.0.0.0", "127.0.0.1")
+ doTest(t, "tcp", "", "127.0.0.1")
if kernelSupportsIPv6() {
- doTest(t, "tcp", "[::]", "[::ffff:127.0.0.1]");
- doTest(t, "tcp", "[::]", "127.0.0.1");
- doTest(t, "tcp", "0.0.0.0", "[::ffff:127.0.0.1]");
+ doTest(t, "tcp", "[::]", "[::ffff:127.0.0.1]")
+ doTest(t, "tcp", "[::]", "127.0.0.1")
+ doTest(t, "tcp", "0.0.0.0", "[::ffff:127.0.0.1]")
}
}
func TestUnixServer(t *testing.T) {
- os.Remove("/tmp/gotest.net");
- doTest(t, "unix", "/tmp/gotest.net", "/tmp/gotest.net");
- os.Remove("/tmp/gotest.net");
+ os.Remove("/tmp/gotest.net")
+ doTest(t, "unix", "/tmp/gotest.net", "/tmp/gotest.net")
+ os.Remove("/tmp/gotest.net")
if syscall.OS == "linux" {
// Test abstract unix domain socket, a Linux-ism
doTest(t, "unix", "@gotest/net", "@gotest/net")
}
func runPacket(t *testing.T, network, addr string, listening chan<- string, done chan<- int) {
- c, err := ListenPacket(network, addr);
+ c, err := ListenPacket(network, addr)
if err != nil {
t.Fatalf("net.ListenPacket(%q, %q) = _, %v", network, addr, err)
}
- listening <- c.LocalAddr().String();
- c.SetReadTimeout(10e6); // 10ms
- var buf [1000]byte;
+ listening <- c.LocalAddr().String()
+ c.SetReadTimeout(10e6) // 10ms
+ var buf [1000]byte
for {
- n, addr, err := c.ReadFrom(&buf);
+ n, addr, err := c.ReadFrom(&buf)
if isEAGAIN(err) {
if done <- 1 {
break
}
- continue;
+ continue
}
if err != nil {
break
t.Fatalf("WriteTo %v: %v", addr, err)
}
}
- c.Close();
- done <- 1;
+ c.Close()
+ done <- 1
}
func doTestPacket(t *testing.T, network, listenaddr, dialaddr string, isEmpty bool) {
- t.Logf("TestPacket %s %s %s\n", network, listenaddr, dialaddr);
- listening := make(chan string);
- done := make(chan int);
+ t.Logf("TestPacket %s %s %s\n", network, listenaddr, dialaddr)
+ listening := make(chan string)
+ done := make(chan int)
if network == "udp" {
- listenaddr += ":0" // any available port
+ listenaddr += ":0" // any available port
}
- go runPacket(t, network, listenaddr, listening, done);
- addr := <-listening; // wait for server to start
+ go runPacket(t, network, listenaddr, listening, done)
+ addr := <-listening // wait for server to start
if network == "udp" {
dialaddr += addr[strings.LastIndex(addr, ":"):]
}
- connect(t, network, dialaddr, isEmpty);
- <-done; // tell server to stop
- <-done; // wait for stop
+ connect(t, network, dialaddr, isEmpty)
+ <-done // tell server to stop
+ <-done // wait for stop
}
func TestUDPServer(t *testing.T) {
for _, isEmpty := range []bool{false, *testEmptyDatagrams} {
- doTestPacket(t, "udp", "0.0.0.0", "127.0.0.1", isEmpty);
- doTestPacket(t, "udp", "", "127.0.0.1", isEmpty);
+ doTestPacket(t, "udp", "0.0.0.0", "127.0.0.1", isEmpty)
+ doTestPacket(t, "udp", "", "127.0.0.1", isEmpty)
if kernelSupportsIPv6() {
- doTestPacket(t, "udp", "[::]", "[::ffff:127.0.0.1]", isEmpty);
- doTestPacket(t, "udp", "[::]", "127.0.0.1", isEmpty);
- doTestPacket(t, "udp", "0.0.0.0", "[::ffff:127.0.0.1]", isEmpty);
+ doTestPacket(t, "udp", "[::]", "[::ffff:127.0.0.1]", isEmpty)
+ doTestPacket(t, "udp", "[::]", "127.0.0.1", isEmpty)
+ doTestPacket(t, "udp", "0.0.0.0", "[::ffff:127.0.0.1]", isEmpty)
}
}
}
func TestUnixDatagramServer(t *testing.T) {
for _, isEmpty := range []bool{false, *testEmptyDatagrams} {
- os.Remove("/tmp/gotest1.net");
- os.Remove("/tmp/gotest1.net.local");
- doTestPacket(t, "unixgram", "/tmp/gotest1.net", "/tmp/gotest1.net", isEmpty);
- os.Remove("/tmp/gotest1.net");
- os.Remove("/tmp/gotest1.net.local");
+ os.Remove("/tmp/gotest1.net")
+ os.Remove("/tmp/gotest1.net.local")
+ doTestPacket(t, "unixgram", "/tmp/gotest1.net", "/tmp/gotest1.net", isEmpty)
+ os.Remove("/tmp/gotest1.net")
+ os.Remove("/tmp/gotest1.net.local")
if syscall.OS == "linux" {
// Test abstract unix domain socket, a Linux-ism
doTestPacket(t, "unixgram", "@gotest1/net", "@gotest1/net", isEmpty)
package net
import (
- "os";
- "reflect";
- "syscall";
+ "os"
+ "reflect"
+ "syscall"
)
// Boolean to int.
if b {
return 1
}
- return 0;
+ return 0
}
// Generic socket creation.
func socket(net string, f, p, t int, la, ra syscall.Sockaddr, toAddr func(syscall.Sockaddr) Addr) (fd *netFD, err os.Error) {
// See ../syscall/exec.go for description of ForkLock.
- syscall.ForkLock.RLock();
- s, e := syscall.Socket(f, p, t);
+ syscall.ForkLock.RLock()
+ s, e := syscall.Socket(f, p, t)
if e != 0 {
- syscall.ForkLock.RUnlock();
- return nil, os.Errno(e);
+ syscall.ForkLock.RUnlock()
+ return nil, os.Errno(e)
}
- syscall.CloseOnExec(s);
- syscall.ForkLock.RUnlock();
+ syscall.CloseOnExec(s)
+ syscall.ForkLock.RUnlock()
// Allow reuse of recently-used addresses.
- syscall.SetsockoptInt(s, syscall.SOL_SOCKET, syscall.SO_REUSEADDR, 1);
+ syscall.SetsockoptInt(s, syscall.SOL_SOCKET, syscall.SO_REUSEADDR, 1)
if la != nil {
- e = syscall.Bind(s, la);
+ e = syscall.Bind(s, la)
if e != 0 {
- syscall.Close(s);
- return nil, os.Errno(e);
+ syscall.Close(s)
+ return nil, os.Errno(e)
}
}
if ra != nil {
- e = syscall.Connect(s, ra);
+ e = syscall.Connect(s, ra)
if e != 0 {
- syscall.Close(s);
- return nil, os.Errno(e);
+ syscall.Close(s)
+ return nil, os.Errno(e)
}
}
- sa, _ := syscall.Getsockname(s);
- laddr := toAddr(sa);
- sa, _ = syscall.Getpeername(s);
- raddr := toAddr(sa);
+ sa, _ := syscall.Getsockname(s)
+ laddr := toAddr(sa)
+ sa, _ = syscall.Getpeername(s)
+ raddr := toAddr(sa)
- fd, err = newFD(s, f, p, net, laddr, raddr);
+ fd, err = newFD(s, f, p, net, laddr, raddr)
if err != nil {
- syscall.Close(s);
- return nil, err;
+ syscall.Close(s)
+ return nil, err
}
- return fd, nil;
+ return fd, nil
}
func setsockoptInt(fd, level, opt int, value int) os.Error {
}
func setsockoptNsec(fd, level, opt int, nsec int64) os.Error {
- var tv = syscall.NsecToTimeval(nsec);
- return os.NewSyscallError("setsockopt", syscall.SetsockoptTimeval(fd, level, opt, &tv));
+ var tv = syscall.NsecToTimeval(nsec)
+ return os.NewSyscallError("setsockopt", syscall.SetsockoptTimeval(fd, level, opt, &tv))
}
func setReadBuffer(fd *netFD, bytes int) os.Error {
- fd.incref();
- defer fd.decref();
- return setsockoptInt(fd.sysfd, syscall.SOL_SOCKET, syscall.SO_RCVBUF, bytes);
+ fd.incref()
+ defer fd.decref()
+ return setsockoptInt(fd.sysfd, syscall.SOL_SOCKET, syscall.SO_RCVBUF, bytes)
}
func setWriteBuffer(fd *netFD, bytes int) os.Error {
- fd.incref();
- defer fd.decref();
- return setsockoptInt(fd.sysfd, syscall.SOL_SOCKET, syscall.SO_SNDBUF, bytes);
+ fd.incref()
+ defer fd.decref()
+ return setsockoptInt(fd.sysfd, syscall.SOL_SOCKET, syscall.SO_SNDBUF, bytes)
}
func setReadTimeout(fd *netFD, nsec int64) os.Error {
- fd.rdeadline_delta = nsec;
- return nil;
+ fd.rdeadline_delta = nsec
+ return nil
}
func setWriteTimeout(fd *netFD, nsec int64) os.Error {
- fd.wdeadline_delta = nsec;
- return nil;
+ fd.wdeadline_delta = nsec
+ return nil
}
func setTimeout(fd *netFD, nsec int64) os.Error {
if e := setReadTimeout(fd, nsec); e != nil {
return e
}
- return setWriteTimeout(fd, nsec);
+ return setWriteTimeout(fd, nsec)
}
func setReuseAddr(fd *netFD, reuse bool) os.Error {
- fd.incref();
- defer fd.decref();
- return setsockoptInt(fd.sysfd, syscall.SOL_SOCKET, syscall.SO_REUSEADDR, boolint(reuse));
+ fd.incref()
+ defer fd.decref()
+ return setsockoptInt(fd.sysfd, syscall.SOL_SOCKET, syscall.SO_REUSEADDR, boolint(reuse))
}
func bindToDevice(fd *netFD, dev string) os.Error {
}
func setDontRoute(fd *netFD, dontroute bool) os.Error {
- fd.incref();
- defer fd.decref();
- return setsockoptInt(fd.sysfd, syscall.SOL_SOCKET, syscall.SO_DONTROUTE, boolint(dontroute));
+ fd.incref()
+ defer fd.decref()
+ return setsockoptInt(fd.sysfd, syscall.SOL_SOCKET, syscall.SO_DONTROUTE, boolint(dontroute))
}
func setKeepAlive(fd *netFD, keepalive bool) os.Error {
- fd.incref();
- defer fd.decref();
- return setsockoptInt(fd.sysfd, syscall.SOL_SOCKET, syscall.SO_KEEPALIVE, boolint(keepalive));
+ fd.incref()
+ defer fd.decref()
+ return setsockoptInt(fd.sysfd, syscall.SOL_SOCKET, syscall.SO_KEEPALIVE, boolint(keepalive))
}
func setLinger(fd *netFD, sec int) os.Error {
- var l syscall.Linger;
+ var l syscall.Linger
if sec >= 0 {
- l.Onoff = 1;
- l.Linger = int32(sec);
+ l.Onoff = 1
+ l.Linger = int32(sec)
} else {
- l.Onoff = 0;
- l.Linger = 0;
+ l.Onoff = 0
+ l.Linger = 0
}
- fd.incref();
- defer fd.decref();
- e := syscall.SetsockoptLinger(fd.sysfd, syscall.SOL_SOCKET, syscall.SO_LINGER, &l);
- return os.NewSyscallError("setsockopt", e);
+ fd.incref()
+ defer fd.decref()
+ e := syscall.SetsockoptLinger(fd.sysfd, syscall.SOL_SOCKET, syscall.SO_LINGER, &l)
+ return os.NewSyscallError("setsockopt", e)
}
type UnknownSocketError struct {
- sa syscall.Sockaddr;
+ sa syscall.Sockaddr
}
func (e *UnknownSocketError) String() string {
return a.Name, nil
}
- return "", &UnknownSocketError{sa};
+ return "", &UnknownSocketError{sa}
}
package net
import (
- "os";
- "syscall";
+ "os"
+ "syscall"
)
func sockaddrToTCP(sa syscall.Sockaddr) Addr {
case *syscall.SockaddrInet6:
return &TCPAddr{&sa.Addr, sa.Port}
}
- return nil;
+ return nil
}
// TCPAddr represents the address of a TCP end point.
type TCPAddr struct {
- IP IP;
- Port int;
+ IP IP
+ Port int
}
// Network returns the address's network name, "tcp".
-func (a *TCPAddr) Network() string { return "tcp" }
+func (a *TCPAddr) Network() string { return "tcp" }
-func (a *TCPAddr) String() string { return joinHostPort(a.IP.String(), itoa(a.Port)) }
+func (a *TCPAddr) String() string { return joinHostPort(a.IP.String(), itoa(a.Port)) }
func (a *TCPAddr) family() int {
if a == nil || len(a.IP) <= 4 {
if ip := a.IP.To4(); ip != nil {
return syscall.AF_INET
}
- return syscall.AF_INET6;
+ return syscall.AF_INET6
}
func (a *TCPAddr) sockaddr(family int) (syscall.Sockaddr, os.Error) {
}
func (a *TCPAddr) toAddr() sockaddr {
- if a == nil { // nil *TCPAddr
- return nil // nil interface
+ if a == nil { // nil *TCPAddr
+ return nil // nil interface
}
- return a;
+ return a
}
// ResolveTCPAddr parses addr as a TCP address of the form
// numeric addresses. A literal IPv6 host address must be
// enclosed in square brackets, as in "[::]:80".
func ResolveTCPAddr(addr string) (*TCPAddr, os.Error) {
- ip, port, err := hostPortToIP("tcp", addr);
+ ip, port, err := hostPortToIP("tcp", addr)
if err != nil {
return nil, err
}
- return &TCPAddr{ip, port}, nil;
+ return &TCPAddr{ip, port}, nil
}
// TCPConn is an implementation of the Conn interface
// for TCP network connections.
type TCPConn struct {
- fd *netFD;
+ fd *netFD
}
func newTCPConn(fd *netFD) *TCPConn {
- c := &TCPConn{fd};
- setsockoptInt(fd.sysfd, syscall.IPPROTO_TCP, syscall.TCP_NODELAY, 1);
- return c;
+ c := &TCPConn{fd}
+ setsockoptInt(fd.sysfd, syscall.IPPROTO_TCP, syscall.TCP_NODELAY, 1)
+ return c
}
-func (c *TCPConn) ok() bool { return c != nil && c.fd != nil }
+func (c *TCPConn) ok() bool { return c != nil && c.fd != nil }
// Implementation of the Conn interface - see Conn for documentation.
if !c.ok() {
return 0, os.EINVAL
}
- return c.fd.Read(b);
+ return c.fd.Read(b)
}
// Write writes data to the TCP connection.
if !c.ok() {
return 0, os.EINVAL
}
- return c.fd.Write(b);
+ return c.fd.Write(b)
}
// Close closes the TCP connection.
if !c.ok() {
return os.EINVAL
}
- err := c.fd.Close();
- c.fd = nil;
- return err;
+ err := c.fd.Close()
+ c.fd = nil
+ return err
}
// LocalAddr returns the local network address, a *TCPAddr.
if !c.ok() {
return nil
}
- return c.fd.laddr;
+ return c.fd.laddr
}
// RemoteAddr returns the remote network address, a *TCPAddr.
if !c.ok() {
return nil
}
- return c.fd.raddr;
+ return c.fd.raddr
}
// SetTimeout sets the read and write deadlines associated
if !c.ok() {
return os.EINVAL
}
- return setTimeout(c.fd, nsec);
+ return setTimeout(c.fd, nsec)
}
// SetReadTimeout sets the time (in nanoseconds) that
if !c.ok() {
return os.EINVAL
}
- return setReadTimeout(c.fd, nsec);
+ return setReadTimeout(c.fd, nsec)
}
// SetWriteTimeout sets the time (in nanoseconds) that
if !c.ok() {
return os.EINVAL
}
- return setWriteTimeout(c.fd, nsec);
+ return setWriteTimeout(c.fd, nsec)
}
// SetReadBuffer sets the size of the operating system's
if !c.ok() {
return os.EINVAL
}
- return setReadBuffer(c.fd, bytes);
+ return setReadBuffer(c.fd, bytes)
}
// SetWriteBuffer sets the size of the operating system's
if !c.ok() {
return os.EINVAL
}
- return setWriteBuffer(c.fd, bytes);
+ return setWriteBuffer(c.fd, bytes)
}
// SetLinger sets the behavior of Close() on a connection
if !c.ok() {
return os.EINVAL
}
- return setLinger(c.fd, sec);
+ return setLinger(c.fd, sec)
}
// SetKeepAlive sets whether the operating system should send
if !c.ok() {
return os.EINVAL
}
- return setKeepAlive(c.fd, keepalive);
+ return setKeepAlive(c.fd, keepalive)
}
// DialTCP is like Dial but can only connect to TCP networks
if raddr == nil {
return nil, &OpError{"dial", "tcp", nil, errMissingAddress}
}
- fd, e := internetSocket(net, laddr.toAddr(), raddr.toAddr(), syscall.SOCK_STREAM, "dial", sockaddrToTCP);
+ fd, e := internetSocket(net, laddr.toAddr(), raddr.toAddr(), syscall.SOCK_STREAM, "dial", sockaddrToTCP)
if e != nil {
return nil, e
}
- return newTCPConn(fd), nil;
+ return newTCPConn(fd), nil
}
// TCPListener is a TCP network listener.
// Clients should typically use variables of type Listener
// instead of assuming TCP.
type TCPListener struct {
- fd *netFD;
+ fd *netFD
}
// ListenTCP announces on the TCP address laddr and returns a TCP listener.
// If laddr has a port of 0, it means to listen on some available port.
// The caller can use l.Addr() to retrieve the chosen address.
func ListenTCP(net string, laddr *TCPAddr) (l *TCPListener, err os.Error) {
- fd, err := internetSocket(net, laddr.toAddr(), nil, syscall.SOCK_STREAM, "listen", sockaddrToTCP);
+ fd, err := internetSocket(net, laddr.toAddr(), nil, syscall.SOCK_STREAM, "listen", sockaddrToTCP)
if err != nil {
return nil, err
}
- errno := syscall.Listen(fd.sysfd, listenBacklog());
+ errno := syscall.Listen(fd.sysfd, listenBacklog())
if errno != 0 {
- syscall.Close(fd.sysfd);
- return nil, &OpError{"listen", "tcp", laddr, os.Errno(errno)};
+ syscall.Close(fd.sysfd)
+ return nil, &OpError{"listen", "tcp", laddr, os.Errno(errno)}
}
- l = new(TCPListener);
- l.fd = fd;
- return l, nil;
+ l = new(TCPListener)
+ l.fd = fd
+ return l, nil
}
// AcceptTCP accepts the next incoming call and returns the new connection
if l == nil || l.fd == nil || l.fd.sysfd < 0 {
return nil, os.EINVAL
}
- fd, err := l.fd.accept(sockaddrToTCP);
+ fd, err := l.fd.accept(sockaddrToTCP)
if err != nil {
return nil, err
}
- return newTCPConn(fd), nil;
+ return newTCPConn(fd), nil
}
// Accept implements the Accept method in the Listener interface;
// it waits for the next call and returns a generic Conn.
func (l *TCPListener) Accept() (c Conn, err os.Error) {
- c1, err := l.AcceptTCP();
+ c1, err := l.AcceptTCP()
if err != nil {
return nil, err
}
- return c1, nil;
+ return c1, nil
}
// Close stops listening on the TCP address.
if l == nil || l.fd == nil {
return os.EINVAL
}
- return l.fd.Close();
+ return l.fd.Close()
}
// Addr returns the listener's network address, a *TCPAddr.
-func (l *TCPListener) Addr() Addr { return l.fd.laddr }
+func (l *TCPListener) Addr() Addr { return l.fd.laddr }
package net
import (
- "os";
- "testing";
- "time";
+ "os"
+ "testing"
+ "time"
)
func testTimeout(t *testing.T, network, addr string, readFrom bool) {
- fd, err := Dial(network, "", addr);
- defer fd.Close();
+ fd, err := Dial(network, "", addr)
+ defer fd.Close()
if err != nil {
t.Errorf("dial %s %s failed: %v", network, addr, err)
}
- t0 := time.Nanoseconds();
- fd.SetReadTimeout(1e8); // 100ms
- var b [100]byte;
- var n int;
- var err1 os.Error;
+ t0 := time.Nanoseconds()
+ fd.SetReadTimeout(1e8) // 100ms
+ var b [100]byte
+ var n int
+ var err1 os.Error
if readFrom {
n, _, err1 = fd.(PacketConn).ReadFrom(&b)
} else {
n, err1 = fd.Read(&b)
}
- t1 := time.Nanoseconds();
- what := "Read";
+ t1 := time.Nanoseconds()
+ what := "Read"
if readFrom {
what = "ReadFrom"
}
}
func TestTimeoutUDP(t *testing.T) {
- testTimeout(t, "udp", "127.0.0.1:53", false);
- testTimeout(t, "udp", "127.0.0.1:53", true);
+ testTimeout(t, "udp", "127.0.0.1:53", false)
+ testTimeout(t, "udp", "127.0.0.1:53", true)
}
func TestTimeoutTCP(t *testing.T) {
package net
import (
- "os";
- "syscall";
+ "os"
+ "syscall"
)
func sockaddrToUDP(sa syscall.Sockaddr) Addr {
case *syscall.SockaddrInet6:
return &UDPAddr{&sa.Addr, sa.Port}
}
- return nil;
+ return nil
}
// UDPAddr represents the address of a UDP end point.
type UDPAddr struct {
- IP IP;
- Port int;
+ IP IP
+ Port int
}
// Network returns the address's network name, "udp".
-func (a *UDPAddr) Network() string { return "udp" }
+func (a *UDPAddr) Network() string { return "udp" }
-func (a *UDPAddr) String() string { return joinHostPort(a.IP.String(), itoa(a.Port)) }
+func (a *UDPAddr) String() string { return joinHostPort(a.IP.String(), itoa(a.Port)) }
func (a *UDPAddr) family() int {
if a == nil || len(a.IP) <= 4 {
if ip := a.IP.To4(); ip != nil {
return syscall.AF_INET
}
- return syscall.AF_INET6;
+ return syscall.AF_INET6
}
func (a *UDPAddr) sockaddr(family int) (syscall.Sockaddr, os.Error) {
}
func (a *UDPAddr) toAddr() sockaddr {
- if a == nil { // nil *UDPAddr
- return nil // nil interface
+ if a == nil { // nil *UDPAddr
+ return nil // nil interface
}
- return a;
+ return a
}
// ResolveUDPAddr parses addr as a UDP address of the form
// numeric addresses. A literal IPv6 host address must be
// enclosed in square brackets, as in "[::]:80".
func ResolveUDPAddr(addr string) (*UDPAddr, os.Error) {
- ip, port, err := hostPortToIP("udp", addr);
+ ip, port, err := hostPortToIP("udp", addr)
if err != nil {
return nil, err
}
- return &UDPAddr{ip, port}, nil;
+ return &UDPAddr{ip, port}, nil
}
// UDPConn is the implementation of the Conn and PacketConn
// interfaces for UDP network connections.
type UDPConn struct {
- fd *netFD;
+ fd *netFD
}
func newUDPConn(fd *netFD) *UDPConn {
- c := &UDPConn{fd};
- setsockoptInt(fd.sysfd, syscall.SOL_SOCKET, syscall.SO_BROADCAST, 1);
- return c;
+ c := &UDPConn{fd}
+ setsockoptInt(fd.sysfd, syscall.SOL_SOCKET, syscall.SO_BROADCAST, 1)
+ return c
}
-func (c *UDPConn) ok() bool { return c != nil && c.fd != nil }
+func (c *UDPConn) ok() bool { return c != nil && c.fd != nil }
// Implementation of the Conn interface - see Conn for documentation.
if !c.ok() {
return 0, os.EINVAL
}
- return c.fd.Read(b);
+ return c.fd.Read(b)
}
// Write writes data to the connection as a single UDP packet.
if !c.ok() {
return 0, os.EINVAL
}
- return c.fd.Write(b);
+ return c.fd.Write(b)
}
// Close closes the UDP connection.
if !c.ok() {
return os.EINVAL
}
- err := c.fd.Close();
- c.fd = nil;
- return err;
+ err := c.fd.Close()
+ c.fd = nil
+ return err
}
// LocalAddr returns the local network address.
if !c.ok() {
return nil
}
- return c.fd.laddr;
+ return c.fd.laddr
}
// RemoteAddr returns the remote network address, a *UDPAddr.
if !c.ok() {
return nil
}
- return c.fd.raddr;
+ return c.fd.raddr
}
// SetTimeout sets the read and write deadlines associated
if !c.ok() {
return os.EINVAL
}
- return setTimeout(c.fd, nsec);
+ return setTimeout(c.fd, nsec)
}
// SetReadTimeout sets the time (in nanoseconds) that
if !c.ok() {
return os.EINVAL
}
- return setReadTimeout(c.fd, nsec);
+ return setReadTimeout(c.fd, nsec)
}
// SetWriteTimeout sets the time (in nanoseconds) that
if !c.ok() {
return os.EINVAL
}
- return setWriteTimeout(c.fd, nsec);
+ return setWriteTimeout(c.fd, nsec)
}
// SetReadBuffer sets the size of the operating system's
if !c.ok() {
return os.EINVAL
}
- return setReadBuffer(c.fd, bytes);
+ return setReadBuffer(c.fd, bytes)
}
// SetWriteBuffer sets the size of the operating system's
if !c.ok() {
return os.EINVAL
}
- return setWriteBuffer(c.fd, bytes);
+ return setWriteBuffer(c.fd, bytes)
}
// UDP-specific methods.
if !c.ok() {
return 0, nil, os.EINVAL
}
- n, sa, err := c.fd.ReadFrom(b);
+ n, sa, err := c.fd.ReadFrom(b)
switch sa := sa.(type) {
case *syscall.SockaddrInet4:
addr = &UDPAddr{&sa.Addr, sa.Port}
case *syscall.SockaddrInet6:
addr = &UDPAddr{&sa.Addr, sa.Port}
}
- return;
+ return
}
// ReadFrom reads a UDP packet from c, copying the payload into b.
if !c.ok() {
return 0, nil, os.EINVAL
}
- n, uaddr, err := c.ReadFromUDP(b);
- return n, uaddr.toAddr(), err;
+ n, uaddr, err := c.ReadFromUDP(b)
+ return n, uaddr.toAddr(), err
}
// WriteToUDP writes a UDP packet to addr via c, copying the payload from b.
if !c.ok() {
return 0, os.EINVAL
}
- sa, err := addr.sockaddr(c.fd.family);
+ sa, err := addr.sockaddr(c.fd.family)
if err != nil {
return 0, err
}
- return c.fd.WriteTo(b, sa);
+ return c.fd.WriteTo(b, sa)
}
// WriteTo writes a UDP packet with payload b to addr via c.
if !c.ok() {
return 0, os.EINVAL
}
- a, ok := addr.(*UDPAddr);
+ a, ok := addr.(*UDPAddr)
if !ok {
return 0, &OpError{"writeto", "udp", addr, os.EINVAL}
}
- return c.WriteToUDP(b, a);
+ return c.WriteToUDP(b, a)
}
// DialUDP connects to the remote address raddr on the network net,
if raddr == nil {
return nil, &OpError{"dial", "udp", nil, errMissingAddress}
}
- fd, e := internetSocket(net, laddr.toAddr(), raddr.toAddr(), syscall.SOCK_DGRAM, "dial", sockaddrToUDP);
+ fd, e := internetSocket(net, laddr.toAddr(), raddr.toAddr(), syscall.SOCK_DGRAM, "dial", sockaddrToUDP)
if e != nil {
return nil, e
}
- return newUDPConn(fd), nil;
+ return newUDPConn(fd), nil
}
// ListenUDP listens for incoming UDP packets addressed to the
if laddr == nil {
return nil, &OpError{"listen", "udp", nil, errMissingAddress}
}
- fd, e := internetSocket(net, laddr.toAddr(), nil, syscall.SOCK_DGRAM, "dial", sockaddrToUDP);
+ fd, e := internetSocket(net, laddr.toAddr(), nil, syscall.SOCK_DGRAM, "dial", sockaddrToUDP)
if e != nil {
return nil, e
}
- return newUDPConn(fd), nil;
+ return newUDPConn(fd), nil
}
package net
import (
- "os";
- "syscall";
+ "os"
+ "syscall"
)
func unixSocket(net string, laddr, raddr *UnixAddr, mode string) (fd *netFD, err os.Error) {
- var proto int;
+ var proto int
switch net {
default:
return nil, UnknownNetworkError(net)
proto = syscall.SOCK_DGRAM
}
- var la, ra syscall.Sockaddr;
+ var la, ra syscall.Sockaddr
switch mode {
default:
panic("unixSocket", mode)
if laddr == nil {
return nil, &OpError{mode, net, nil, errMissingAddress}
}
- la = &syscall.SockaddrUnix{Name: laddr.Name};
+ la = &syscall.SockaddrUnix{Name: laddr.Name}
if raddr != nil {
return nil, &OpError{mode, net, raddr, &AddrError{"unexpected remote address", raddr.String()}}
}
}
- f := sockaddrToUnix;
+ f := sockaddrToUnix
if proto != syscall.SOCK_STREAM {
f = sockaddrToUnixgram
}
- fd, err = socket(net, syscall.AF_UNIX, proto, 0, la, ra, f);
+ fd, err = socket(net, syscall.AF_UNIX, proto, 0, la, ra, f)
if err != nil {
goto Error
}
- return fd, nil;
+ return fd, nil
Error:
- addr := raddr;
+ addr := raddr
if mode == "listen" {
addr = laddr
}
- return nil, &OpError{mode, net, addr, err};
+ return nil, &OpError{mode, net, addr, err}
}
// UnixAddr represents the address of a Unix domain socket end point.
type UnixAddr struct {
- Name string;
- Datagram bool;
+ Name string
+ Datagram bool
}
func sockaddrToUnix(sa syscall.Sockaddr) Addr {
if s, ok := sa.(*syscall.SockaddrUnix); ok {
return &UnixAddr{s.Name, false}
}
- return nil;
+ return nil
}
func sockaddrToUnixgram(sa syscall.Sockaddr) Addr {
if s, ok := sa.(*syscall.SockaddrUnix); ok {
return &UnixAddr{s.Name, true}
}
- return nil;
+ return nil
}
// Network returns the address's network name, "unix" or "unixgram".
if a == nil || !a.Datagram {
return "unix"
}
- return "unixgram";
+ return "unixgram"
}
func (a *UnixAddr) String() string {
if a == nil {
return "<nil>"
}
- return a.Name;
+ return a.Name
}
func (a *UnixAddr) toAddr() Addr {
- if a == nil { // nil *UnixAddr
- return nil // nil interface
+ if a == nil { // nil *UnixAddr
+ return nil // nil interface
}
- return a;
+ return a
}
// ResolveUnixAddr parses addr as a Unix domain socket address.
// The string net gives the network name, "unix" or "unixgram".
func ResolveUnixAddr(net, addr string) (*UnixAddr, os.Error) {
- var datagram bool;
+ var datagram bool
switch net {
case "unix":
case "unixgram":
default:
return nil, UnknownNetworkError(net)
}
- return &UnixAddr{addr, datagram}, nil;
+ return &UnixAddr{addr, datagram}, nil
}
// UnixConn is an implementation of the Conn interface
// for connections to Unix domain sockets.
type UnixConn struct {
- fd *netFD;
+ fd *netFD
}
-func newUnixConn(fd *netFD) *UnixConn { return &UnixConn{fd} }
+func newUnixConn(fd *netFD) *UnixConn { return &UnixConn{fd} }
-func (c *UnixConn) ok() bool { return c != nil && c.fd != nil }
+func (c *UnixConn) ok() bool { return c != nil && c.fd != nil }
// Implementation of the Conn interface - see Conn for documentation.
if !c.ok() {
return 0, os.EINVAL
}
- return c.fd.Read(b);
+ return c.fd.Read(b)
}
// Write writes data to the Unix domain connection.
if !c.ok() {
return 0, os.EINVAL
}
- return c.fd.Write(b);
+ return c.fd.Write(b)
}
// Close closes the Unix domain connection.
if !c.ok() {
return os.EINVAL
}
- err := c.fd.Close();
- c.fd = nil;
- return err;
+ err := c.fd.Close()
+ c.fd = nil
+ return err
}
// LocalAddr returns the local network address, a *UnixAddr.
if !c.ok() {
return nil
}
- return c.fd.laddr;
+ return c.fd.laddr
}
// RemoteAddr returns the remote network address, a *UnixAddr.
if !c.ok() {
return nil
}
- return c.fd.raddr;
+ return c.fd.raddr
}
// SetTimeout sets the read and write deadlines associated
if !c.ok() {
return os.EINVAL
}
- return setTimeout(c.fd, nsec);
+ return setTimeout(c.fd, nsec)
}
// SetReadTimeout sets the time (in nanoseconds) that
if !c.ok() {
return os.EINVAL
}
- return setReadTimeout(c.fd, nsec);
+ return setReadTimeout(c.fd, nsec)
}
// SetWriteTimeout sets the time (in nanoseconds) that
if !c.ok() {
return os.EINVAL
}
- return setWriteTimeout(c.fd, nsec);
+ return setWriteTimeout(c.fd, nsec)
}
// SetReadBuffer sets the size of the operating system's
if !c.ok() {
return os.EINVAL
}
- return setReadBuffer(c.fd, bytes);
+ return setReadBuffer(c.fd, bytes)
}
// SetWriteBuffer sets the size of the operating system's
if !c.ok() {
return os.EINVAL
}
- return setWriteBuffer(c.fd, bytes);
+ return setWriteBuffer(c.fd, bytes)
}
// ReadFromUnix reads a packet from c, copying the payload into b.
if !c.ok() {
return 0, nil, os.EINVAL
}
- n, sa, err := c.fd.ReadFrom(b);
+ n, sa, err := c.fd.ReadFrom(b)
switch sa := sa.(type) {
case *syscall.SockaddrUnix:
addr = &UnixAddr{sa.Name, c.fd.proto == syscall.SOCK_DGRAM}
}
- return;
+ return
}
// ReadFrom reads a packet from c, copying the payload into b.
if !c.ok() {
return 0, nil, os.EINVAL
}
- n, uaddr, err := c.ReadFromUnix(b);
- return n, uaddr.toAddr(), err;
+ n, uaddr, err := c.ReadFromUnix(b)
+ return n, uaddr.toAddr(), err
}
// WriteToUnix writes a packet to addr via c, copying the payload from b.
if addr.Datagram != (c.fd.proto == syscall.SOCK_DGRAM) {
return 0, os.EAFNOSUPPORT
}
- sa := &syscall.SockaddrUnix{Name: addr.Name};
- return c.fd.WriteTo(b, sa);
+ sa := &syscall.SockaddrUnix{Name: addr.Name}
+ return c.fd.WriteTo(b, sa)
}
// WriteTo writes a packet to addr via c, copying the payload from b.
if !c.ok() {
return 0, os.EINVAL
}
- a, ok := addr.(*UnixAddr);
+ a, ok := addr.(*UnixAddr)
if !ok {
return 0, &OpError{"writeto", "unix", addr, os.EINVAL}
}
- return c.WriteToUnix(b, a);
+ return c.WriteToUnix(b, a)
}
// DialUDP connects to the remote address raddr on the network net,
// which must be "unix" or "unixdgram". If laddr is not nil, it is used
// as the local address for the connection.
func DialUnix(net string, laddr, raddr *UnixAddr) (c *UnixConn, err os.Error) {
- fd, e := unixSocket(net, laddr, raddr, "dial");
+ fd, e := unixSocket(net, laddr, raddr, "dial")
if e != nil {
return nil, e
}
- return newUnixConn(fd), nil;
+ return newUnixConn(fd), nil
}
// UnixListener is a Unix domain socket listener.
// Clients should typically use variables of type Listener
// instead of assuming Unix domain sockets.
type UnixListener struct {
- fd *netFD;
- path string;
+ fd *netFD
+ path string
}
// ListenUnix announces on the Unix domain socket laddr and returns a Unix listener.
return nil, UnknownNetworkError(net)
}
if laddr != nil {
- laddr = &UnixAddr{laddr.Name, net == "unixgram"} // make our own copy
+ laddr = &UnixAddr{laddr.Name, net == "unixgram"} // make our own copy
}
- fd, e := unixSocket(net, laddr, nil, "listen");
+ fd, e := unixSocket(net, laddr, nil, "listen")
if e != nil {
if pe, ok := e.(*os.PathError); ok {
e = pe.Error
}
- return nil, e;
+ return nil, e
}
- e1 := syscall.Listen(fd.sysfd, 8); // listenBacklog());
+ e1 := syscall.Listen(fd.sysfd, 8) // listenBacklog());
if e1 != 0 {
- syscall.Close(fd.sysfd);
- return nil, &OpError{"listen", "unix", laddr, os.Errno(e1)};
+ syscall.Close(fd.sysfd)
+ return nil, &OpError{"listen", "unix", laddr, os.Errno(e1)}
}
- return &UnixListener{fd, laddr.Name}, nil;
+ return &UnixListener{fd, laddr.Name}, nil
}
// AcceptUnix accepts the next incoming call and returns the new connection
if l == nil || l.fd == nil {
return nil, os.EINVAL
}
- fd, e := l.fd.accept(sockaddrToUnix);
+ fd, e := l.fd.accept(sockaddrToUnix)
if e != nil {
return nil, e
}
- c = newUnixConn(fd);
- return c, nil;
+ c = newUnixConn(fd)
+ return c, nil
}
// Accept implements the Accept method in the Listener interface;
// it waits for the next call and returns a generic Conn.
func (l *UnixListener) Accept() (c Conn, err os.Error) {
- c1, err := l.AcceptUnix();
+ c1, err := l.AcceptUnix()
if err != nil {
return nil, err
}
- return c1, nil;
+ return c1, nil
}
// Close stops listening on the Unix address.
if l.path[0] != '@' {
syscall.Unlink(l.path)
}
- err := l.fd.Close();
- l.fd = nil;
- return err;
+ err := l.fd.Close()
+ l.fd = nil
+ return err
}
// Addr returns the listener's network address.
-func (l *UnixListener) Addr() Addr { return l.fd.laddr }
+func (l *UnixListener) Addr() Addr { return l.fd.laddr }
// ListenUnixgram listens for incoming Unix datagram packets addressed to the
// local address laddr. The returned connection c's ReadFrom
if laddr == nil {
return nil, &OpError{"listen", "unixgram", nil, errMissingAddress}
}
- fd, e := unixSocket(net, laddr, nil, "listen");
+ fd, e := unixSocket(net, laddr, nil, "listen")
if e != nil {
return nil, e
}
- return newUDPConn(fd), nil;
+ return newUDPConn(fd), nil
}