_id stringlengths 2 7 | title stringlengths 1 118 | partition stringclasses 3
values | text stringlengths 52 85.5k | language stringclasses 1
value | meta_information dict |
|---|---|---|---|---|---|
q27200 | Save | train | func (rwt *RWTree) Save() ([]byte, int64, error) {
// save state at a new version may still be orphaned before we save the version against the hash
hash, version, err := rwt.tree.SaveVersion()
if err != nil {
return nil, 0, fmt.Errorf("could not save RWTree: %v", err)
}
// Take an immutable reference to the tree... | go | {
"resource": ""
} |
q27201 | PushBytes | train | func (st *Stack) PushBytes(bz []byte) {
if len(bz) != 32 {
panic("Invalid bytes size: expected 32")
}
st.Push(LeftPadWord256(bz))
} | go | {
"resource": ""
} |
q27202 | PushBigInt | train | func (st *Stack) PushBigInt(bigInt *big.Int) Word256 {
word := LeftPadWord256(U256(bigInt).Bytes())
st.Push(word)
return word
} | go | {
"resource": ""
} |
q27203 | Peek | train | func (st *Stack) Peek() Word256 {
if st.ptr == 0 {
st.pushErr(errors.ErrorCodeDataStackUnderflow)
return Zero256
}
return st.slice[st.ptr-1]
} | go | {
"resource": ""
} |
q27204 | NewCache | train | func NewCache(backend Reader, options ...CacheOption) *Cache {
cache := &Cache{
backend: backend,
accounts: make(map[crypto.Address]*accountInfo),
}
for _, option := range options {
option(cache)
}
return cache
} | go | {
"resource": ""
} |
q27205 | IterateCachedAccount | train | func (cache *Cache) IterateCachedAccount(consumer func(*acm.Account) (stop bool)) (stopped bool, err error) {
// Try cache first for early exit
cache.RLock()
for _, info := range cache.accounts {
if consumer(info.account) {
cache.RUnlock()
return true, nil
}
}
cache.RUnlock()
return false, nil
} | go | {
"resource": ""
} |
q27206 | IterateCachedStorage | train | func (cache *Cache) IterateCachedStorage(address crypto.Address,
consumer func(key, value binary.Word256) error) error {
accInfo, err := cache.get(address)
if err != nil {
return err
}
accInfo.RLock()
// Try cache first for early exit
for key, value := range accInfo.storage {
if err := consumer(key, value); ... | go | {
"resource": ""
} |
q27207 | Sync | train | func (cache *Cache) Sync(st Writer) error {
if cache.readonly {
// Sync is (should be) a no-op for read-only - any modifications should have been caught in respective methods
return nil
}
cache.Lock()
defer cache.Unlock()
var addresses crypto.Addresses
for address := range cache.accounts {
addresses = appen... | go | {
"resource": ""
} |
q27208 | matchLogLine | train | func matchLogLine(keyvals []interface{}, keyRegexes, valueRegexes []*regexp.Regexp, matchAll bool) bool {
all := matchAll
// We should be passed an aligned list of keyRegexes and valueRegexes, but since we can't error here we'll guard
// against a failure of the caller to pass valid arguments
length := len(keyRegex... | go | {
"resource": ""
} |
q27209 | JSONBytes | train | func (genesisDoc *GenesisDoc) JSONBytes() ([]byte, error) {
// Just in case
genesisDoc.GenesisTime = genesisDoc.GenesisTime.UTC()
return json.MarshalIndent(genesisDoc, "", "\t")
} | go | {
"resource": ""
} |
q27210 | Clone | train | func (genesisAccount *Account) Clone() Account {
// clone the account permissions
return Account{
BasicAccount: BasicAccount{
Address: genesisAccount.Address,
Amount: genesisAccount.Amount,
},
Name: genesisAccount.Name,
Permissions: genesisAccount.Permissions.Clone(),
}
} | go | {
"resource": ""
} |
q27211 | Clone | train | func (gv *Validator) Clone() Validator {
// clone the addresses to unbond to
unbondToClone := make([]BasicAccount, len(gv.UnbondTo))
for i, basicAccount := range gv.UnbondTo {
unbondToClone[i] = basicAccount.Clone()
}
return Validator{
BasicAccount: BasicAccount{
PublicKey: gv.PublicKey,
Amount: gv.Am... | go | {
"resource": ""
} |
q27212 | MakeGenesisDocFromAccounts | train | func MakeGenesisDocFromAccounts(chainName string, salt []byte, genesisTime time.Time, accounts map[string]*acm.Account,
validators map[string]*validator.Validator) *GenesisDoc {
// Establish deterministic order of accounts by name so we obtain identical GenesisDoc
// from identical input
names := make([]string, 0,... | go | {
"resource": ""
} |
q27213 | Tokens | train | func (bc Bytecode) Tokens() ([]string, error) {
// Overestimate of capacity in the presence of pushes
tokens := make([]string, 0, len(bc))
for i := 0; i < len(bc); i++ {
op, ok := asm.GetOpCode(bc[i])
if !ok {
return tokens, fmt.Errorf("did not recognise byte %#x at position %v as an OpCode:\n %s",
bc[i]... | go | {
"resource": ""
} |
q27214 | NewBuilder | train | func NewBuilder(queries ...string) *Builder {
qb := new(Builder)
qb.queryString = qb.and(stringIterator(queries...))
return qb
} | go | {
"resource": ""
} |
q27215 | And | train | func (qb *Builder) And(queryBuilders ...*Builder) *Builder {
return NewBuilder(qb.and(queryBuilderIterator(queryBuilders...)))
} | go | {
"resource": ""
} |
q27216 | AndEquals | train | func (qb *Builder) AndEquals(tag string, operand interface{}) *Builder {
qb.condition.Tag = tag
qb.condition.Op = equalString
qb.condition.Operand = operandString(operand)
return NewBuilder(qb.and(stringIterator(qb.conditionString())))
} | go | {
"resource": ""
} |
q27217 | stringIterator | train | func stringIterator(strs ...string) func(func(string)) {
return func(callback func(string)) {
for _, s := range strs {
callback(s)
}
}
} | go | {
"resource": ""
} |
q27218 | NewParser | train | func NewParser(options ...func(*Parser)) *Parser {
p := &Parser{helperBuf: new(bytes.Buffer)}
for _, opt := range options {
opt(p)
}
return p
} | go | {
"resource": ""
} |
q27219 | Parse | train | func (p *Parser) Parse(r io.Reader, name string) (*File, error) {
p.reset()
p.f = &File{Name: name}
p.src = r
p.rune()
p.next()
p.f.Stmts, p.f.Last = p.stmtList()
if p.err == nil {
// EOF immediately after heredoc word so no newline to
// trigger it
p.doHeredocs()
}
return p.f, p.err
} | go | {
"resource": ""
} |
q27220 | Stmts | train | func (p *Parser) Stmts(r io.Reader, fn func(*Stmt) bool) error {
p.reset()
p.f = &File{}
p.src = r
p.rune()
p.next()
p.stmts(fn)
if p.err == nil {
// EOF immediately after heredoc word so no newline to
// trigger it
p.doHeredocs()
}
return p.err
} | go | {
"resource": ""
} |
q27221 | Words | train | func (p *Parser) Words(r io.Reader, fn func(*Word) bool) error {
p.reset()
p.f = &File{}
p.src = r
p.rune()
p.next()
for {
p.got(_Newl)
w := p.getWord()
if w == nil {
if p.tok != _EOF {
p.curErr("%s is not a valid word", p.tok)
}
return p.err
}
if !fn(w) {
return nil
}
}
} | go | {
"resource": ""
} |
q27222 | Document | train | func (p *Parser) Document(r io.Reader) (*Word, error) {
p.reset()
p.f = &File{}
p.src = r
p.rune()
p.quote = hdocBody
p.hdocStop = []byte("MVDAN_CC_SH_SYNTAX_EOF")
p.parsingDoc = true
p.next()
w := p.getWord()
return w, p.err
} | go | {
"resource": ""
} |
q27223 | Incomplete | train | func (p *Parser) Incomplete() bool {
// If we're in a quote state other than noState, we're parsing a node
// such as a double-quoted string.
// If there are any open statements, we need to finish them.
// If we're constructing a literal, we need to finish it.
return p.quote != noState || p.openStmts > 0 || p.litB... | go | {
"resource": ""
} |
q27224 | IsIncomplete | train | func IsIncomplete(err error) bool {
perr, ok := err.(ParseError)
return ok && perr.Incomplete
} | go | {
"resource": ""
} |
q27225 | ValidName | train | func ValidName(val string) bool {
if val == "" {
return false
}
for i, r := range val {
switch {
case 'a' <= r && r <= 'z':
case 'A' <= r && r <= 'Z':
case r == '_':
case i > 0 && '0' <= r && r <= '9':
default:
return false
}
}
return true
} | go | {
"resource": ""
} |
q27226 | String | train | func (v Variable) String() string {
switch v.Kind {
case String:
return v.Str
case Indexed:
if len(v.List) > 0 {
return v.List[0]
}
case Associative:
// nothing to do
}
return ""
} | go | {
"resource": ""
} |
q27227 | Resolve | train | func (v Variable) Resolve(env Environ) (string, Variable) {
name := ""
for i := 0; i < maxNameRefDepth; i++ {
if v.Kind != NameRef {
return name, v
}
name = v.Str // keep name for the next iteration
v = env.Get(name)
}
return name, Variable{}
} | go | {
"resource": ""
} |
q27228 | listEnvironWithUpper | train | func listEnvironWithUpper(upper bool, pairs ...string) Environ {
list := append([]string{}, pairs...)
if upper {
// Uppercase before sorting, so that we can remove duplicates
// without the need for linear search nor a map.
for i, s := range list {
if sep := strings.IndexByte(s, '='); sep > 0 {
list[i] =... | go | {
"resource": ""
} |
q27229 | hasPermissionToDir | train | func hasPermissionToDir(info os.FileInfo) bool {
user, err := user.Current()
if err != nil {
return true
}
uid, _ := strconv.Atoi(user.Uid)
// super-user
if uid == 0 {
return true
}
st, _ := info.Sys().(*syscall.Stat_t)
if st == nil {
return true
}
perm := info.Mode().Perm()
// user (u)
if perm&0100... | go | {
"resource": ""
} |
q27230 | SourceFile | train | func SourceFile(ctx context.Context, path string) (map[string]expand.Variable, error) {
f, err := os.Open(path)
if err != nil {
return nil, fmt.Errorf("could not open: %v", err)
}
defer f.Close()
file, err := syntax.NewParser().Parse(f, path)
if err != nil {
return nil, fmt.Errorf("could not parse: %v", err)
... | go | {
"resource": ""
} |
q27231 | New | train | func New(opts ...func(*Runner) error) (*Runner, error) {
r := &Runner{usedNew: true}
r.dirStack = r.dirBootstrap[:0]
for _, opt := range opts {
if err := opt(r); err != nil {
return nil, err
}
}
// Set the default fallbacks, if necessary.
if r.Env == nil {
Env(nil)(r)
}
if r.Dir == "" {
if err := Dir... | go | {
"resource": ""
} |
q27232 | Env | train | func Env(env expand.Environ) func(*Runner) error {
return func(r *Runner) error {
if env == nil {
env = expand.ListEnviron(os.Environ()...)
}
r.Env = env
return nil
}
} | go | {
"resource": ""
} |
q27233 | Dir | train | func Dir(path string) func(*Runner) error {
return func(r *Runner) error {
if path == "" {
path, err := os.Getwd()
if err != nil {
return fmt.Errorf("could not get current dir: %v", err)
}
r.Dir = path
return nil
}
path, err := filepath.Abs(path)
if err != nil {
return fmt.Errorf("could n... | go | {
"resource": ""
} |
q27234 | Module | train | func Module(mod ModuleFunc) func(*Runner) error {
return func(r *Runner) error {
switch mod := mod.(type) {
case ModuleExec:
if mod == nil {
mod = DefaultExec
}
r.Exec = mod
case ModuleOpen:
if mod == nil {
mod = DefaultOpen
}
r.Open = mod
default:
return fmt.Errorf("unknown module... | go | {
"resource": ""
} |
q27235 | StdIO | train | func StdIO(in io.Reader, out, err io.Writer) func(*Runner) error {
return func(r *Runner) error {
r.Stdin = in
if out == nil {
out = ioutil.Discard
}
r.Stdout = out
if err == nil {
err = ioutil.Discard
}
r.Stderr = err
return nil
}
} | go | {
"resource": ""
} |
q27236 | Literal | train | func Literal(cfg *Config, word *syntax.Word) (string, error) {
if word == nil {
return "", nil
}
cfg = prepareConfig(cfg)
field, err := cfg.wordField(word.Parts, quoteNone)
if err != nil {
return "", err
}
return cfg.fieldJoin(field), nil
} | go | {
"resource": ""
} |
q27237 | Document | train | func Document(cfg *Config, word *syntax.Word) (string, error) {
if word == nil {
return "", nil
}
cfg = prepareConfig(cfg)
field, err := cfg.wordField(word.Parts, quoteDouble)
if err != nil {
return "", err
}
return cfg.fieldJoin(field), nil
} | go | {
"resource": ""
} |
q27238 | Pattern | train | func Pattern(cfg *Config, word *syntax.Word) (string, error) {
cfg = prepareConfig(cfg)
field, err := cfg.wordField(word.Parts, quoteNone)
if err != nil {
return "", err
}
buf := cfg.strBuilder()
for _, part := range field {
if part.quote > quoteNone {
buf.WriteString(syntax.QuotePattern(part.val))
} els... | go | {
"resource": ""
} |
q27239 | Fields | train | func Fields(cfg *Config, words ...*syntax.Word) ([]string, error) {
cfg = prepareConfig(cfg)
fields := make([]string, 0, len(words))
dir := cfg.envGet("PWD")
for _, word := range words {
afterBraces := []*syntax.Word{word}
if w2 := syntax.SplitBraces(word); w2 != word {
afterBraces = Braces(w2)
}
for _, ... | go | {
"resource": ""
} |
q27240 | pathJoin2 | train | func pathJoin2(elem1, elem2 string) string {
if elem1 == "" {
return elem2
}
if strings.HasSuffix(elem1, string(filepath.Separator)) {
return elem1 + elem2
}
return elem1 + string(filepath.Separator) + elem2
} | go | {
"resource": ""
} |
q27241 | pathSplit | train | func pathSplit(path string) []string {
path = filepath.FromSlash(path)
return strings.Split(path, string(filepath.Separator))
} | go | {
"resource": ""
} |
q27242 | CouldBeScript | train | func CouldBeScript(info os.FileInfo) ScriptConfidence {
name := info.Name()
switch {
case info.IsDir(), name[0] == '.':
return ConfNotScript
case info.Mode()&os.ModeSymlink != 0:
return ConfNotScript
case extRe.MatchString(name):
return ConfIsScript
case strings.IndexByte(name, '.') > 0:
return ConfNotScr... | go | {
"resource": ""
} |
q27243 | atoi | train | func atoi(s string) int {
n, _ := strconv.Atoi(s)
return n
} | go | {
"resource": ""
} |
q27244 | Fields | train | func Fields(s string, env func(string) string) ([]string, error) {
p := syntax.NewParser()
var words []*syntax.Word
err := p.Words(strings.NewReader(s), func(w *syntax.Word) bool {
words = append(words, w)
return true
})
if err != nil {
return nil, err
}
if env == nil {
env = os.Getenv
}
cfg := &expand... | go | {
"resource": ""
} |
q27245 | KeepPadding | train | func KeepPadding(p *Printer) {
p.keepPadding = true
p.cols.Writer = p.bufWriter.(*bufio.Writer)
p.bufWriter = &p.cols
} | go | {
"resource": ""
} |
q27246 | NewPrinter | train | func NewPrinter(options ...func(*Printer)) *Printer {
p := &Printer{
bufWriter: bufio.NewWriter(nil),
tabsPrinter: new(Printer),
tabWriter: new(tabwriter.Writer),
}
for _, opt := range options {
opt(p)
}
return p
} | go | {
"resource": ""
} |
q27247 | FromModuleContext | train | func FromModuleContext(ctx context.Context) (ModuleCtx, bool) {
mc, ok := ctx.Value(moduleCtxKey{}).(ModuleCtx)
return mc, ok
} | go | {
"resource": ""
} |
q27248 | DebugPrint | train | func DebugPrint(w io.Writer, node Node) error {
p := debugPrinter{out: w}
p.print(reflect.ValueOf(node))
return p.err
} | go | {
"resource": ""
} |
q27249 | fill | train | func (p *Parser) fill() {
p.offs += p.bsp
left := len(p.bs) - p.bsp
copy(p.readBuf[:left], p.readBuf[p.bsp:])
readAgain:
n, err := 0, p.readErr
if err == nil {
n, err = p.src.Read(p.readBuf[left:])
p.readErr = err
}
if n == 0 {
if err == nil {
goto readAgain
}
// don't use p.errPass as we don't want... | go | {
"resource": ""
} |
q27250 | AddFile | train | func (self *FileSet) AddFile(filename, src string) int {
base := self.nextBase()
file := &File{
name: filename,
src: src,
base: base,
}
self.files = append(self.files, file)
self.last = file
return base
} | go | {
"resource": ""
} |
q27251 | newBoundFunction | train | func (runtime *_runtime) newBoundFunction(target *_object, this Value, argumentList []Value) *_object {
self := runtime.newBoundFunctionObject(target, this, argumentList)
self.prototype = runtime.global.FunctionPrototype
prototype := runtime.newObject()
self.defineProperty("prototype", toValue_object(prototype), 01... | go | {
"resource": ""
} |
q27252 | CompileWithSourceMap | train | func (self *Otto) CompileWithSourceMap(filename string, src, sm interface{}) (*Script, error) {
program, err := self.runtime.parse(filename, src, sm)
if err != nil {
return nil, err
}
cmpl_program := cmpl_parse(program)
script := &Script{
version: scriptVersion,
program: cmpl_program,
filename: filenam... | go | {
"resource": ""
} |
q27253 | marshalBinary | train | func (self *Script) marshalBinary() ([]byte, error) {
var bfr bytes.Buffer
encoder := gob.NewEncoder(&bfr)
err := encoder.Encode(self.version)
if err != nil {
return nil, err
}
err = encoder.Encode(self.program)
if err != nil {
return nil, err
}
err = encoder.Encode(self.filename)
if err != nil {
return... | go | {
"resource": ""
} |
q27254 | unmarshalBinary | train | func (self *Script) unmarshalBinary(data []byte) error {
decoder := gob.NewDecoder(bytes.NewReader(data))
err := decoder.Decode(&self.version)
if err != nil {
goto error
}
if self.version != scriptVersion {
err = ErrVersion
goto error
}
err = decoder.Decode(&self.program)
if err != nil {
goto error
}
... | go | {
"resource": ""
} |
q27255 | hasInstance | train | func (self *_object) hasInstance(of Value) bool {
if !self.isCall() {
// We should not have a hasInstance method
panic(self.runtime.panicTypeError())
}
if !of.IsObject() {
return false
}
prototype := self.get("prototype")
if !prototype.IsObject() {
panic(self.runtime.panicTypeError())
}
prototypeObject ... | go | {
"resource": ""
} |
q27256 | Argument | train | func (self FunctionCall) Argument(index int) Value {
return valueOfArrayIndex(self.ArgumentList, index)
} | go | {
"resource": ""
} |
q27257 | valueToRangeIndex | train | func valueToRangeIndex(indexValue Value, length int64, negativeIsZero bool) int64 {
index := indexValue.number().int64
if negativeIsZero {
if index < 0 {
index = 0
}
// minimum(index, length)
if index >= length {
index = length
}
return index
}
if index < 0 {
index += length
if index < 0 {
... | go | {
"resource": ""
} |
q27258 | Error | train | func (self Error) Error() string {
filename := self.Position.Filename
if filename == "" {
filename = "(anonymous)"
}
return fmt.Sprintf("%s: Line %d:%d %s",
filename,
self.Position.Line,
self.Position.Column,
self.Message,
)
} | go | {
"resource": ""
} |
q27259 | Add | train | func (self *ErrorList) Add(position file.Position, msg string) {
*self = append(*self, &Error{position, msg})
} | go | {
"resource": ""
} |
q27260 | getOwnProperty | train | func (self *_object) getOwnProperty(name string) *_property {
return self.objectClass.getOwnProperty(self, name)
} | go | {
"resource": ""
} |
q27261 | DefaultValue | train | func (self *_object) DefaultValue(hint _defaultValueHint) Value {
if hint == defaultValueNoHint {
if self.class == "Date" {
// Date exception
hint = defaultValueHintString
} else {
hint = defaultValueHintNumber
}
}
methodSequence := []string{"valueOf", "toString"}
if hint == defaultValueHintString {
... | go | {
"resource": ""
} |
q27262 | decorate | train | func decorate(call _entry, s string) string {
file, line := call.File, call.Line
if call.PC > 0 {
// Truncate file name at last file name separator.
if index := strings.LastIndex(file, "/"); index >= 0 {
file = file[index+1:]
} else if index = strings.LastIndex(file, "\\"); index >= 0 {
file = file[index... | go | {
"resource": ""
} |
q27263 | Caller | train | func Caller() *Call {
scope, entry := findScope()
if scope == nil {
return nil
}
return &Call{
scope: scope,
entry: entry,
}
} | go | {
"resource": ""
} |
q27264 | Log | train | func (cl *Call) Log(arguments ...interface{}) {
cl.scope.log(cl.entry, fmt.Sprintln(arguments...))
} | go | {
"resource": ""
} |
q27265 | Logf | train | func (cl *Call) Logf(format string, arguments ...interface{}) {
cl.scope.log(cl.entry, fmt.Sprintf(format, arguments...))
} | go | {
"resource": ""
} |
q27266 | Error | train | func (cl *Call) Error(arguments ...interface{}) {
cl.scope.log(cl.entry, fmt.Sprintln(arguments...))
cl.scope.t.Fail()
} | go | {
"resource": ""
} |
q27267 | Errorf | train | func (cl *Call) Errorf(format string, arguments ...interface{}) {
cl.scope.log(cl.entry, fmt.Sprintf(format, arguments...))
cl.scope.t.Fail()
} | go | {
"resource": ""
} |
q27268 | Skip | train | func (cl *Call) Skip(arguments ...interface{}) {
cl.scope.log(cl.entry, fmt.Sprintln(arguments...))
cl.scope.t.SkipNow()
} | go | {
"resource": ""
} |
q27269 | Skipf | train | func (cl *Call) Skipf(format string, arguments ...interface{}) {
cl.scope.log(cl.entry, fmt.Sprintf(format, arguments...))
cl.scope.t.SkipNow()
} | go | {
"resource": ""
} |
q27270 | IsFunction | train | func (value Value) IsFunction() bool {
if value.kind != valueObject {
return false
}
return value.value.(*_object).class == "Function"
} | go | {
"resource": ""
} |
q27271 | String | train | func (value Value) String() string {
result := ""
catchPanic(func() {
result = value.string()
})
return result
} | go | {
"resource": ""
} |
q27272 | Object | train | func (value Value) Object() *Object {
switch object := value.value.(type) {
case *_object:
return _newObject(object, value)
}
return nil
} | go | {
"resource": ""
} |
q27273 | DebuggerHandler | train | func DebuggerHandler(vm *otto.Otto) {
i := atomic.AddUint32(&counter, 1)
// purposefully ignoring the error here - we can't do anything useful with
// it except panicking, and that'd be pretty rude. it'd be easy enough for a
// consumer to define an equivalent function that _does_ panic if desired.
_ = RunWithPro... | go | {
"resource": ""
} |
q27274 | RunWithPrompt | train | func RunWithPrompt(vm *otto.Otto, prompt string) error {
return RunWithOptions(vm, Options{
Prompt: prompt,
})
} | go | {
"resource": ""
} |
q27275 | RunWithPrelude | train | func RunWithPrelude(vm *otto.Otto, prelude string) error {
return RunWithOptions(vm, Options{
Prelude: prelude,
})
} | go | {
"resource": ""
} |
q27276 | RunWithPromptAndPrelude | train | func RunWithPromptAndPrelude(vm *otto.Otto, prompt, prelude string) error {
return RunWithOptions(vm, Options{
Prompt: prompt,
Prelude: prelude,
})
} | go | {
"resource": ""
} |
q27277 | RunWithOptions | train | func RunWithOptions(vm *otto.Otto, options Options) error {
prompt := options.Prompt
if prompt == "" {
prompt = "> "
}
c := &readline.Config{
Prompt: prompt,
}
if options.Autocomplete {
c.AutoComplete = &autoCompleter{vm}
}
rl, err := readline.NewEx(c)
if err != nil {
return err
}
prelude := opti... | go | {
"resource": ""
} |
q27278 | isLineWhiteSpace | train | func isLineWhiteSpace(chr rune) bool {
switch chr {
case '\u0009', '\u000b', '\u000c', '\u0020', '\u00a0', '\ufeff':
return true
case '\u000a', '\u000d', '\u2028', '\u2029':
return false
case '\u0085':
return false
}
return unicode.IsSpace(chr)
} | go | {
"resource": ""
} |
q27279 | read | train | func (self *_RegExp_parser) read() {
if self.offset < self.length {
self.chrOffset = self.offset
chr, width := rune(self.str[self.offset]), 1
if chr >= utf8.RuneSelf { // !ASCII
chr, width = utf8.DecodeRuneInString(self.str[self.offset:])
if chr == utf8.RuneError && width == 1 {
self.error(self.chrOffs... | go | {
"resource": ""
} |
q27280 | objectGetOwnProperty | train | func objectGetOwnProperty(self *_object, name string) *_property {
// Return a _copy_ of the property
property, exists := self._read(name)
if !exists {
return nil
}
return &property
} | go | {
"resource": ""
} |
q27281 | ParseFunction | train | func ParseFunction(parameterList, body string) (*ast.FunctionLiteral, error) {
src := "(function(" + parameterList + ") {\n" + body + "\n})"
parser := _newParser("", src, 1, nil)
program, err := parser.parse()
if err != nil {
return nil, err
}
return program.Body[0].(*ast.ExpressionStatement).Expression.(*as... | go | {
"resource": ""
} |
q27282 | precedence | train | func (tkn Token) precedence(in bool) int {
switch tkn {
case LOGICAL_OR:
return 1
case LOGICAL_AND:
return 2
case OR, OR_ASSIGN:
return 3
case EXCLUSIVE_OR:
return 4
case AND, AND_ASSIGN, AND_NOT, AND_NOT_ASSIGN:
return 5
case EQUAL,
NOT_EQUAL,
STRICT_EQUAL,
STRICT_NOT_EQUAL:
return 6
c... | go | {
"resource": ""
} |
q27283 | NewComment | train | func NewComment(text string, idx file.Idx) *Comment {
comment := &Comment{
Begin: idx,
Text: text,
Position: TBD,
}
return comment
} | go | {
"resource": ""
} |
q27284 | String | train | func (cp CommentPosition) String() string {
switch cp {
case LEADING:
return "Leading"
case TRAILING:
return "Trailing"
case KEY:
return "Key"
case COLON:
return "Colon"
case FINAL:
return "Final"
case IF:
return "If"
case WHILE:
return "While"
case DO:
return "Do"
case FOR:
return "For"
ca... | go | {
"resource": ""
} |
q27285 | FetchAll | train | func (c *Comments) FetchAll() []*Comment {
defer func() {
c.Comments = nil
c.future = nil
}()
return append(c.Comments, c.future...)
} | go | {
"resource": ""
} |
q27286 | AddComment | train | func (c *Comments) AddComment(comment *Comment) {
if c.primary {
if !c.wasLineBreak {
c.Comments = append(c.Comments, comment)
} else {
c.future = append(c.future, comment)
}
} else {
if !c.wasLineBreak || (c.Current == nil && !c.afterBlock) {
c.Comments = append(c.Comments, comment)
} else {
c.... | go | {
"resource": ""
} |
q27287 | MarkComments | train | func (c *Comments) MarkComments(position CommentPosition) {
for _, comment := range c.Comments {
if comment.Position == TBD {
comment.Position = position
}
}
for _, c := range c.future {
if c.Position == TBD {
c.Position = position
}
}
} | go | {
"resource": ""
} |
q27288 | Unset | train | func (c *Comments) Unset() {
if c.Current != nil {
c.applyComments(c.Current, c.Current, TRAILING)
c.Current = nil
}
c.wasLineBreak = false
c.primary = false
c.afterBlock = false
} | go | {
"resource": ""
} |
q27289 | SetExpression | train | func (c *Comments) SetExpression(node Expression) {
// Skipping same node
if c.Current == node {
return
}
if c.Current != nil && c.Current.Idx1() == node.Idx1() {
c.Current = node
return
}
previous := c.Current
c.Current = node
// Apply the found comments and futures to the node and the previous.
c.appl... | go | {
"resource": ""
} |
q27290 | PostProcessNode | train | func (c *Comments) PostProcessNode(node Node) {
c.applyComments(node, nil, TRAILING)
} | go | {
"resource": ""
} |
q27291 | applyComments | train | func (c *Comments) applyComments(node, previous Node, position CommentPosition) {
if previous != nil {
c.CommentMap.AddComments(previous, c.Comments, position)
c.Comments = nil
} else {
c.CommentMap.AddComments(node, c.Comments, position)
c.Comments = nil
}
// Only apply the future comments to the node if t... | go | {
"resource": ""
} |
q27292 | AddComment | train | func (cm CommentMap) AddComment(node Node, comment *Comment) {
list := cm[node]
list = append(list, comment)
cm[node] = list
} | go | {
"resource": ""
} |
q27293 | AddComments | train | func (cm CommentMap) AddComments(node Node, comments []*Comment, position CommentPosition) {
for _, comment := range comments {
if comment.Position == TBD {
comment.Position = position
}
cm.AddComment(node, comment)
}
} | go | {
"resource": ""
} |
q27294 | Size | train | func (cm CommentMap) Size() int {
size := 0
for _, comments := range cm {
size += len(comments)
}
return size
} | go | {
"resource": ""
} |
q27295 | MoveComments | train | func (cm CommentMap) MoveComments(from, to Node, position CommentPosition) {
for i, c := range cm[from] {
if c.Position == position {
cm.AddComment(to, c)
// Remove the comment from the "from" slice
cm[from][i] = cm[from][len(cm[from])-1]
cm[from][len(cm[from])-1] = nil
cm[from] = cm[from][:len(cm[fr... | go | {
"resource": ""
} |
q27296 | New | train | func New() *Otto {
self := &Otto{
runtime: newContext(),
}
self.runtime.otto = self
self.runtime.traceLimit = 10
self.Set("console", self.runtime.newConsole())
registry.Apply(func(entry registry.Entry) {
self.Run(entry.Source())
})
return self
} | go | {
"resource": ""
} |
q27297 | Eval | train | func (self Otto) Eval(src interface{}) (Value, error) {
if self.runtime.scope == nil {
self.runtime.enterGlobalScope()
defer self.runtime.leaveScope()
}
value, err := self.runtime.cmpl_eval(src, nil)
if !value.safe() {
value = Value{}
}
return value, err
} | go | {
"resource": ""
} |
q27298 | MakeCustomError | train | func (self Otto) MakeCustomError(name, message string) Value {
return self.runtime.toValue(self.runtime.newError(name, self.runtime.toValue(message), 0))
} | go | {
"resource": ""
} |
q27299 | MakeRangeError | train | func (self Otto) MakeRangeError(message string) Value {
return self.runtime.toValue(self.runtime.newRangeError(self.runtime.toValue(message)))
} | go | {
"resource": ""
} |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.