id stringlengths 2 7 | text stringlengths 17 51.2k | title stringclasses 1
value |
|---|---|---|
c15600 |
for i := range t.Vec {
if err = binary.Read(r, binary.LittleEndian, &t.Vec[i]); err != nil {
return
}
}
return
} | |
c15601 | la.dic = d
la.udic = u
return la
} | |
c15602 | := range la.list[i] {
nodePool.Put(la.list[i][j])
}
la.list[i] = la.list[i][:0]
}
la.list = la.list[:0]
la.udic = nil
latticePool.Put(la)
} | |
c15603 | :\n", i)
for _, node := range nodes {
str += fmt.Sprintf("%v\n", node)
}
str += "\n"
}
return str
} | |
c15604 | if m != Normal {
totalCost += int64(additionalCost(n))
}
if totalCost > maximumCost {
totalCost = maximumCost
}
if j == 0 || int32(totalCost) < la.list[i][index].Cost {
la.list[i][index].Cost = int32(totalCost)
la.list[i][index].Prev = la.list[target.Start][j]
}
}
}
}
... | |
c15605 |
for _, r := range p.Surface {
n := nodePool.Get().(*node)
n.ID = p.ID
n.Start = p.Start + i
n.Class = DUMMY
n.Surface = string(r)
stack = append(stack, n)
i++
}
for j, end := 0, len(stack); j < end; j++ {
la.Output = append(la.Output, stack[runeLen-1-j])
}
}
} | |
c15606 | }
if _, ok := bests[n]; ok {
fmt.Fprintf(w, "\t\"%p\" [label=\"%s\\n%s\\n%d\",shape=ellipse, peripheries=2];\n", n, surf, pos, n.Weight)
} else if n.Class != UNKNOWN {
fmt.Fprintf(w, "\t\"%p\" [label=\"%s\\n%s\\n%d\"];\n", n, surf, pos, n.Weight)
}
}
}
for _, e := range edges {
var c int16
i... | |
c15607 | i := range t.dic.UnkContents[t.ID] {
features[i] = t.dic.UnkContents[t.ID][i]
}
return features
case lattice.USER:
pos := t.udic.Contents[t.ID].Pos
tokens := strings.Join(t.udic.Contents[t.ID].Tokens, "/")
yomi := strings.Join(t.udic.Contents[t.ID].Yomi, "/")
return []string{pos, tokens, yomi}
}
retu... | |
c15608 |
if len(f) < 1 {
return ""
}
return f[0]
} | |
c15609 | %v)%v[%v]", t.Surface, t.Start, t.End, t.Class, t.ID)
} | |
c15610 | := dic.Load(path)
return Dic{d}, err
} | |
c15611 | err := dec.Decode(&d.UnkMorphs); err != nil {
return d, fmt.Errorf("UnkMorphs: %v", err)
}
if err := dec.Decode(&d.UnkContents); err != nil {
return d, fmt.Errorf("UnkContents: %v", err)
}
return d, nil
} | |
c15612 |
if err != nil {
return err
}
}
return nil
} | |
c15613 | remove from context
c.ctx.HTTPPath = basePath
return nil
}
} | |
c15614 |
c.ctx.BuildDir = path
return nil
}
} | |
c15615 |
t = "timestamp"
}
c.cachebust = t
return nil
}
} | |
c15616 | c.ctx.Comments = b
return nil
}
} | |
c15617 | c.ctx.HTTPPath = u
return nil
}
} | |
c15618 |
c.ctx.GenImgDir = path
return nil
}
} | |
c15619 | c.ctx.ImageDir = path
return nil
}
} | |
c15620 |
c.ctx.Imports = imports
return nil
}
} | |
c15621 | c.ctx.IncludePaths = includes
return nil
}
} | |
c15622 |
c.cmt = b
return nil
}
} | |
c15623 | c.ctx.Precision = prec
return nil
}
} | |
c15624 | = path
if len(sourceMapRoot) > 0 {
c.sourceMapRoot = sourceMapRoot
}
return nil
}
} | |
c15625 | c.ctx.MainFile = path
return nil
}
} | |
c15626 |
c.ctx.Payload = load
return nil
}
} | |
c15627 |
s.m[idx] = ie
defer s.Unlock()
return idx
} | |
c15628 | }
im := Import{
bytes: bs,
mod: time.Now(),
Prev: prev,
Path: path,
}
p.m[prev+":"+path] = im
return nil
} | |
c15629 | defer p.Unlock()
delete(p.m, path)
} | |
c15630 | _, imp := range p.m {
if imp.Prev == prev && imp.Path == path {
return imp.bytes, nil
}
}
return nil, ErrImportNotFound
} | |
c15631 | {
return
}
}
entry, err := libs.GetEntry(entries, prev, url)
if err == nil {
return url, entry, true
}
return "", "", false
}
// set entries somewhere so GC doesn't collect it
p.idx = libs.BindImporter(opts, resolver)
} | |
c15632 | C.free(unsafe.Pointer(cs))
return C.sass_make_error(cs)
} | |
c15633 | C.free(unsafe.Pointer(cs))
return C.sass_make_warning(cs)
} | |
c15634 | := C.double(c.A)
return C.sass_make_color(r, g, b, a)
} | |
c15635 | return C.sass_make_list(C.size_t(len), C.SASS_COMMA, false)
} | |
c15636 | i < l; i++ {
sv := Index(usv, i)
inf := Interface(sv)
rf := reflect.ValueOf(inf)
// Special case for nil
if inf == nil {
d.Index(i).Set(reflect.ValueOf("<nil>"))
continue
}
d.Index(i).Set(rf)
}
r.Set(d)
} | |
c15637 |
//return List(usv)
case IsMap(usv):
fallthrough
//return Map(usv)
default:
return nil
}
panic("call of interface not supported on type")
} | |
c15638 | error {
return libs.ToScss(r, w)
} | |
c15639 | C.Sass_Function_Fn(C.CallSassFunction),
ptr)
return (SassFunc)(fn)
} | |
c15640 | := C.size_t(len(funcs))
cfuncs := C.sass_make_function_list(sz)
for i, cfn := range funcs {
C.sass_function_set_list_entry(cfuncs, C.size_t(i), C.Sass_Function_Entry(cfn))
}
C.sass_option_set_c_functions(opts, cfuncs)
return ids
} | |
c15641 | sign,
callback: SassHandler(fn),
})
ghMu.Unlock()
} | |
c15642 |
return comp, ErrCompilerNotFound
}
return comp, nil
} | |
c15643 | err != nil {
// Returns the error to libsass Compiler
*rsv = libs.MakeError(err.Error())
// Returning an error does nothing as libsass is in charge of
// reporting error to user
return err
}
*rsv = res.Val()
return err
}
} | |
c15644 | sign,
callback: Handler(callback),
})
ghMu.Unlock()
} | |
c15645 | req := SassValue{value: usv}
res := SassValue{value: *rsv}
err := h(v, req, &res)
if rsv != nil {
*rsv = res.Val()
}
return err
}
} | |
c15646 |
for i, h := range fs.f {
cookies[i+l] = libs.Cookie{
Sign: h.Sign,
Fn: h.Fn,
Ctx: fs.ctx,
}
}
fs.idx = libs.BindFuncs(goopts, cookies)
} | |
c15647 | incs)
libs.SassOptionSetPrecision(goopts, ctx.Precision)
libs.SassOptionSetOutputStyle(goopts, ctx.OutputStyle)
libs.SassOptionSetSourceComments(goopts, ctx.Comments)
if ctx.includeMap {
libs.SassOptionSetSourceMapEmbed(goopts, true)
}
return goopts
} | |
c15648 | goout)
ctx.Status = libs.SassContextGetErrorStatus(goctx)
errJSON := libs.SassContextGetErrorJSON(goctx)
err = ctx.ProcessSassError([]byte(errJSON))
if err != nil {
return err
}
if ctx.Error() != "" {
lines := bytes.Split(bs, []byte("\n"))
var out string
for i := -7; i < 7; i++ {
if i+ctx.err.Line >... | |
c15649 | return filepath.ToSlash(filepath.Clean(rel))
} | |
c15650 | SassValue{value: libs.MakeError(err.Error())}
} | |
c15651 |
// ck := *(*Cookie)(ptr)
var usv UnionSassValue
err := ck.Fn(ck.Ctx, cargs, &usv)
_ = err
return usv
} | |
c15652 | C.Sass_Importer_Fn(C.SassHeaders),
czero,
unsafe.Pointer(uintptr(idx)),
)
impers := C.sass_make_importer_list(1)
C.sass_importer_set_list_entry(impers, 0, imper)
C.sass_option_set_c_headers(
(*C.struct_Sass_Options)(unsafe.Pointer(opts)),
impers)
return idx
} | |
c15653 | return SassNumber{Value: sn1Value + sn2Value, Unit: sn.Unit}
} | |
c15654 |
// SASS2SCSS_PRETTIFY_1 Egyptian brackets
C.int(1),
)
_, err := io.WriteString(w, C.GoString(chars))
return err
} | |
c15655 | != reflect.Slice &&
l == 1 { //arg is a slice of 1 but we want back a non slice
val := libs.Index(sv, 0)
return unmarshal(SassValue{value: val}, v[0])
} else if libs.IsList(sv) &&
getKind(v[0]) == reflect.Slice &&
libs.IsList(libs.Index(sv, 0)) &&
l == 1 { //arg is a list of single list and we only want b... | |
c15656 | nil
} else {
err = errors.New(fmt.Sprintf("The struct type %s is unsupported for marshalling", reflect.TypeOf(v).String()))
return SassValue{value: libs.MakeNil()}, err
}
case reflect.Slice:
// Initialize the list
lst := libs.MakeList(f.Len())
for i := 0; i < f.Len(); i++ {
t, er := makevalue(f.Ind... | |
c15657 | C.sass_make_importer_list(l)
return (SassImporterList)(cimp)
} | |
c15658 |
cent := (C.Sass_Import_Entry)(ent)
golist[0] = cent
return list
}
}
if strings.HasPrefix(rel, "compass") {
ent := C.sass_make_import_entry(url, C.CString(""), nil)
cent := (C.Sass_Import_Entry)(ent)
golist[0] = cent
} else {
ent := C.sass_make_import_entry(url, nil, nil)
cent := (C.Sass_Impor... | |
c15659 | C.sass_make_file_context(s)
return (SassFileContext)(fctx)
} | |
c15660 | C.sass_make_data_context(s)
return (SassDataContext)(dctx)
} | |
c15661 | C.sass_data_context_get_context(godc)
return (SassContext)(opts)
} | |
c15662 | C.sass_file_context_get_context(gofc)
return (SassContext)(opts)
} | |
c15663 | C.sass_file_context_get_options(gofc)
return (SassOptions)(fcopts)
} | |
c15664 | C.sass_data_context_get_options(godc)
return (SassOptions)(dcopts)
} | |
c15665 | C.sass_make_file_compiler(gofc)
return (SassCompiler)(sc)
} | |
c15666 | C.sass_make_data_compiler(godc)
return (SassCompiler)(dc)
} | |
c15667 | := C.sass_compile_file_context(gofc)
return int(cstatus)
} | |
c15668 | C.sass_option_set_c_headers(gofc, C.Sass_Importer_List(goimp))
} | |
c15669 | C.sass_context_get_output_string(goctx)
defer C.free(unsafe.Pointer(cstr))
return C.GoString(cstr)
} | |
c15670 | C.free(unsafe.Pointer(cstr))
return C.GoString(cstr)
} | |
c15671 | C.sass_option_get_source_map_file(goopts)
return C.GoString(p)
} | |
c15672 | C.sass_context_get_source_map_string(goctx)
return C.GoString(s)
} | |
c15673 | C.sass_option_set_precision(goopts, C.int(i))
} | |
c15674 | C.sass_option_set_source_comments(goopts, C.bool(b))
} | |
c15675 | C.sass_option_set_output_path(goopts, C.CString(path))
} | |
c15676 | C.sass_option_set_input_path(goopts, C.CString(path))
} | |
c15677 | C.sass_option_set_include_path(goopts, C.CString(path))
} | |
c15678 |
impent := C.sass_make_import(C.CString(path), C.CString(base),
C.CString(source), C.CString(srcmap))
return (SassImportEntry)(impent)
} | |
c15679 | manually
lst := C.sass_make_importer(C.Sass_Importer_Fn(fn), C.double(priority), unsafe.Pointer(vv.Addr().Pointer()))
return (SassImporter)(lst), nil
} | |
c15680 | C.sass_importer_set_list_entry(C.Sass_Importer_List(golst), C.size_t(idx), C.Sass_Importer_Entry(ent))
} | |
c15681 | impers := C.sass_make_importer_list(1)
C.sass_importer_set_list_entry(impers, 0, imper)
C.sass_option_set_c_importers(
(*C.struct_Sass_Options)(unsafe.Pointer(opts)),
impers,
)
return idx
} | |
c15682 |
ctx.errorString = fmt.Sprintf("Error > %s:%d\n%s",
errors.File, errors.Line, errors.Message)
return nil
} | |
c15683 | f := &countSelectFunction{}
functors = append(functors, f)
}
}
if len(functors) == 0 {
f := &defaultSelectFunction{}
functors = append(functors, f)
}
return functors, nil
} | |
c15684 | := range predicates {
if res, err = predicate.Eval(row); err != nil {
return err
}
if res == false {
return nil
}
}
for i := range functors {
err := functors[i].FeedVirtualRow(row)
if err != nil {
return err
}
}
return nil
} | |
c15685 | tables[0].name + "." + attr.Decl[0].Lexeme
}
// if second subdecl is present, it's either asc or desc
// default is asc anyway
if len(attr.Decl) == 2 && attr.Decl[1].Token == parser.AscToken {
f.asc = true
}
log.Debug("orderbyExecutor> you must order by '%s', asc: %v\n", f.orderby, f.asc)
return f, nil
} | |
c15686 | log.Debug("%s|-> %s\n", indent, d.Lexeme)
for _, subD := range d.Decl {
subD.Stringy(depth + 1)
}
} | |
c15687 | t.Token,
Lexeme: t.Lexeme,
}
} | |
c15688 | append(d.Decl, subDecl)
} | |
c15689 | != nil {
return nil, err
}
d.Add(attr)
// Bracket
_, err = p.consumeToken(BracketClosingToken)
if err != nil {
return nil, err
}
}
return d, nil
} | |
c15690 | := NewDecl(p.cur())
if quoted {
// Check there is a closing quote
if _, err := p.mustHaveNext(quoteToken); err != nil {
return nil, err
}
}
p.next()
return decl, nil
} | |
c15691 |
// EQUAL
equalAttr, err := p.consumeToken(EqualityToken)
if err != nil {
return nil, err
}
onDecl.Add(equalAttr)
//ATTRIBUTE
rightAttributeDecl, err := p.parseAttribute()
if err != nil {
return nil, err
}
onDecl.Add(rightAttributeDecl)
return joinDecl, nil
} | |
c15692 | parser.ExistsToken: existsExecutor,
parser.TruncateToken: truncateExecutor,
parser.DropToken: dropExecutor,
parser.GrantToken: grantExecutor,
}
e.relations = make(map[string]*Relation)
err = e.start()
if err != nil {
return nil, err
}
return
} | |
c15693 | {
e.stop <- true
close(e.stop)
e.stop = nil
}()
} | |
c15694 | 0, r.err
}
return r.lastInsertedID, nil
} | |
c15695 | 0, r.err
}
return r.rowsAffected, nil
} | |
c15696 |
t.Values = append(t.Values, v)
}
return t
} | |
c15697 | append(t.Values, value)
} | |
c15698 | err != nil {
return err
}
}
// for each row in t1
for i := range t1.rows {
// create virtualrow
row := make(virtualRow)
for index := range t1.rows[i].Values {
v := Value{
v: t1.rows[i].Values[index],
valid: true,
lexeme: t1.table.attributes[index].name,
table: t1Name,
}
r... | |
c15699 | r.rows[i].Values {
v := Value{
v: r.rows[i].Values[index],
valid: true,
lexeme: r.table.attributes[index].name,
table: r.table.name,
}
row[v.table+"."+v.lexeme] = v
}
// if last predicate
if last {
err = selectRows(row, selectPredicates, functors)
} else {
err = join(row,... |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.