return f, nil
}
-func contains(list []string, s string) bool {
- for _, t := range list {
- if t == s {
- return true
- }
- }
- return false
-}
-
// The package cache doesn't operate correctly in rare (so far artificial)
// circumstances (issue 8425). Disable before debugging non-obvious errors
// from the type-checker.
// with equivalent memory layout.
type typeConv struct {
// Cache of already-translated or in-progress types.
- m map[dwarf.Type]*Type
- typedef map[string]ast.Expr
+ m map[dwarf.Type]*Type
// Map from types to incomplete pointers to those types.
ptrs map[dwarf.Type][]*Type
var (
bgwork = make(chan func(), 1e5)
- bgdone = make(chan struct{}, 1e5)
bghelpers sync.WaitGroup
)
type Package struct {
- writer io.Writer // Destination for output.
- name string // Package name, json for encoding/json.
- userPath string // String the user used to find this package.
- unexported bool
- matchCase bool
- pkg *ast.Package // Parsed package.
- file *ast.File // Merged from all files in the package
- doc *doc.Package
- build *build.Package
- fs *token.FileSet // Needed for printing.
- buf bytes.Buffer
+ writer io.Writer // Destination for output.
+ name string // Package name, json for encoding/json.
+ userPath string // String the user used to find this package.
+ pkg *ast.Package // Parsed package.
+ file *ast.File // Merged from all files in the package
+ doc *doc.Package
+ build *build.Package
+ fs *token.FileSet // Needed for printing.
+ buf bytes.Buffer
}
type PackageError string // type returned by pkg.Fatalf.
wg.Wait()
}
-// hasString reports whether s appears in the list of strings.
-func hasString(strings []string, s string) bool {
- for _, t := range strings {
- if s == t {
- return true
- }
- }
- return false
-}
-
// build is the action for building a single package or command.
func (b *builder) build(a *action) (err error) {
// Return an error if the package has CXX files but it's not using
"runtime"
"strconv"
"strings"
- "unicode"
)
var cmdGenerate = &Command{
return os.Getenv(word)
}
-// identLength returns the length of the identifier beginning the string.
-func (g *Generator) identLength(word string) int {
- for i, r := range word {
- if r == '_' || unicode.IsLetter(r) || unicode.IsDigit(r) {
- continue
- }
- return i
- }
- return len(word)
-}
-
// setShorthand installs a new shorthand as defined by a -command directive.
func (g *Generator) setShorthand(words []string) {
// Create command shorthand.
setExitStatus(1)
}
-var logf = log.Printf
-
func exitIfErrors() {
if exitStatus != 0 {
exit()
}
}
-func runOut(dir string, cmdargs ...interface{}) []byte {
- cmdline := stringList(cmdargs...)
- cmd := exec.Command(cmdline[0], cmdline[1:]...)
- cmd.Dir = dir
- out, err := cmd.CombinedOutput()
- if err != nil {
- os.Stderr.Write(out)
- errorf("%v", err)
- out = nil
- }
- return out
-}
-
// envForDir returns a copy of the environment
// suitable for running in the given directory.
// The environment is the current process's environment
target string // installed file for this package (may be executable)
fake bool // synthesized package
external bool // synthesized external test package
- forceBuild bool // this package must be rebuilt
forceLibrary bool // this package is a library (even if named "main")
cmdline bool // defined by files listed on command line
local bool // imported via local path (./ or ../)
"fmt"
"io"
"math"
- "os"
"path/filepath"
"regexp"
"sort"
return rpt.formatValue(value)
}
-// canAccessFile determines if the filename can be opened for reading.
-func canAccessFile(path string) bool {
- if fi, err := os.Stat(path); err == nil {
- return fi.Mode().Perm()&0400 != 0
- }
- return false
-}
-
// printTags collects all tags referenced in the profile and prints
// them in a sorted table.
func printTags(w io.Writer, rpt *Report) error {
tags tagMap
}
-func (ts tags) string() string {
- var ret string
- for _, s := range ts {
- ret = ret + fmt.Sprintf("%s %s %d %d\n", s.name, s.unit, s.value, s.weight)
- }
- return ret
-}
-
type nodeInfo struct {
name string
origName string
sampleValue func(*profile.Sample) int64
formatValue func(int64) string
}
-
-func (rpt *Report) formatTags(s *profile.Sample) (string, bool) {
- var labels []string
- for key, vals := range s.Label {
- for _, v := range vals {
- labels = append(labels, key+":"+v)
- }
- }
- for key, nvals := range s.NumLabel {
- for _, v := range nvals {
- labels = append(labels, scaledValueLabel(v, key, "auto"))
- }
- }
- if len(labels) == 0 {
- return "", false
- }
- sort.Strings(labels)
- return strings.Join(labels, `\n`), true
-}
// lookahead set information
-var lkst []Lkset
var nolook = 0 // flag to turn off lookahead computations
var tbitset = 0 // size of lookahead sets
var clset Lkset // temporary storage for lookahead computations
return c >= 0xa0 || c == '_' || (c >= 'a' && c <= 'z') || (c >= 'A' && c <= 'Z')
}
-func mktemp(t string) string { return t }
-
//
// return 1 if 2 arrays are equal
// return 0 if not equal
return 1
}
-func putrune(f *bufio.Writer, c int) {
- s := string(c)
- for i := 0; i < len(s); i++ {
- f.WriteByte(s[i])
- }
-}
-
func getrune(f *bufio.Reader) rune {
var r rune
setupDone bool // true if we have parsed the bzip2 header.
blockSize int // blockSize in bytes, i.e. 900 * 1000.
eof bool
- buf []byte // stores Burrows-Wheeler transformed data.
c [256]uint // the `C' array for the inverse BWT.
tt []uint32 // mirrors the `tt' array in the bzip2 source and contains the P array in the upper 24 bits.
tPos uint32 // Index of the next output byte in tt.
return token(matchType + xlength<<lengthShift + xoffset)
}
-// Returns the type of a token
-func (t token) typ() uint32 { return uint32(t) & typeMask }
-
// Returns the literal of a literal token
func (t token) literal() uint32 { return uint32(t - literalType) }
Leaf *x509.Certificate
}
-// A TLS record.
-type record struct {
- contentType recordType
- major, minor uint8
- payload []byte
-}
-
type handshakeMessage interface {
marshal() []byte
unmarshal([]byte) bool
panic("TLS: sequence number wraparound")
}
-// resetSeq resets the sequence number to zero.
-func (hc *halfConn) resetSeq() {
- for i := range hc.seq {
- hc.seq[i] = 0
- }
-}
-
// removePadding returns an unpadded slice, in constant time, which is a prefix
// of the input. It also returns a byte which is equal to 255 if the padding
// was valid and 0 otherwise. See RFC 2246, section 6.2.3.2
return dc, nil
}
-var (
- errConnClosed = errors.New("database/sql: internal sentinel error: conn is closed")
- errConnBusy = errors.New("database/sql: internal sentinel error: conn is busy")
-)
-
// putConnHook is a hook for testing.
var putConnHook func(*DB, *driverConn)
}
return strconv.FormatUint(uint64(i), 10)
}
-
-func flagName(i uint32, names []intName, goSyntax bool) string {
- s := ""
- for _, n := range names {
- if n.i&i == n.i {
- if len(s) > 0 {
- s += "+"
- }
- if goSyntax {
- s += "macho."
- }
- s += n.s
- i -= n.i
- }
- }
- if len(s) == 0 {
- return "0x" + strconv.FormatUint(uint64(i), 16)
- }
- if i != 0 {
- s += "+0x" + strconv.FormatUint(uint64(i), 16)
- }
- return s
-}
}
var (
- begComment = []byte("<!--")
- endComment = []byte("-->")
- endProcInst = []byte("?>")
- endDirective = []byte(">")
+ begComment = []byte("<!--")
+ endComment = []byte("-->")
+ endProcInst = []byte("?>")
)
// EncodeToken writes the given XML token to the stream.
"unicode/utf8"
)
-type writer interface {
- WriteString(string) (int, error)
-}
-
// These replacements permit compatibility with old numeric entities that
// assumed Windows-1252 encoding.
// http://www.whatwg.org/specs/web-apps/current-work/multipage/tokenization.html#consume-a-character-reference
// ErrClosedPipe is the error used for read or write operations on a closed pipe.
var ErrClosedPipe = errors.New("io: read/write on closed pipe")
-type pipeResult struct {
- n int
- err error
-}
-
// A pipe is the shared pipe structure underlying PipeReader and PipeWriter.
type pipe struct {
rl sync.Mutex // gates readers one at a time
statusUnknownRole
)
-const headerLen = 8
-
type header struct {
Version uint8
Type recType
return err
}
-func (c *conn) writeBeginRequest(reqId uint16, role uint16, flags uint8) error {
- b := [8]byte{byte(role >> 8), byte(role), flags}
- return c.writeRecord(typeBeginRequest, reqId, b[:])
-}
-
func (c *conn) writeEndRequest(reqId uint16, appStatus int, protocolStatus uint8) error {
b := make([]byte, 8)
binary.BigEndian.PutUint32(b, uint32(appStatus))
"Trailer": true,
}
-// dumpAsReceived writes req to w in the form as it was received, or
-// at least as accurately as possible from the information retained in
-// the request.
-func dumpAsReceived(req *http.Request, w io.Writer) error {
- return nil
-}
-
// DumpRequest returns the given request in its HTTP/1.x wire
// representation. It should only be used by servers to debug client
// requests. The returned representation is an approximation only;
func (e *httpError) Temporary() bool { return true }
var errTimeout error = &httpError{err: "net/http: timeout awaiting response headers", timeout: true}
-var errClosed error = &httpError{err: "net/http: server closed connection before response was received"}
var errRequestCanceled = errors.New("net/http: request canceled")
var errRequestCanceledConn = errors.New("net/http: request canceled while waiting for connection") // TODO: unify?
func (fakeLocker) Lock() {}
func (fakeLocker) Unlock() {}
-func isNetWriteError(err error) bool {
- switch e := err.(type) {
- case *url.Error:
- return isNetWriteError(e.Err)
- case *net.OpError:
- return e.Op == "write"
- default:
- return false
- }
-}
-
// cloneTLSConfig returns a shallow clone of the exported
// fields of cfg, ignoring the unexported sync.Once, which
// contains a mutex and must not be copied.
)
const ptrSize = 4 << (^uintptr(0) >> 63) // unsafe.Sizeof(uintptr(0)) but an ideal const
-const cannotSet = "cannot set value obtained from unexported struct field"
// Value is the reflection interface to a Go value.
//
end int
cap []int
- input input
jobs []job
visited []uint32
}
return t
}
-// free returns t to the free pool.
-func (m *machine) free(t *thread) {
- m.inputBytes.str = nil
- m.inputString.str = ""
- m.inputReader.r = nil
- m.pool = append(m.pool, t)
-}
-
// match runs the machine over the input starting at pos.
// It reports whether a match was found.
// If so, m.matchcap holds the submatch information.
func (m *machine) clear(q *queue) {
for _, d := range q.dense {
if d.t != nil {
- // m.free(d.t)
m.pool = append(m.pool, d.t)
}
}
continue
}
if longest && m.matched && len(t.cap) > 0 && m.matchcap[0] < t.cap[0] {
- // m.free(t)
m.pool = append(m.pool, t)
continue
}
// First-match mode: cut off all lower-priority threads.
for _, d := range runq.dense[j+1:] {
if d.t != nil {
- // m.free(d.t)
m.pool = append(m.pool, d.t)
}
}
t = m.add(nextq, i.Out, nextPos, t.cap, nextCond, t)
}
if t != nil {
- // m.free(t)
m.pool = append(m.pool, t)
}
}
"unicode/utf8"
)
-var debug = false
-
// Regexp is the representation of a compiled regular expression.
// A Regexp is safe for concurrent use by multiple goroutines.
type Regexp struct {
Swap(i, j int)
}
-func min(a, b int) int {
- if a < b {
- return a
- }
- return b
-}
-
// Insertion sort
func insertionSort(data Interface, a, b int) {
for i := a + 1; i < b; i++ {
complexKind
intKind
floatKind
- integerKind
stringKind
uintKind
)
// Assumed by the unixToInternal computation below.
internalYear = 1
- // The year of the zero Unix time.
- unixYear = 1970
-
// Offsets to convert between internal and absolute or Unix times.
absoluteToInternal int64 = (absoluteZeroYear - internalYear) * 365.2425 * secondsPerDay
internalToAbsolute = -absoluteToInternal