id stringlengths 2 7 | text stringlengths 17 51.2k | title stringclasses 1 value |
|---|---|---|
c180400 | int8(p.ReadUint8(a))
} | |
c180401 | int16(p.ReadUint16(a))
} | |
c180402 | int32(p.ReadUint32(a))
} | |
c180403 | int64(p.ReadUint64(a))
} | |
c180404 | p.ptrSize == 4 {
return uint64(p.ReadUint32(a))
}
return p.ReadUint64(a)
} | |
c180405 | Address(p.ReadUintptr(a))
} | |
c180406 | b := make([]byte, n)
p.ReadAt(b, a)
return string(b)
}
}
} | |
c180407 | return "", 0
}
return m.f.Name(), m.off
} | |
c180408 | t1 == nil {
return nil
}
t0 := t1[a>>22%(1<<10)]
if t0 == nil {
return nil
}
return t0[a>>12%(1<<10)]
} | |
c180409 | return a
}
return b
} | |
c180410 | return a
}
return b
} | |
c180411 | + Address(x) - 1) & ^(Address(x) - 1)
} | |
c180412 | d.parents[item.name] = item.parentName
d.vertices[n] = item.name
n++
visitChild := func(_ int64, child Object, _ int64) bool {
childIdx, _ := d.p.findObjectIndex(d.p.Addr(child))
work = append(work, workItem{name: vName(childIdx + d.nRoots + 1), parentName: item.name})
return true
}
root, object := d.findVertexByName(item.name)
if root != nil {
d.p.ForEachRootPtr(root, visitChild)
} else {
d.p.ForEachPtr(object, visitChild)
}
}
} | |
c180413 | d.vertices[d.semis[w]] {
d.idom[w] = d.parents[w]
} else {
buckets[w] = buckets[d.vertices[d.semis[w]]]
buckets[d.vertices[d.semis[w]]] = w
}
}
// The final 'Step 3' is now outside the loop.
for v := buckets[pseudoRoot]; v != pseudoRoot; v = buckets[v] {
d.idom[v] = pseudoRoot
}
// Step 4. Explicitly define the immediate dominator of each
// node, in preorder.
for _, w := range d.vertices[1:] {
if d.idom[w] != d.vertices[d.semis[w]] {
d.idom[w] = d.idom[d.idom[w]]
}
}
} | |
c180414 |
d.compress(v)
return d.labels[v]
} | |
c180415 | stack[:len(stack)-1]
if d.semis[d.labels[d.ancestor[v]]] < d.semis[d.labels[v]] {
d.labels[v] = d.labels[d.ancestor[v]]
}
d.ancestor[v] = d.ancestor[d.ancestor[v]]
}
} | |
c180416 | d.ancestor[w] = v
} | |
c180417 | // Make tmp cumulative. After this step, cnt[1:] is what we want for
// ridx, but the next step messes it up.
var n int
for idx, c := range tmp {
n += c
tmp[idx] = n
}
// Store outbound edges in redge, using cnt[1:] as the index to store
// the next edge for each vertex. After we're done, everything's been
// shifted over one, and cnt is ridx.
redge := make([]vName, len(d.idom))
tmp = cnt[1:]
for i, idom := range d.idom {
redge[tmp[idom]] = vName(i)
tmp[idom]++
}
d.redge, d.ridx = redge, cnt[:len(cnt)-1]
} | |
c180418 | root, obj := d.findVertexByName(item.v)
var size int64
switch {
case item.v == pseudoRoot:
break
case root != nil:
size += root.Type.Size
default:
size += p.Size(obj)
}
for _, w := range kids {
size += d.size[w]
}
d.size[item.v] = size
}
} | |
c180419 |
s = fmt.Sprintf("[%d]", off/t.Size)
off %= t.Size
}
return s + typeFieldName(t, off)
} | |
c180420 | p.findMapping(a) != nil
} | |
c180421 | c := m.max.Sub(a)
if n <= c {
return true
}
n -= c
a = a.Add(c)
}
} | |
c180422 | nil {
m2.off += m.Size()
}
if m2.origF != nil {
m2.origOff += m.Size()
}
p.memory.mappings = append(p.memory.mappings, m2)
return
}
} | |
c180423 | if x == 0 {
return nil
}
return p.runtimeType2Type(x)
case KindIface:
x := p.proc.ReadPtr(a)
if x == 0 {
return nil
}
// Read type out of itab.
x = p.proc.ReadPtr(x.Add(p.proc.PtrSize()))
return p.runtimeType2Type(x)
}
} | |
c180424 | $IMAGE_PATH
fi
mkdir -p $MOUNT_PATH
if ! mountpoint -q $MOUNT_PATH; then
mount -t btrfs $lo $MOUNT_PATH
fi
`)
idempotent.Env = []string{
"PATH=" + os.Getenv("PATH"),
"MOUNT_PATH=" + fs.mountPath,
"IMAGE_PATH=" + fs.imagePath,
fmt.Sprintf("SIZE_IN_BYTES=%d", bytes),
}
_, err := fs.run(idempotent)
return err
} | |
c180425 | nil {
return nil, err
}
addr, err := net.ResolveIPAddr("ip", host)
if err != nil {
return nil, err
}
return addr, nil
} | |
c180426 | != b.tokenType {
return false
}
return a.value == b.value
} | |
c180427 |
t.addRuneClass(escapeRunes, escapeRuneClass)
t.addRuneClass(commentRunes, commentRuneClass)
return t
} | |
c180428 | // skip comments
default:
return "", fmt.Errorf("Unknown token type: %v", token.tokenType)
}
}
} | |
c180429 |
return &Tokenizer{
input: *input,
classifier: classifier}
} | |
c180430 | err == io.EOF {
return subStrings, nil
}
return subStrings, err
}
subStrings = append(subStrings, word)
}
} | |
c180431 | if endPos < 0 {
return ""
} else if right == "" {
return s[endPos:]
} else {
return s[startPos+l : endPos]
}
} | |
c180432 | {
return func(s string) string {
return Between(s, left, right)
}
} | |
c180433 | val = camelizeRe2.ReplaceAllString(val, "")
return val
})
} | |
c180434 | strings.ToUpper(s[0:1]) + strings.ToLower(s[1:])
} | |
c180435 | l == 0
if shortcut {
return ""
}
return s[index : index+1]
} | |
c180436 | string) string {
return CharAt(s, index)
}
} | |
c180437 | return s[len(prefix):]
}
return s
} | |
c180438 | string) string {
return ChompLeft(s, prefix)
}
} | |
c180439 | return s[:len(s)-len(suffix)]
}
return s
} | |
c180440 | string) string {
return ChompRight(s, suffix)
}
} | |
c180441 | string) string {
return Classify(s)
}
} | |
c180442 | = beginEndSpacesRe.ReplaceAllString(s, "")
return s
} | |
c180443 | dashesRe.ReplaceAllString(s, "-")
s = strings.ToLower(s)
return s
} | |
c180444 | html.EscapeString instead of EscapeHTML")
}
return html.EscapeString(s)
} | |
c180445 | html.UnescapeString instead of DecodeHTMLEntities")
}
return html.UnescapeString(s)
} | |
c180446 | {
return func(s string) string {
return EnsurePrefix(s, prefix)
}
} | |
c180447 | {
return func(s string) string {
return EnsureSuffix(s, suffix)
}
} | |
c180448 |
s = humanizeRe.ReplaceAllString(s, "")
s = strings.Replace(s, "_", " ", -1)
s = strings.TrimSpace(s)
s = Capitalize(s)
return s
} | |
c180449 | string) string {
if condition {
return truthy
}
return falsey
} | |
c180450 | -1
}
pos := strings.Index(s[start:], needle)
if pos == -1 {
return -1
}
return start + pos
} | |
c180451 | == strings.ToLower(s)
} | |
c180452 | == strings.ToUpper(s)
} | |
c180453 | n < 0 {
return Right(s, -n)
}
return Substr(s, 0, n)
} | |
c180454 | string {
return Left(s, n)
}
} | |
c180455 | result = append(result, string(r))
}
return result
} | |
c180456 | return strings.Split(s, "\n")
} | |
c180457 | range arr {
r = append(r, iterator(item))
}
return r
} | |
c180458 | := regexp.MustCompile(pattern)
return r.MatchString(s)
} | |
c180459 | goa.Pipe(
f.Load("./README.md"),
f.Str(str.ReplaceF("--", "\n[godoc](https://godoc.org/"+packageName+")\n", 1)),
f.Write(),
)
}).Src("**/*.go")
p.Task("test", nil, func(c *do.Context) {
c.Run("go test")
})
} | |
c180460 | right := strings.Repeat(c, int(math.Floor(float64(n)/2)))
return left + s + right
} | |
c180461 | string) string {
return Pad(s, c, n)
}
} | |
c180462 | return s
}
return strings.Repeat(c, (n-L)) + s
} | |
c180463 | string) string {
return PadLeft(s, c, n)
}
} | |
c180464 | string) string {
return PadRight(s, c, n)
}
} | |
c180465 | string {
for _, fn := range funcs {
s = fn(s)
}
return s
} | |
c180466 | {
return strconv.Quote(s)
})
} | |
c180467 | return strings.Replace(s, old, new, n)
}
} | |
c180468 | return ReplacePattern(s, pattern, repl)
}
} | |
c180469 | range s {
i--
cs[i] = c
}
return string(cs)
} | |
c180470 | string {
return Right(s, n)
}
} | |
c180471 | L+end > 0 {
return s[start : L-end]
}
return s[start:]
} | |
c180472 | {
return func(s string) string {
return Slice(s, start, end)
}
} | |
c180473 | if it == val {
return true
}
}
return false
} | |
c180474 |
return -1
}
for i, it := range slice {
if it == val {
return i
}
}
return -1
} | |
c180475 | strings.ToLower(sl)
sl = Dasherize(sl)
return sl
} | |
c180476 | nWhitespaceRe.ReplaceAllString(s, " ")
return s
} | |
c180477 | stripTagsRe := regexp.MustCompile(`(?i)<\/?` + tag + `[^<>]*>`)
s = stripTagsRe.ReplaceAllString(s, "")
}
return s
} | |
c180478 | if end >= L {
end = L
}
if end <= index {
return ""
}
return s[index:end]
} | |
c180479 | string) string {
return Substr(s, index, n)
}
} | |
c180480 | for _, submatches := range matches {
match := submatches[0]
key := submatches[1]
//log.Printf("match %s key %s\n", match, key)
if values[key] != nil {
v := fmt.Sprintf("%v", values[key])
s = strings.Replace(s, match, v, -1)
}
}
return s
} | |
c180481 | InArgQuote:
if i == L-1 {
if runtime.GOOS == "windows" {
// just add \ to end for windows
currentArg += c
} else {
panic("Escape character at end string")
}
} else {
if runtime.GOOS == "windows" {
peek := s[i+1 : i+2]
if peek != `"` {
currentArg += c
}
} else {
i++
c = s[i : i+1]
currentArg += c
}
}
}
} else {
switch currentState {
case InArg, InArgQuote:
currentArg += c
case OutOfArg:
currentArg = ""
currentArg += c
currentState = InArg
}
}
}
if currentState == InArg {
argv = append(argv, currentArg)
} else if currentState == InArgQuote {
panic("Starting quote has no ending quote.")
}
return argv
} | |
c180482 |
return s == "true" || s == "yes" || s == "on" || s == "1"
} | |
c180483 | err != nil {
return defaultValue
}
return b
} | |
c180484 | err := strconv.Atoi(s)
if err != nil {
return defaultValue
}
return n
} | |
c180485 | := strconv.ParseFloat(s, 32)
if err != nil {
return defaultValue
}
return float32(f)
} | |
c180486 | f, err := strconv.ParseFloat(s, 64)
if err != nil {
return defaultValue
}
return f
} | |
c180487 | html.UnescapeString instead of UnescapeHTML")
}
return html.UnescapeString(s)
} | |
c180488 |
for name, val := range attrs {
el += " " + name + "=\"" + escapeHTMLAttributeQuotes(val) + "\""
}
el += ">" + s + "</" + tag + ">"
return el
} | |
c180489 | func(s string) string {
return WrapHTML(s, tag, attrs)
}
} | |
c180490 |
return
case unix.ECHILD:
// No more children, we are done.
return
case unix.EINTR:
// We got interrupted, try again. This likely
// can't happen since we are calling Wait4 in a
// non-blocking fashion, but it's good to be
// complete and handle this case rather than
// fail.
goto POLL
default:
// We got some other error we didn't expect.
// Wait for another SIGCHLD so we don't
// potentially spam in here and chew up CPU.
if errors != nil {
errors <- err
}
return
}
}()
}
} | |
c180491 | if err != nil {
return err
}
defer conn.Close()
_, err = conn.Write([]byte(state))
return err
} | |
c180492 |
// initialize clients
for _, model := range policy.Clients {
coal.Init(model)
}
return &Authenticator{
store: store,
policy: policy,
}
} | |
c180493 | len(s) != 1 || (s[0] != "authorize" && s[0] != "token" && s[0] != "revoke") {
w.WriteHeader(http.StatusNotFound)
return
}
// copy store
store := a.store.Copy()
defer store.Close()
// create
state := &state{
request: r,
writer: w,
store: store,
tracer: tracer,
}
// call endpoints
switch s[0] {
case "authorize":
a.authorizationEndpoint(state)
case "token":
a.tokenEndpoint(state)
case "revoke":
a.revocationEndpoint(state)
}
})
} | |
c180494 | _, ok := m[id]; !ok {
m[id] = true
l = append(l, id)
}
}
return l
} | |
c180495 |
if item == id {
return true
}
}
return false
} | |
c180496 | := range subset {
if !Contains(all, item) {
return false
}
}
return true
} | |
c180497 | check all flags
for _, f := range flags {
L(m, f, true)
}
} | |
c180498 | err
}
// marshall into job
err = bson.Unmarshal(raw, &job.Data)
if err != nil {
return nil, err
}
// insert job
err = store.C(job).Insert(job)
if err != nil {
return nil, err
}
return job, nil
} | |
c180499 | &Authorizer{
Matcher: m,
Handler: func(ctx *fire.Context) ([]*Enforcer, error) {
// begin trace
ctx.Tracer.Push(name)
// call handler
enforcers, err := h(ctx)
if err != nil {
return nil, err
}
// finish trace
ctx.Tracer.Pop()
return enforcers, nil
},
}
} |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.