id stringlengths 2 7 | text stringlengths 17 51.2k | title stringclasses 1
value |
|---|---|---|
c15000 | !t.node.MoveTo(n) {
t.node = n.Copy()
}
return true
}
return false
} | |
c15001 | {
return &NodeIterator{query: expr.q.Clone(), node: root}
} | |
c15002 | build(expr)
if err != nil {
return nil, err
}
return &Expr{s: expr, q: qy}, nil
} | |
c15003 | err != nil {
return nil
}
return exp
} | |
c15004 | ok {
return p.Test
}
return func(NodeNavigator) bool { return true }
} | |
c15005 | }
start--
if arg3 != nil {
if length, ok = arg3.Evaluate(t).(float64); !ok {
panic(errors.New("substring() function second argument type must be int"))
}
}
if (len(m) - int(start)) < int(length) {
panic(errors.New("substring() function start and length argument out of range"))
}
if length > 0 ... | |
c15006 | }()
mu.Lock()
s.block = block
if s.closed {
return false
}
var sal C.socklen_t
staticRsa, sal = netAddrToLibSockaddr(addr)
ret := C.utp_process_udp(s.ctx, (*C.byte)(&b[0]), C.size_t(len(b)), (*C.struct_sockaddr)(unsafe.Pointer(&staticRsa)), sal)
switch ret {
case 1:
return true
case 0:
return false
de... | |
c15007 | network, addr)
if err != nil {
c.Close()
return nil, err
}
return c, nil
} | |
c15008 |
offset = fd % (syscall.FD_SETSIZE / len(fds.Bits))
return
} | |
c15009 |
idx, pos := fdget(fd, fds)
fds.Bits[idx] = 1 << uint(pos)
} | |
c15010 |
idx, pos := fdget(fd, fds)
return fds.Bits[idx]&(1<<uint(pos)) != 0
} | |
c15011 | return
}
if done == 0 {
err = ErrTimeout
return
}
n = int(done)
return
} | |
c15012 | error {
return syscall.Select(n, r, w, e, tv)
} | |
c15013 | {
err = fmt.Errorf("serial: could not select: %v", err)
return
}
}
if !fdisset(fd, &rfds) {
// Timeout
err = ErrTimeout
return
}
n, err = syscall.Read(fd, b)
return
} | |
c15014 | nil {
// Warning only.
log.Printf("serial: could not get setting: %v\n", err)
return
}
// Will be reloaded when closing.
p.oldTermios = oldTermios
} | |
c15015 | only.
log.Printf("serial: could not restore setting: %v\n", err)
return
}
p.oldTermios = nil
} | |
c15016 |
// PARODD: Parity is odd.
termios.Cflag |= syscall.PARODD
fallthrough
case "", "E":
// As mentioned in the modbus spec, the default parity mode must be Even parity
// PARENB: Enable parity generation on output.
termios.Cflag |= syscall.PARENB
// INPCK: Enable input parity checking.
termios.Iflag |= sy... | |
c15017 |
syscall.SYS_IOCTL,
uintptr(fd),
uintptr(rs485Tiocs),
uintptr(unsafe.Pointer(&rs485)))
if errno != 0 {
return os.NewSyscallError("SYS_IOCTL (RS485)", errno)
}
if r != 0 {
return errors.New("serial: unknown error from SYS_IOCTL (RS485)")
}
return nil
} | |
c15018 | error) {
p = New()
err = p.Open(c)
return
} | |
c15019 | gcInterval: 1 * time.Minute,
packetReadTimeout: 100 * time.Millisecond,
readHandler: readHandler,
writeHandler: writeHandler,
}
return s
} | |
c15020 | else {
s.sendAEnable = false
s.sendAWinSz = 1
}
} | |
c15021 |
New: func() interface{} {
return make([]byte, datagramLength)
},
}
go s.internalGC()
} | |
c15022 | defaultTimeout
} else {
s.timeout = t
}
} | |
c15023 | < 1 {
s.retries = defaultRetries
} else {
s.retries = count
}
} | |
c15024 |
if err != nil {
return err
}
conn, err := net.ListenUDP("udp", a)
if err != nil {
return err
}
return s.Serve(conn)
} | |
c15025 | != nil {
s.conn4 = nil
}
} else {
s.conn6 = ipv6.NewPacketConn(conn)
if err := s.conn6.SetControlMessage(ipv6.FlagDst|ipv6.FlagInterface, true); err != nil {
s.conn6 = nil
}
}
s.quit = make(chan chan struct{})
if s.singlePort {
s.singlePortProcessRequests()
} else {
for {
select {
case q ... | |
c15026 | struct{})
s.quit <- q
<-q
s.wg.Wait()
} | |
c15027 | case <-time.After(s.gcInterval):
s.runGC <- completedHandlers
completedHandlers = nil
}
}
} | |
c15028 |
for name, value := range opts {
n += copy(p[n:], name)
p[n] = 0
n++
n += copy(p[n:], value)
p[n] = 0
n++
}
return n
} | |
c15029 |
}
return &Client{
addr: a,
timeout: defaultTimeout,
retries: defaultRetries,
}, nil
} | |
c15030 | c.timeout = defaultTimeout
}
c.timeout = t
} | |
c15031 | count < 1 {
c.retries = defaultRetries
}
c.retries = count
} | |
c15032 | 0 {
s.opts = make(options)
s.opts["blksize"] = strconv.Itoa(c.blksize)
}
n := packRQ(s.send, opWRQ, filename, mode, s.opts)
addr, err := s.sendWithRetry(n)
if err != nil {
return nil, err
}
s.addr = addr
s.opts = nil
return s, nil
} | |
c15033 | we don't send options twice
defer func() { delete(r.opts, "blksize") }()
}
if c.tsize {
r.opts["tsize"] = "0"
}
n := packRQ(r.send, opRRQ, filename, mode, r.opts)
l, addr, err := r.receiveWithRetry(n)
if err != nil {
return nil, err
}
r.l = l
r.addr = addr
return r, nil
} | |
c15034 |
}
// make sure FileBackend is last
return append(b, FileBackend)
} | |
c15035 | err := opener(cfg)
if err != nil {
debugf("Failed backend %s: %s", backend, err)
continue
}
return openBackend, nil
}
}
return nil, ErrNoAvailImpl
} | |
c15036 | := &ArrayKeyring{}
for _, i := range initial {
_ = kr.Set(i)
}
return kr
} | |
c15037 | return i, nil
}
return Item{}, ErrKeyNotFound
} | |
c15038 | == nil {
k.items = map[string]Item{}
}
k.items[i.Key] = i
return nil
} | |
c15039 | error {
delete(k.items, key)
return nil
} | |
c15040 | keys = append(keys, key)
}
return keys, nil
} | |
c15041 | *Client) { metaclient.client = client }
} | |
c15042 | *Client) { metaclient.baseURL = base }
} | |
c15043 | defaultBaseURL,
}
for _, opt := range opts {
opt(client)
}
return client
} | |
c15044 |
return json.NewDecoder(r).Decode(metadata)
})
return metadata, err
} | |
c15045 | fmt.Fscanf(r, "%d", dropletID)
return err
})
return *dropletID, err
} | |
c15046 | ioutil.ReadAll(r)
hostname = string(hostnameraw)
return err
})
return hostname, err
} | |
c15047 | ioutil.ReadAll(r)
userdata = string(userdataraw)
return err
})
return userdata, err
} | |
c15048 | ioutil.ReadAll(r)
vendordata = string(vendordataraw)
return err
})
return vendordata, err
} | |
c15049 | ioutil.ReadAll(r)
region = string(regionraw)
return err
})
return region, err
} | |
c15050 | ioutil.ReadAll(r)
authToken = string(authTokenraw)
return err
})
return authToken, err
} | |
c15051 | ioutil.ReadAll(r)
if string(activeraw) == "true" {
active = true
}
return err
})
return active, err
} | |
c15052 | := Marshal(v)
if err != nil {
return err
}
_, err = io.Copy(f, r)
return err
} | |
c15053 |
if err != nil {
// E2BIG errors can be ignored (we'll get them often) as long
// as at least 1 byte was written. If we experienced an E2BIG
// and no bytes were written then the buffer is too small for
// even the next character
if err != syscall.E2BIG || bytesWritten == 0 {
// track anything else
thi... | |
c15054 | C Strings
C.free(unsafe.Pointer(toEncodingC))
C.free(unsafe.Pointer(fromEncodingC))
// check err
if err == nil {
// no error, mark the context as open
converter.open = true
}
return
} | |
c15055 | if this.open {
_, err = C.iconv_close(this.context)
}
return
} | |
c15056 | _, err = C.call_iconv(this.context, inputPointer, &inputLeft, outputPointer, &outputLeft)
// update byte counters
bytesRead = len(input) - int(inputLeft)
bytesWritten = len(output) - int(outputLeft)
} else if inputLeft == 0 && outputLeft > 0 {
// inputPointer will be nil, outputPointer is generated as a... | |
c15057 | a new buffer
tempBuffer := make([]byte, len(outputBuffer)+len(inputBuffer))
// copy the existing data
copy(tempBuffer, outputBuffer)
// switch the buffers
outputBuffer = tempBuffer
// forget the error
err = nil
}
}
if err == nil {
// perform a final shift state reset
_, byt... | |
c15058 | shift sequences
_, shiftBytesWritten, err = converter.Convert(nil, output[bytesWritten:])
// add shift bytes to total bytes
bytesWritten += shiftBytesWritten
}
// close the converter
converter.Close()
}
return
} | |
c15059 | output, err = converter.ConvertString(input)
// close the converter
converter.Close()
}
return
} | |
c15060 | for return
n += bytesRead
this.writePos += bytesWritten
// checks for when we have a full buffer
for this.writePos > 0 {
// if we have an error, just return it
if this.err != nil {
return
}
// else empty the buffer
this.emptyBuffer()
}
return n, err
} | |
c15061 |
a := util.Prof.Enter("render.Transform.(Regions)")
r := v.Regions.Regions()
a.Exit()
a = util.Prof.Enter("render.Transform.(AddAll)")
rs.AddAll(r)
a.Exit()
recipe[k] = rs
}
return recipe
} | |
c15062 | ret = append(ret, RenderUnit{Flavour: flav, Region: r})
}
}
sort.Sort(&ret)
return
} | |
c15063 | e.args, e.bypassUndo, e.composite)
} | |
c15064 | := range e.savedSel.Regions() {
e.v.Sel().Add(r)
}
} | |
c15065 | < k.Bindings[j].Keys[k.seqIndex].Index()
} | |
c15066 | k.Bindings[j], k.Bindings[i]
} | |
c15067 | k.Bindings[i] = k.Bindings[len(k.Bindings)-1]
k.Bindings = k.Bindings[:len(k.Bindings)-1]
} else {
i++
}
}
sort.Sort(k)
if k.parent == nil {
break
}
k = k.parent.KeyBindings()
}
} | |
c15068 | ki := kp.Index()
k.filter(ki, &ret)
if kp.IsCharacter() {
k.filter(int(Any), &ret)
}
return
} | |
c15069 |
}
for _, c := range k.Bindings[i].Context {
if !qc(c.Key, c.Operator, c.Operand, c.MatchAll) {
goto skip
}
}
if kb == nil || kb.priority < k.Bindings[i].priority {
kb = k.Bindings[i]
}
skip:
}
if kb != nil || k.parent == nil {
break
}
k = k.parent.KeyBindings()
}
return
} | |
c15070 | unicode.IsPrint(rune(k.Key)) && !k.Super && !k.Ctrl
} | |
c15071 | k.Key {
k.Shift = true
k.Key = lower
}
} | |
c15072 | := NewJSON(path, marshal)
watch(j)
j.Load()
return j.err
} | |
c15073 | the view has been closed
return
}
if len(v.reparseChan) < cap(v.reparseChan) || forced {
v.reparseChan <- parseReq{forced}
}
} | |
c15074 | edit.composite.AddExec(text.NewEraseAction(v.buffer, r))
} | |
c15075 | string) {
edit.composite.AddExec(text.NewReplaceAction(v.buffer, r, value))
} | |
c15076 | %d: %v, %v", i, l, edit, v.editstack)
}
// Invalidate all Edits "below" and including this Edit.
for j := len(v.editstack) - 1; j >= i; j-- {
current_edit := v.editstack[j]
current_edit.invalid = true
sel_same := reflect.DeepEqual(*v.Sel(), current_edit.savedSel)
buf_same := v.ChangeCount() == current_edit... | |
c15077 |
lastSave := v.Settings().Int("lime.last_save_change_count", -1)
return v.ChangeCount() != lastSave
} | |
c15078 | if err := v.nonAtomicSave(name); err != nil {
return err
}
}
if err := os.RemoveAll(n); err != nil {
return err
}
}
ed := GetEditor()
if fn := v.FileName(); fn != name {
v.SetFileName(name)
if fn != "" {
ed.UnWatch(fn, v)
}
ed.Watch(name, v)
}
v.Settings().Set("lime.last_save_change... | |
c15079 | flags}
vr.Regions.AddAll(regions)
v.lock.Lock()
defer v.lock.Unlock()
v.regions[key] = vr
} | |
c15080 |
vr := v.regions[key]
rs := vr.Regions.Regions()
ret = make([]text.Region, len(rs))
copy(ret, rs)
return
} | |
c15081 | v.lock.Lock()
defer v.lock.Unlock()
delete(v.regions, key)
} | |
c15082 | the reparseChan, and setting to nil will eventually clean up other resources
// when the parseThread exits
v.lock.Lock()
defer v.lock.Unlock()
close(v.reparseChan)
v.reparseChan = nil
return true
} | |
c15083 | {
if p <= 0 {
return 0
}
if p >= size {
return size
}
if v.Classify(p)&classes != 0 {
return p
}
}
} | |
c15084 |
if a > 0 {
a -= 1
} else if a < 0 {
a = 0
}
b := r.B
size := v.Size()
if b < size {
b += 1
} else if b > size {
b = size
}
for ; a > 0 && (v.Classify(a)&classes == 0); a -= 1 {
}
for ; b < size && (v.Classify(b)&classes == 0); b += 1 {
}
return text.Region{a, b}
} | |
c15085 | return err
}
continue
}
}
rv := reflect.ValueOf(fv)
rvtype := rv.Type()
ftype := f.Type()
if !rvtype.AssignableTo(ftype) {
if rvtype.ConvertibleTo(ftype) {
rv = rv.Convert(ftype)
} else {
return fmt.Errorf("Command %v arg %v of type %v not assignable or convertable to %v of type %v"... | |
c15086 | {
return false
}
GetEditor().remove(w)
return true
} | |
c15087 | > 0 {
if !w.views[0].Close() {
return false
}
}
return true
} | |
c15088 |
}
if abs, err := filepath.Abs(name); err != nil {
p.SetName(name)
} else {
p.SetName(abs)
}
return nil
} | |
c15089 | finished")
for _, ev := range *ie {
ev()
}
} | |
c15090 | if err := w.removeWatch(p); err != nil {
log.Error("Couldn't unwatch file %s: %s", p, err)
}
}
}
} | |
c15091 | if err := w.watch(p, stat.IsDir()); err != nil {
log.Error("Could not watch: %s", err)
continue
}
}
}
w.dirs = util.Remove(w.dirs, name)
} | |
c15092 | = nil
w.dirs = nil
close(w.fsEvent)
w.fsEvent = nil
return
}
w.parseEv(ev)
}
}
} | |
c15093 | to = len(us.actions)
}
for us.position < to {
us.actions[us.position].Apply()
us.position++
}
} | |
c15094 |
entries[i].name = a.command
entries[i].args = a.args
e.composite.Add(a)
}
us.position = mark
us.actions = us.actions[:mark+1]
e.args = make(Args)
e.args["commands"] = entries
us.Add(&e)
} | |
c15095 | pkg); err != nil {
log.Warn("Couldn't watch %s: %s", pkg.Path(), err)
}
} | |
c15096 |
if err := watcher.Watch(sd.path, sd); err != nil {
log.Error("Couldn't watch %s: %s", sd.path, err)
}
} | |
c15097 |
rm = append(rm, k)
} else {
(*vrm)[k] = v
}
}
for _, r := range rm {
delete(*vrm, r)
}
} | |
c15098 | if in.Size() != 0 {
nr = append(nr, in)
}
}
}
vr.Regions.Clear()
vr.Regions.AddAll(nr)
} | |
c15099 | vr.Flags}
ret.Regions.AddAll(vr.Regions.Regions())
return &ret
} |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.