_id stringlengths 2 7 | title stringlengths 1 118 | partition stringclasses 3 values | text stringlengths 52 85.5k | language stringclasses 1 value | meta_information dict |
|---|---|---|---|---|---|
q15600 | LoadConnectionTable | train | func LoadConnectionTable(r io.Reader) (t ConnectionTable, err error) {
if err = binary.Read(r, binary.LittleEndian, &t.Row); err != nil {
return
}
if err = binary.Read(r, binary.LittleEndian, &t.Col); err != nil {
return
}
t.Vec = make([]int16, t.Row*t.Col)
for i := range t.Vec {
if err = binary.Read(r, binary.LittleEndian, &t.Vec[i]); err != nil {
return
}
}
return
} | go | {
"resource": ""
} |
q15601 | New | train | func New(d *dic.Dic, u *dic.UserDic) *Lattice {
la := latticePool.Get().(*Lattice)
la.dic = d
la.udic = u
return la
} | go | {
"resource": ""
} |
q15602 | Free | train | func (la *Lattice) Free() {
la.Input = ""
la.Output = la.Output[:0]
for i := range la.list {
for j := 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)
} | go | {
"resource": ""
} |
q15603 | String | train | func (la *Lattice) String() string {
str := ""
for i, nodes := range la.list {
str += fmt.Sprintf("[%v] :\n", i)
for _, node := range nodes {
str += fmt.Sprintf("%v\n", node)
}
str += "\n"
}
return str
} | go | {
"resource": ""
} |
q15604 | Forward | train | func (la *Lattice) Forward(m TokenizeMode) {
for i, size := 1, len(la.list); i < size; i++ {
currentList := la.list[i]
for index, target := range currentList {
prevList := la.list[target.Start]
if len(prevList) == 0 {
la.list[i][index].Cost = maximumCost
continue
}
for j, n := range prevList {
var c int16
if n.Class != USER && target.Class != USER {
c = la.dic.Connection.At(int(n.Right), int(target.Left))
}
totalCost := int64(c) + int64(target.Weight) + int64(n.Cost)
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]
}
}
}
}
return
} | go | {
"resource": ""
} |
q15605 | Backward | train | func (la *Lattice) Backward(m TokenizeMode) {
const bufferExpandRatio = 2
size := len(la.list)
if size == 0 {
return
}
if cap(la.Output) < size {
la.Output = make([]*node, 0, size*bufferExpandRatio)
} else {
la.Output = la.Output[:0]
}
for p := la.list[size-1][0]; p != nil; p = p.Prev {
if m != Extended || p.Class != UNKNOWN {
la.Output = append(la.Output, p)
continue
}
runeLen := utf8.RuneCountInString(p.Surface)
stack := make([]*node, 0, runeLen)
i := 0
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])
}
}
} | go | {
"resource": ""
} |
q15606 | Dot | train | func (la *Lattice) Dot(w io.Writer) {
bests := make(map[*node]struct{})
for _, n := range la.Output {
bests[n] = struct{}{}
}
type edge struct {
from *node
to *node
}
edges := make([]edge, 0, 1024)
for i, size := 1, len(la.list); i < size; i++ {
currents := la.list[i]
for _, to := range currents {
if to.Class == UNKNOWN {
if _, ok := bests[to]; !ok {
continue
}
}
prevs := la.list[to.Start]
if len(prevs) == 0 {
continue
}
for _, from := range prevs {
if from.Class == UNKNOWN {
if _, ok := bests[from]; !ok {
continue
}
}
edges = append(edges, edge{from, to})
}
}
}
fmt.Fprintln(w, "graph lattice {")
fmt.Fprintln(w, "dpi=48;")
fmt.Fprintln(w, "graph [style=filled, splines=true, overlap=false, fontsize=30, rankdir=LR]")
fmt.Fprintln(w, "edge [fontname=Helvetica, fontcolor=red, color=\"#606060\"]")
fmt.Fprintln(w, "node [shape=box, style=filled, fillcolor=\"#e8e8f0\", fontname=Helvetica]")
for i, list := range la.list {
for _, n := range list {
if n.Class == UNKNOWN {
if _, ok := bests[n]; !ok {
continue
}
}
surf := n.Surface
if n.ID == BosEosID {
if i == 0 {
surf = "BOS"
} else {
surf = "EOS"
}
}
features := features(la.dic, la.udic, n)
pos := "---"
if len(features) > 1 {
pos = features[0]
}
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
if e.from.Class != USER && e.to.Class != USER {
c = la.dic.Connection.At(int(e.from.Right), int(e.to.Left))
}
_, l := bests[e.from]
_, r := bests[e.to]
if l && r {
fmt.Fprintf(w, "\t\"%p\" -- \"%p\" [label=\"%d\", style=bold, color=blue, fontcolor=blue];\n",
e.from, e.to, c)
} else {
fmt.Fprintf(w, "\t\"%p\" -- \"%p\" [label=\"%d\"];\n",
e.from, e.to, c)
}
}
fmt.Fprintln(w, "}")
} | go | {
"resource": ""
} |
q15607 | Features | train | func (t Token) Features() []string {
switch lattice.NodeClass(t.Class) {
case lattice.DUMMY:
return nil
case lattice.KNOWN:
var c int
if t.dic.Contents != nil {
c = len(t.dic.Contents[t.ID])
}
features := make([]string, 0, len(t.dic.POSTable.POSs[t.ID])+c)
for _, id := range t.dic.POSTable.POSs[t.ID] {
features = append(features, t.dic.POSTable.NameList[id])
}
if t.dic.Contents != nil {
features = append(features, t.dic.Contents[t.ID]...)
}
return features
case lattice.UNKNOWN:
features := make([]string, len(t.dic.UnkContents[t.ID]))
for 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}
}
return nil
} | go | {
"resource": ""
} |
q15608 | Pos | train | func (t Token) Pos() string {
f := t.Features()
if len(f) < 1 {
return ""
}
return f[0]
} | go | {
"resource": ""
} |
q15609 | String | train | func (t Token) String() string {
return fmt.Sprintf("%v(%v, %v)%v[%v]", t.Surface, t.Start, t.End, t.Class, t.ID)
} | go | {
"resource": ""
} |
q15610 | NewDic | train | func NewDic(path string) (Dic, error) {
d, err := dic.Load(path)
return Dic{d}, err
} | go | {
"resource": ""
} |
q15611 | ReadUnkDic | train | func ReadUnkDic(r io.Reader) (UnkDic, error) {
d := UnkDic{}
ui, err := readMap(r)
if err != nil {
return d, fmt.Errorf("UnkIndex: %v", err)
}
d.UnkIndex = ui
ud, err := readMap(r)
if err != nil {
return d, fmt.Errorf("UnkIndexDup: %v", err)
}
d.UnkIndexDup = ud
dec := gob.NewDecoder(r)
if 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
} | go | {
"resource": ""
} |
q15612 | Option | train | func (c *sass) Option(opts ...option) error {
for _, opt := range opts {
err := opt(c)
if err != nil {
return err
}
}
return nil
} | go | {
"resource": ""
} |
q15613 | BasePath | train | func BasePath(basePath string) option {
return func(c *sass) error {
c.httpPath = basePath
// FIXME: remove from context
c.ctx.HTTPPath = basePath
return nil
}
} | go | {
"resource": ""
} |
q15614 | BuildDir | train | func BuildDir(path string) option {
return func(c *sass) error {
c.ctx.BuildDir = path
return nil
}
} | go | {
"resource": ""
} |
q15615 | CacheBust | train | func CacheBust(t string) option {
return func(c *sass) error {
if t == "ts" {
t = "timestamp"
}
c.cachebust = t
return nil
}
} | go | {
"resource": ""
} |
q15616 | Comments | train | func Comments(b bool) option {
return func(c *sass) error {
c.ctx.Comments = b
return nil
}
} | go | {
"resource": ""
} |
q15617 | HTTPPath | train | func HTTPPath(u string) option {
return func(c *sass) error {
c.httpPath = u
c.ctx.HTTPPath = u
return nil
}
} | go | {
"resource": ""
} |
q15618 | ImgBuildDir | train | func ImgBuildDir(path string) option {
return func(c *sass) error {
c.ctx.GenImgDir = path
return nil
}
} | go | {
"resource": ""
} |
q15619 | ImgDir | train | func ImgDir(path string) option {
return func(c *sass) error {
c.ctx.ImageDir = path
return nil
}
} | go | {
"resource": ""
} |
q15620 | ImportsOption | train | func ImportsOption(imports *Imports) option {
return func(c *sass) error {
c.ctx.Imports = imports
return nil
}
} | go | {
"resource": ""
} |
q15621 | IncludePaths | train | func IncludePaths(includes []string) option {
return func(c *sass) error {
c.includePaths = includes
c.ctx.IncludePaths = includes
return nil
}
} | go | {
"resource": ""
} |
q15622 | LineComments | train | func LineComments(b bool) option {
return func(c *sass) error {
c.cmt = b
return nil
}
} | go | {
"resource": ""
} |
q15623 | Precision | train | func Precision(prec int) option {
return func(c *sass) error {
c.ctx.Precision = prec
return nil
}
} | go | {
"resource": ""
} |
q15624 | SourceMap | train | func SourceMap(b bool, path, sourceMapRoot string) option {
return func(c *sass) error {
c.ctx.includeMap = b
c.mappath = path
if len(sourceMapRoot) > 0 {
c.sourceMapRoot = sourceMapRoot
}
return nil
}
} | go | {
"resource": ""
} |
q15625 | Path | train | func Path(path string) option {
return func(c *sass) error {
c.srcFile = path
c.ctx.MainFile = path
return nil
}
} | go | {
"resource": ""
} |
q15626 | Payload | train | func Payload(load context.Context) option {
return func(c *sass) error {
c.ctx.Payload = load
return nil
}
} | go | {
"resource": ""
} |
q15627 | Set | train | func (s *SafeMap) Set(ie interface{}) int {
idx := s.nextidx()
s.Lock()
s.m[idx] = ie
defer s.Unlock()
return idx
} | go | {
"resource": ""
} |
q15628 | Add | train | func (p *Imports) Add(prev string, path string, bs []byte) error {
p.Lock()
defer p.Unlock()
// TODO: align these with libsass name "stdin"
if len(prev) == 0 || prev == "string" {
prev = "stdin"
}
im := Import{
bytes: bs,
mod: time.Now(),
Prev: prev,
Path: path,
}
p.m[prev+":"+path] = im
return nil
} | go | {
"resource": ""
} |
q15629 | Del | train | func (p *Imports) Del(path string) {
p.Lock()
defer p.Unlock()
delete(p.m, path)
} | go | {
"resource": ""
} |
q15630 | Get | train | func (p *Imports) Get(prev, path string) ([]byte, error) {
p.RLock()
defer p.RUnlock()
for _, imp := range p.m {
if imp.Prev == prev && imp.Path == path {
return imp.bytes, nil
}
}
return nil, ErrImportNotFound
} | go | {
"resource": ""
} |
q15631 | Bind | train | func (p *Imports) Bind(opts libs.SassOptions) {
entries := make([]libs.ImportEntry, p.Len())
i := 0
p.RLock()
for _, ent := range p.m {
bs := ent.bytes
entries[i] = libs.ImportEntry{
Parent: ent.Prev,
Path: ent.Path,
Source: string(bs),
}
i++
}
p.RUnlock()
resolver := func(url string, prev string) (newURL string, body string, resolved bool) {
if p.resolver != nil {
newURL, body, resolved = p.resolver(url, prev)
if resolved {
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)
} | go | {
"resource": ""
} |
q15632 | MakeError | train | func MakeError(s string) UnionSassValue {
cs := C.CString(s)
defer C.free(unsafe.Pointer(cs))
return C.sass_make_error(cs)
} | go | {
"resource": ""
} |
q15633 | MakeWarning | train | func MakeWarning(s string) UnionSassValue {
cs := C.CString(s)
defer C.free(unsafe.Pointer(cs))
return C.sass_make_warning(cs)
} | go | {
"resource": ""
} |
q15634 | MakeColor | train | func MakeColor(c color.RGBA) UnionSassValue {
r := C.double(c.R)
g := C.double(c.G)
b := C.double(c.B)
a := C.double(c.A)
return C.sass_make_color(r, g, b, a)
} | go | {
"resource": ""
} |
q15635 | MakeList | train | func MakeList(len int) UnionSassValue {
return C.sass_make_list(C.size_t(len), C.SASS_COMMA, false)
} | go | {
"resource": ""
} |
q15636 | Slice | train | func Slice(usv UnionSassValue, inf interface{}) {
if !IsList(usv) {
panic("sass value is not a list")
}
l := Len(usv)
r := reflect.ValueOf(inf)
if r.Kind() == reflect.Ptr {
r = r.Elem()
}
if !r.CanSet() {
panic("value is not addressable")
}
// if a non-slice is passed, make a slice
t := r.Type()
if r.Kind() != reflect.Slice {
t = reflect.SliceOf(t)
}
d := reflect.MakeSlice(t, l, l)
for i := 0; 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)
} | go | {
"resource": ""
} |
q15637 | Interface | train | func Interface(usv UnionSassValue) interface{} {
switch {
case IsNil(usv):
return nil
case IsBool(usv):
return Bool(usv)
case IsString(usv):
return String(usv)
case IsColor(usv):
return Color(usv)
case IsNumber(usv):
return Number(usv)
case IsList(usv):
fallthrough
//return List(usv)
case IsMap(usv):
fallthrough
//return Map(usv)
default:
return nil
}
panic("call of interface not supported on type")
} | go | {
"resource": ""
} |
q15638 | ToScss | train | func ToScss(r io.Reader, w io.Writer) error {
return libs.ToScss(r, w)
} | go | {
"resource": ""
} |
q15639 | SassMakeFunction | train | func SassMakeFunction(signature string, idx int) SassFunc {
csign := C.CString(signature)
ptr := unsafe.Pointer(uintptr(idx))
fn := C.sass_make_function(
csign,
C.Sass_Function_Fn(C.CallSassFunction),
ptr)
return (SassFunc)(fn)
} | go | {
"resource": ""
} |
q15640 | BindFuncs | train | func BindFuncs(opts SassOptions, cookies []Cookie) []int {
funcs := make([]SassFunc, len(cookies))
ids := make([]int, len(cookies))
for i, cookie := range cookies {
idx := globalFuncs.Set(cookies[i])
fn := SassMakeFunction(cookie.Sign, idx)
funcs[i] = fn
ids[i] = idx
}
sz := 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
} | go | {
"resource": ""
} |
q15641 | RegisterSassFunc | train | func RegisterSassFunc(sign string, fn SassFunc) {
ghMu.Lock()
globalHandlers = append(globalHandlers, handler{
sign: sign,
callback: SassHandler(fn),
})
ghMu.Unlock()
} | go | {
"resource": ""
} |
q15642 | CompFromCtx | train | func CompFromCtx(ctx context.Context) (Compiler, error) {
v := ctx.Value(compkey)
comp, ok := v.(Compiler)
if !ok {
return comp, ErrCompilerNotFound
}
return comp, nil
} | go | {
"resource": ""
} |
q15643 | SassHandler | train | func SassHandler(h SassFunc) libs.SassCallback {
return func(v interface{}, usv libs.UnionSassValue, rsv *libs.UnionSassValue) error {
if *rsv == nil {
*rsv = libs.MakeNil()
}
libCtx, ok := v.(*compctx)
if !ok {
return errors.New("libsass Context not found")
}
ctx := NewCompilerContext(libCtx.compiler)
// Cast to exported Go types
req := SassValue{value: usv}
res, err := h(ctx, req)
if 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
}
} | go | {
"resource": ""
} |
q15644 | RegisterHandler | train | func RegisterHandler(sign string, callback HandlerFunc) {
ghMu.Lock()
globalHandlers = append(globalHandlers, handler{
sign: sign,
callback: Handler(callback),
})
ghMu.Unlock()
} | go | {
"resource": ""
} |
q15645 | Handler | train | func Handler(h HandlerFunc) libs.SassCallback {
return func(v interface{}, usv libs.UnionSassValue, rsv *libs.UnionSassValue) error {
if *rsv == nil {
*rsv = libs.MakeNil()
}
req := SassValue{value: usv}
res := SassValue{value: *rsv}
err := h(v, req, &res)
if rsv != nil {
*rsv = res.Val()
}
return err
}
} | go | {
"resource": ""
} |
q15646 | Bind | train | func (fs *Funcs) Bind(goopts libs.SassOptions) {
ghMu.RLock()
cookies := make([]libs.Cookie, len(globalHandlers)+len(fs.f))
// Append registered handlers to cookie array
for i, h := range globalHandlers {
cookies[i] = libs.Cookie{
Sign: h.sign,
Fn: h.callback,
Ctx: fs.ctx,
}
}
l := len(globalHandlers)
ghMu.RUnlock()
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)
} | go | {
"resource": ""
} |
q15647 | Init | train | func (ctx *compctx) Init(goopts libs.SassOptions) libs.SassOptions {
if ctx.Precision == 0 {
ctx.Precision = 5
}
ctx.options = goopts
ctx.Headers.Bind(goopts)
ctx.Imports.Bind(goopts)
ctx.Funcs.Bind(goopts)
libs.SassOptionSetSourceComments(goopts, ctx.compiler.LineComments())
//os.PathListSeparator
incs := strings.Join(ctx.IncludePaths, string(os.PathListSeparator))
libs.SassOptionSetIncludePath(goopts, 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
} | go | {
"resource": ""
} |
q15648 | compile | train | func (ctx *compctx) compile(out io.Writer, in io.Reader) error {
defer ctx.Reset()
var (
bs []byte
err error
)
// libSass will fail on Sass syntax given as non-file input
// convert the input on its behalf
if ctx.compiler.Syntax() == SassSyntax {
// this is memory intensive
var buf bytes.Buffer
err := ToScss(in, &buf)
if err != nil {
return err
}
bs = buf.Bytes()
} else {
// ScssSyntax
bs, err = ioutil.ReadAll(in)
if err != nil {
return err
}
}
if len(bs) == 0 {
return errors.New("No input provided")
}
godc := libs.SassMakeDataContext(string(bs))
goopts := libs.SassDataContextGetOptions(godc)
libs.SassOptionSetSourceComments(goopts, true)
ctx.Init(goopts)
libs.SassDataContextSetOptions(godc, goopts)
goctx := libs.SassDataContextGetContext(godc)
ctx.context = goctx
gocompiler := libs.SassMakeDataCompiler(godc)
libs.SassCompilerParse(gocompiler)
libs.SassCompilerExecute(gocompiler)
defer libs.SassDeleteCompiler(gocompiler)
goout := libs.SassContextGetOutputString(goctx)
io.WriteString(out, 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 >= 0 && i+ctx.err.Line < len(lines) {
out += fmt.Sprintf("%s\n", string(lines[i+ctx.err.Line]))
}
}
// TODO: this is weird, make something more idiomatic
return errors.New(ctx.Error() + "\n" + out)
}
return nil
} | go | {
"resource": ""
} |
q15649 | RelativeImage | train | func (p *compctx) RelativeImage() string {
rel, _ := filepath.Rel(p.BuildDir, p.ImageDir)
return filepath.ToSlash(filepath.Clean(rel))
} | go | {
"resource": ""
} |
q15650 | Error | train | func Error(err error) SassValue {
return SassValue{value: libs.MakeError(err.Error())}
} | go | {
"resource": ""
} |
q15651 | GoBridge | train | func GoBridge(cargs UnionSassValue, cidx C.int) UnionSassValue {
// Recover the Cookie struct passed in
idx := int(cidx)
ck, ok := globalFuncs.Get(idx).(Cookie)
if !ok {
fmt.Printf("failed to resolve Cookie %d\n", idx)
return MakeNil()
}
// ck := *(*Cookie)(ptr)
var usv UnionSassValue
err := ck.Fn(ck.Ctx, cargs, &usv)
_ = err
return usv
} | go | {
"resource": ""
} |
q15652 | BindHeader | train | func BindHeader(opts SassOptions, entries []ImportEntry) int {
idx := globalHeaders.Set(entries)
// ptr := unsafe.Pointer(idx)
czero := C.double(0)
imper := C.sass_make_importer(
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
} | go | {
"resource": ""
} |
q15653 | Add | train | func (sn SassNumber) Add(sn2 SassNumber) SassNumber {
sn1Value, sn2Value := getConvertedUnits(sn, sn2)
return SassNumber{Value: sn1Value + sn2Value, Unit: sn.Unit}
} | go | {
"resource": ""
} |
q15654 | ToScss | train | func ToScss(r io.Reader, w io.Writer) error {
bs, _ := ioutil.ReadAll(r)
in := C.CString(string(bs))
defer C.free(unsafe.Pointer(in))
chars := C.sass2scss(
// FIXME: readers would be much more efficient
in,
// SASS2SCSS_PRETTIFY_1 Egyptian brackets
C.int(1),
)
_, err := io.WriteString(w, C.GoString(chars))
return err
} | go | {
"resource": ""
} |
q15655 | Unmarshal | train | func Unmarshal(arg SassValue, v ...interface{}) error {
var err error
sv := arg.Val()
var l int
if libs.IsList(sv) {
l = libs.Len(sv)
}
if arg.Val() == nil {
return errors.New("I can't work with this. arg UnionSassValue must not be nil. - Unmarshaller")
} else if len(v) == 0 {
return errors.New("Cannot Unmarshal an empty value - Michael Scott")
} else if len(v) > 1 {
if len(v) < l { //check for optional arguements that are not passed and pad with nil
return fmt.Errorf(
"Arguments mismatch %d C arguments did not match %d",
l, len(v))
}
for i := 0; i < l; i++ {
val := libs.Index(sv, i)
err = unmarshal(SassValue{value: val}, v[i])
if err != nil {
return err
}
}
return err
} else if libs.IsList(sv) &&
getKind(v[0]) != 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 back a list so we need to unwrap
val := libs.Index(sv, 0)
return unmarshal(SassValue{value: val}, v[0])
//return unmarshal(C.sass_list_get_value(arg, C.size_t(0)), v[0])
} else {
return unmarshal(arg, v[0])
}
} | go | {
"resource": ""
} |
q15656 | makevalue | train | func makevalue(v interface{}) (SassValue, error) {
f := reflect.ValueOf(v)
var err error
switch f.Kind() {
default:
return SassValue{value: libs.MakeNil()}, nil
case reflect.Bool:
b := v.(bool)
return SassValue{value: libs.MakeBool(b)}, nil
case reflect.String:
s := v.(string)
return SassValue{value: libs.MakeString(s)}, nil
case reflect.Struct: //only SassNumber and color.RGBA are supported
if sn, ok := v.(libs.SassNumber); ok {
return SassValue{
value: libs.MakeNumber(sn.Float(), sn.UnitOf()),
}, err
} else if sc, ok := v.(color.RGBA); ok {
return SassValue{value: libs.MakeColor(sc)}, 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.Index(i).Interface())
if err == nil && er != nil {
err = er
}
libs.SetIndex(lst, i, t.Val())
}
return SassValue{value: lst}, err
}
} | go | {
"resource": ""
} |
q15657 | SassMakeImporterList | train | func SassMakeImporterList(gol int) SassImporterList {
l := C.size_t(gol)
cimp := C.sass_make_importer_list(l)
return (SassImporterList)(cimp)
} | go | {
"resource": ""
} |
q15658 | ImporterBridge | train | func ImporterBridge(url *C.char, prev *C.char, cidx C.uintptr_t) C.Sass_Import_List {
var importResolver ImportResolver
// Retrieve the index
idx := int(cidx)
importResolver, ok := globalImports.Get(idx).(ImportResolver)
if !ok {
fmt.Printf("failed to resolve import handler: %d\n", idx)
}
parent := C.GoString(prev)
rel := C.GoString(url)
list := C.sass_make_import_list(1)
hdr := reflect.SliceHeader{
Data: uintptr(unsafe.Pointer(list)),
Len: 1, Cap: 1,
}
golist := *(*[]C.Sass_Import_Entry)(unsafe.Pointer(&hdr))
if importResolver != nil {
newURL, body, resolved := importResolver(rel, parent)
if resolved {
// Passing a nil as body is a signal to load the import from the URL.
var bodyv *C.char
if body != "" {
bodyv = C.CString(body)
}
ent := C.sass_make_import_entry(C.CString(newURL), bodyv, nil)
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_Import_Entry)(ent)
golist[0] = cent
}
return list
} | go | {
"resource": ""
} |
q15659 | SassMakeFileContext | train | func SassMakeFileContext(gos string) SassFileContext {
s := C.CString(gos)
fctx := C.sass_make_file_context(s)
return (SassFileContext)(fctx)
} | go | {
"resource": ""
} |
q15660 | SassMakeDataContext | train | func SassMakeDataContext(gos string) SassDataContext {
s := C.CString(gos)
dctx := C.sass_make_data_context(s)
return (SassDataContext)(dctx)
} | go | {
"resource": ""
} |
q15661 | SassDataContextGetContext | train | func SassDataContextGetContext(godc SassDataContext) SassContext {
opts := C.sass_data_context_get_context(godc)
return (SassContext)(opts)
} | go | {
"resource": ""
} |
q15662 | SassFileContextGetContext | train | func SassFileContextGetContext(gofc SassFileContext) SassContext {
opts := C.sass_file_context_get_context(gofc)
return (SassContext)(opts)
} | go | {
"resource": ""
} |
q15663 | SassFileContextGetOptions | train | func SassFileContextGetOptions(gofc SassFileContext) SassOptions {
fcopts := C.sass_file_context_get_options(gofc)
return (SassOptions)(fcopts)
} | go | {
"resource": ""
} |
q15664 | SassDataContextGetOptions | train | func SassDataContextGetOptions(godc SassDataContext) SassOptions {
dcopts := C.sass_data_context_get_options(godc)
return (SassOptions)(dcopts)
} | go | {
"resource": ""
} |
q15665 | SassMakeFileCompiler | train | func SassMakeFileCompiler(gofc SassFileContext) SassCompiler {
sc := C.sass_make_file_compiler(gofc)
return (SassCompiler)(sc)
} | go | {
"resource": ""
} |
q15666 | SassMakeDataCompiler | train | func SassMakeDataCompiler(godc SassDataContext) SassCompiler {
dc := C.sass_make_data_compiler(godc)
return (SassCompiler)(dc)
} | go | {
"resource": ""
} |
q15667 | SassCompileFileContext | train | func SassCompileFileContext(gofc SassFileContext) int {
cstatus := C.sass_compile_file_context(gofc)
return int(cstatus)
} | go | {
"resource": ""
} |
q15668 | SassOptionSetCHeaders | train | func SassOptionSetCHeaders(gofc SassOptions, goimp SassImporterList) {
C.sass_option_set_c_headers(gofc, C.Sass_Importer_List(goimp))
} | go | {
"resource": ""
} |
q15669 | SassContextGetOutputString | train | func SassContextGetOutputString(goctx SassContext) string {
cstr := C.sass_context_get_output_string(goctx)
defer C.free(unsafe.Pointer(cstr))
return C.GoString(cstr)
} | go | {
"resource": ""
} |
q15670 | SassContextGetErrorJSON | train | func SassContextGetErrorJSON(goctx SassContext) string {
cstr := C.sass_context_get_error_json(goctx)
defer C.free(unsafe.Pointer(cstr))
return C.GoString(cstr)
} | go | {
"resource": ""
} |
q15671 | SassOptionGetSourceMapFile | train | func SassOptionGetSourceMapFile(goopts SassOptions) string {
p := C.sass_option_get_source_map_file(goopts)
return C.GoString(p)
} | go | {
"resource": ""
} |
q15672 | SassContextGetSourceMapString | train | func SassContextGetSourceMapString(goctx SassContext) string {
s := C.sass_context_get_source_map_string(goctx)
return C.GoString(s)
} | go | {
"resource": ""
} |
q15673 | SassOptionSetPrecision | train | func SassOptionSetPrecision(goopts SassOptions, i int) {
C.sass_option_set_precision(goopts, C.int(i))
} | go | {
"resource": ""
} |
q15674 | SassOptionSetSourceComments | train | func SassOptionSetSourceComments(goopts SassOptions, b bool) {
C.sass_option_set_source_comments(goopts, C.bool(b))
} | go | {
"resource": ""
} |
q15675 | SassOptionSetOutputPath | train | func SassOptionSetOutputPath(goopts SassOptions, path string) {
C.sass_option_set_output_path(goopts, C.CString(path))
} | go | {
"resource": ""
} |
q15676 | SassOptionSetInputPath | train | func SassOptionSetInputPath(goopts SassOptions, path string) {
C.sass_option_set_input_path(goopts, C.CString(path))
} | go | {
"resource": ""
} |
q15677 | SassOptionSetIncludePath | train | func SassOptionSetIncludePath(goopts SassOptions, path string) {
C.sass_option_set_include_path(goopts, C.CString(path))
} | go | {
"resource": ""
} |
q15678 | SassMakeImport | train | func SassMakeImport(path string, base string, source string, srcmap string) SassImportEntry {
impent := C.sass_make_import(C.CString(path), C.CString(base),
C.CString(source), C.CString(srcmap))
return (SassImportEntry)(impent)
} | go | {
"resource": ""
} |
q15679 | SassMakeImporter | train | func SassMakeImporter(fn SassImporterFN, priority int, v interface{}) (SassImporter, error) {
vv := reflect.ValueOf(v).Elem()
if !vv.CanAddr() {
return nil, errors.New("can not take address of")
}
// TODO: this will leak memory, the interface must be freed manually
lst := C.sass_make_importer(C.Sass_Importer_Fn(fn), C.double(priority), unsafe.Pointer(vv.Addr().Pointer()))
return (SassImporter)(lst), nil
} | go | {
"resource": ""
} |
q15680 | SassImporterSetListEntry | train | func SassImporterSetListEntry(golst SassImporterList, idx int, ent SassImporter) {
C.sass_importer_set_list_entry(C.Sass_Importer_List(golst), C.size_t(idx), C.Sass_Importer_Entry(ent))
} | go | {
"resource": ""
} |
q15681 | BindImporter | train | func BindImporter(opts SassOptions, resolver ImportResolver) int {
idx := globalImports.Set(resolver)
ptr := unsafe.Pointer(uintptr(idx))
imper := C.sass_make_importer(
C.Sass_Importer_Fn(C.SassImporterHandler),
C.double(0),
ptr,
)
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
} | go | {
"resource": ""
} |
q15682 | ProcessSassError | train | func (ctx *compctx) ProcessSassError(bs []byte) error {
if len(bs) == 0 {
return nil
}
err := json.Unmarshal(bs, &ctx.err)
if err != nil {
return err
}
errors := ctx.err
ctx.errorString = fmt.Sprintf("Error > %s:%d\n%s",
errors.File, errors.Line, errors.Message)
return nil
} | go | {
"resource": ""
} |
q15683 | getSelectFunctors | train | func getSelectFunctors(attr *parser.Decl) ([]selectFunctor, error) {
var functors []selectFunctor
for i := range attr.Decl {
if attr.Decl[i].Token == parser.FromToken {
break
}
if attr.Decl[i].Token == parser.CountToken {
f := &countSelectFunction{}
functors = append(functors, f)
}
}
if len(functors) == 0 {
f := &defaultSelectFunction{}
functors = append(functors, f)
}
return functors, nil
} | go | {
"resource": ""
} |
q15684 | selectRows | train | func selectRows(row virtualRow, predicates []PredicateLinker, functors []selectFunctor) error {
var res bool
var err error
// If the row validate all predicates, write it
for _, predicate := 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
} | go | {
"resource": ""
} |
q15685 | orderbyExecutor | train | func orderbyExecutor(attr *parser.Decl, tables []*Table) (selectFunctor, error) {
f := &orderbyFunctor{}
f.buffer = make(map[int64][][]string)
// first subdecl should be attribute
if len(attr.Decl) < 1 {
return nil, fmt.Errorf("ordering attribute not provided")
}
// FIXME we should find for sure the table of the attribute
if len(tables) < 1 {
return nil, fmt.Errorf("cannot guess the table of attribute %s for order", attr.Decl[0].Lexeme)
}
if len(attr.Decl[0].Decl) > 0 {
f.orderby = attr.Decl[0].Decl[0].Lexeme + "." + attr.Decl[0].Lexeme
} else {
f.orderby = 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
} | go | {
"resource": ""
} |
q15686 | Stringy | train | func (d Decl) Stringy(depth int) {
indent := ""
for i := 0; i < depth; i++ {
indent = fmt.Sprintf("%s ", indent)
}
log.Debug("%s|-> %s\n", indent, d.Lexeme)
for _, subD := range d.Decl {
subD.Stringy(depth + 1)
}
} | go | {
"resource": ""
} |
q15687 | NewDecl | train | func NewDecl(t Token) *Decl {
return &Decl{
Token: t.Token,
Lexeme: t.Lexeme,
}
} | go | {
"resource": ""
} |
q15688 | Add | train | func (d *Decl) Add(subDecl *Decl) {
d.Decl = append(d.Decl, subDecl)
} | go | {
"resource": ""
} |
q15689 | parseBuiltinFunc | train | func (p *parser) parseBuiltinFunc() (*Decl, error) {
var d *Decl
var err error
// COUNT(attribute)
if p.is(CountToken) {
d, err = p.consumeToken(CountToken)
if err != nil {
return nil, err
}
// Bracket
_, err = p.consumeToken(BracketOpeningToken)
if err != nil {
return nil, err
}
// Attribute
attr, err := p.parseAttribute()
if err != nil {
return nil, err
}
d.Add(attr)
// Bracket
_, err = p.consumeToken(BracketClosingToken)
if err != nil {
return nil, err
}
}
return d, nil
} | go | {
"resource": ""
} |
q15690 | parseQuotedToken | train | func (p *parser) parseQuotedToken() (*Decl, error) {
quoted := false
quoteToken := DoubleQuoteToken
if p.is(DoubleQuoteToken) || p.is(BacktickToken){
quoted = true
quoteToken = p.cur().Token
if err := p.next(); err != nil {
return nil, err
}
}
// shoud be a StringToken here
if !p.is(StringToken) {
return nil, p.syntaxError()
}
decl := 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
} | go | {
"resource": ""
} |
q15691 | parseJoin | train | func (p *parser) parseJoin() (*Decl, error) {
joinDecl, err := p.consumeToken(JoinToken)
if err != nil {
return nil, err
}
// TABLE NAME
tableDecl, err := p.parseAttribute()
if err != nil {
return nil, err
}
joinDecl.Add(tableDecl)
// ON
onDecl, err := p.consumeToken(OnToken)
if err != nil {
return nil, err
}
// onDecl := NewDecl(t)
joinDecl.Add(onDecl)
// ATTRIBUTE
leftAttributeDecl, err := p.parseAttribute()
if err != nil {
return nil, err
}
onDecl.Add(leftAttributeDecl)
// 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
} | go | {
"resource": ""
} |
q15692 | New | train | func New(endpoint protocol.EngineEndpoint) (e *Engine, err error) {
e = &Engine{
endpoint: endpoint,
}
e.stop = make(chan bool)
e.opsExecutors = map[int]executor{
parser.CreateToken: createExecutor,
parser.TableToken: createTableExecutor,
parser.SelectToken: selectExecutor,
parser.InsertToken: insertIntoTableExecutor,
parser.DeleteToken: deleteExecutor,
parser.UpdateToken: updateExecutor,
parser.IfToken: ifExecutor,
parser.NotToken: notExecutor,
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
} | go | {
"resource": ""
} |
q15693 | Stop | train | func (e *Engine) Stop() {
if e.stop == nil {
// already stopped
return
}
go func() {
e.stop <- true
close(e.stop)
e.stop = nil
}()
} | go | {
"resource": ""
} |
q15694 | LastInsertId | train | func (r *Result) LastInsertId() (int64, error) {
if r.err != nil {
return 0, r.err
}
return r.lastInsertedID, nil
} | go | {
"resource": ""
} |
q15695 | RowsAffected | train | func (r *Result) RowsAffected() (int64, error) {
if r.err != nil {
return 0, r.err
}
return r.rowsAffected, nil
} | go | {
"resource": ""
} |
q15696 | NewTuple | train | func NewTuple(values ...interface{}) *Tuple {
t := &Tuple{}
for _, v := range values {
t.Values = append(t.Values, v)
}
return t
} | go | {
"resource": ""
} |
q15697 | Append | train | func (t *Tuple) Append(value interface{}) {
t.Values = append(t.Values, value)
} | go | {
"resource": ""
} |
q15698 | generateVirtualRows | train | func generateVirtualRows(e *Engine, attr []Attribute, conn protocol.EngineConn, t1Name string, joinPredicates []joiner, selectPredicates []PredicateLinker, functors []selectFunctor) error {
// get t1 and lock it
t1 := e.relation(t1Name)
if t1 == nil {
return fmt.Errorf("table %s not found", t1Name)
}
t1.RLock()
defer t1.RUnlock()
// all joined tables in a map of relation
relations := make(map[string]*Relation)
for _, j := range joinPredicates {
r := e.relation(j.On())
if r == nil {
return fmt.Errorf("table %s not found", j.On())
}
r.RLock()
defer r.RUnlock()
relations[j.On()] = r
}
// Write header
var header []string
var alias []string
for _, a := range attr {
alias = append(alias, a.name)
if strings.Contains(a.name, ".") == false {
a.name = t1Name + "." + a.name
}
header = append(header, a.name)
}
// Initialize functors here
for i := range functors {
if err := functors[i].Init(e, conn, header, alias); 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,
}
row[v.table+"."+v.lexeme] = v
}
// for first join predicates
err := join(row, relations, joinPredicates, 0, selectPredicates, functors)
if err != nil {
return err
}
}
for i := range functors {
err := functors[i].Done()
if err != nil {
return err
}
}
return nil
} | go | {
"resource": ""
} |
q15699 | join | train | func join(row virtualRow, relations map[string]*Relation, predicates []joiner, predicateIndex int, selectPredicates []PredicateLinker, functors []selectFunctor) error {
// Skip directly to selectRows if there is no joiner to run
if len(predicates) == 0 {
return selectRows(row, selectPredicates, functors)
}
// get current predicates
predicate := predicates[predicateIndex]
// last := is it last join ?
last := false
if predicateIndex >= len(predicates)-1 {
last = true
}
// for each row in relations[pred.Table()]
r := relations[predicate.On()]
for i := range r.rows {
ok, err := predicate.Evaluate(row, r, i)
if err != nil {
return err
}
// if predicate not ok
if !ok {
continue
}
// combine columns to existing virtual row
for index := range 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, relations, predicates, predicateIndex+1, selectPredicates, functors)
}
if err != nil {
return err
}
}
return nil
} | go | {
"resource": ""
} |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.