_id stringlengths 2 7 | title stringlengths 1 118 | partition stringclasses 3
values | text stringlengths 52 85.5k | language stringclasses 1
value | meta_information dict |
|---|---|---|---|---|---|
q181800 | MarshalJSON | test | func (this *HawkSignatureAuthenticationResponse) MarshalJSON() ([]byte, error) {
x := json.RawMessage(*this)
return (&x).MarshalJSON()
} | go | {
"resource": ""
} |
q181801 | bmw256 | test | func bmw256(input []byte) []byte {
b := new()
buf := make([]byte, 64)
copy(buf, input)
buf[len(input)] = 0x80
bitLen := uint64(len(input)) << 3
binary.LittleEndian.PutUint64(buf[56:], bitLen)
for i := 0; i < 16; i++ {
b.m[i] = binary.LittleEndian.Uint32(buf[i*4:])
}
b.compress(b.m)
b.h, b.h2 = b.h2, b.h
co... | go | {
"resource": ""
} |
q181802 | NewCubeHash | test | func NewCubeHash() *CubeHash {
c := &CubeHash{}
c.x0 = iv[0]
c.x1 = iv[1]
c.x2 = iv[2]
c.x3 = iv[3]
c.x4 = iv[4]
c.x5 = iv[5]
c.x6 = iv[6]
c.x7 = iv[7]
c.x8 = iv[8]
c.x9 = iv[9]
c.xa = iv[10]
c.xb = iv[11]
c.xc = iv[12]
c.xd = iv[13]
c.xe = iv[14]
c.xf = iv[15]
c.xg = iv[16]
c.xh = iv[17]
c.xi = iv[... | go | {
"resource": ""
} |
q181803 | cubehash256 | test | func cubehash256(data []byte) []byte {
c := NewCubeHash()
buf := make([]byte, 32)
buf[0] = 0x80
c.inputBlock(data)
c.sixteenRounds()
c.inputBlock(buf)
c.sixteenRounds()
c.xv ^= 1
for j := 0; j < 10; j++ {
c.sixteenRounds()
}
out := make([]byte, 32)
binary.LittleEndian.PutUint32(out[0:], c.x0)
binary.Litt... | go | {
"resource": ""
} |
q181804 | Sum | test | func Sum(data []byte) ([]byte, error) {
blake := blake256.New()
if _, err := blake.Write(data); err != nil {
return nil, err
}
resultBlake := blake.Sum(nil)
keccak := sha3.NewKeccak256()
if _, err := keccak.Write(resultBlake); err != nil {
return nil, err
}
resultkeccak := keccak.Sum(nil)
resultcube := c... | go | {
"resource": ""
} |
q181805 | squeeze | test | func squeeze(state []uint64, out []byte) {
tmp := make([]byte, blockLenBytes)
for j := 0; j < len(out)/blockLenBytes+1; j++ {
for i := 0; i < blockLenInt64; i++ {
binary.LittleEndian.PutUint64(tmp[i*8:], state[i])
}
copy(out[j*blockLenBytes:], tmp) //be care in case of len(out[i:])<len(tmp)
blake2bLyra(sta... | go | {
"resource": ""
} |
q181806 | reducedSqueezeRow0 | test | func reducedSqueezeRow0(state []uint64, rowOut []uint64, nCols int) {
ptr := (nCols - 1) * blockLenInt64
//M[row][C-1-col] = H.reduced_squeeze()
for i := 0; i < nCols; i++ {
ptrWord := rowOut[ptr:] //In Lyra2: pointer to M[0][C-1]
ptrWord[0] = state[0]
ptrWord[1] = state[1]
ptrWord[2] = state[2]
ptrWord[3]... | go | {
"resource": ""
} |
q181807 | reducedDuplexRow1 | test | func reducedDuplexRow1(state []uint64, rowIn []uint64, rowOut []uint64, nCols int) {
ptrIn := 0
ptrOut := (nCols - 1) * blockLenInt64
for i := 0; i < nCols; i++ {
ptrWordIn := rowIn[ptrIn:] //In Lyra2: pointer to prev
ptrWordOut := rowOut[ptrOut:] //In Lyra2: pointer to row
//Absorbing "M[prev][col]"
sta... | go | {
"resource": ""
} |
q181808 | NewReaderByteCodeLoader | test | func NewReaderByteCodeLoader(p parser.Parser, c compiler.Compiler) *ReaderByteCodeLoader {
return &ReaderByteCodeLoader{NewFlags(), p, c}
} | go | {
"resource": ""
} |
q181809 | LoadReader | test | func (l *ReaderByteCodeLoader) LoadReader(name string, rdr io.Reader) (*vm.ByteCode, error) {
ast, err := l.Parser.ParseReader(name, rdr)
if err != nil {
return nil, err
}
if l.ShouldDumpAST() {
fmt.Fprintf(os.Stderr, "AST:\n%s\n", ast)
}
bc, err := l.Compiler.Compile(ast)
if err != nil {
return nil, err... | go | {
"resource": ""
} |
q181810 | NewV3 | test | func NewV3(namespace *UUID, name []byte) *UUID {
uuid := newByHash(md5.New(), namespace, name)
uuid[6] = (uuid[6] & 0x0f) | 0x30
return uuid
} | go | {
"resource": ""
} |
q181811 | txLiteral | test | func txLiteral(st *State) {
st.sa = st.CurrentOp().Arg()
st.Advance()
} | go | {
"resource": ""
} |
q181812 | txFetchSymbol | test | func txFetchSymbol(st *State) {
// Need to handle local vars?
key := st.CurrentOp().Arg()
vars := st.Vars()
if v, ok := vars.Get(key); ok {
st.sa = v
} else {
st.sa = nil
}
st.Advance()
} | go | {
"resource": ""
} |
q181813 | txMarkRaw | test | func txMarkRaw(st *State) {
if reflect.ValueOf(st.sa).Type() != rawStringType {
st.sa = rawString(interfaceToString(st.sa))
}
st.Advance()
} | go | {
"resource": ""
} |
q181814 | txUnmarkRaw | test | func txUnmarkRaw(st *State) {
if reflect.ValueOf(st.sa).Type() == rawStringType {
st.sa = string(interfaceToString(st.sa))
}
st.Advance()
} | go | {
"resource": ""
} |
q181815 | txPrint | test | func txPrint(st *State) {
arg := st.sa
if arg == nil {
st.Warnf("Use of nil to print\n")
} else if reflect.ValueOf(st.sa).Type() != rawStringType {
st.AppendOutputString(html.EscapeString(interfaceToString(arg)))
} else {
st.AppendOutputString(interfaceToString(arg))
}
st.Advance()
} | go | {
"resource": ""
} |
q181816 | txPrintRaw | test | func txPrintRaw(st *State) {
// XXX TODO: mark_raw handling
arg := st.sa
if arg == nil {
st.Warnf("Use of nil to print\n")
} else {
st.AppendOutputString(interfaceToString(arg))
}
st.Advance()
} | go | {
"resource": ""
} |
q181817 | NewLoopVar | test | func NewLoopVar(idx int, array reflect.Value) *LoopVar {
lv := &LoopVar{
Index: idx,
Count: idx + 1,
Body: array,
Size: array.Len(),
MaxIndex: array.Len() - 1,
PeekNext: nil,
PeekPrev: nil,
IsFirst: false,
IsLast: false,
}
return lv
} | go | {
"resource": ""
} |
q181818 | txMakeArray | test | func txMakeArray(st *State) {
start := st.CurrentMark() // start
end := st.StackTip() // end
if end <= start {
panic(fmt.Sprintf("MakeArray: list start (%d) >= end (%d)", start, end))
}
list := make([]interface{}, end-start+1)
for i := end; i >= start; i-- {
list[i-start] = st.StackPop()
}
st.sa = li... | go | {
"resource": ""
} |
q181819 | txFunCallOmni | test | func txFunCallOmni(st *State) {
t := reflect.ValueOf(st.sa)
switch t.Kind() {
case reflect.Int:
// If it's an int, assume that it's a MACRO, which points to
// the location in the bytecode that contains the macro code
txMacroCall(st)
case reflect.Func:
txFunCall(st)
default:
st.Warnf("Unknown variable as... | go | {
"resource": ""
} |
q181820 | DumpAST | test | func (f *Flags) DumpAST(b bool) {
if b {
f.flags |= MaskDumpAST
} else {
f.flags &= ^MaskDumpAST
}
} | go | {
"resource": ""
} |
q181821 | DumpByteCode | test | func (f *Flags) DumpByteCode(b bool) {
if b {
f.flags |= MaskDumpByteCode
} else {
f.flags &= ^MaskDumpByteCode
}
} | go | {
"resource": ""
} |
q181822 | Optimize | test | func (o *NaiveOptimizer) Optimize(bc *vm.ByteCode) error {
for i := 0; i < bc.Len(); i++ {
op := bc.Get(i)
if op == nil {
return errors.New("failed to fetch op '" + op.String() + "'")
}
switch op.Type() {
case vm.TXOPLiteral:
if i+1 < bc.Len() && bc.Get(i+1).Type() == vm.TXOPPrintRaw {
bc.OpList[i]... | go | {
"resource": ""
} |
q181823 | NewFuncDepot | test | func NewFuncDepot(namespace string) *FuncDepot {
return &FuncDepot{namespace, make(map[string]reflect.Value)}
} | go | {
"resource": ""
} |
q181824 | Get | test | func (fc *FuncDepot) Get(key string) (reflect.Value, bool) {
f, ok := fc.depot[key]
return f, ok
} | go | {
"resource": ""
} |
q181825 | Set | test | func (fc *FuncDepot) Set(key string, v interface{}) {
fc.depot[key] = reflect.ValueOf(v)
} | go | {
"resource": ""
} |
q181826 | NewFileTemplateFetcher | test | func NewFileTemplateFetcher(paths []string) (*FileTemplateFetcher, error) {
l := &FileTemplateFetcher{
Paths: make([]string, len(paths)),
}
for k, v := range paths {
abs, err := filepath.Abs(v)
if err != nil {
return nil, err
}
l.Paths[k] = abs
}
return l, nil
} | go | {
"resource": ""
} |
q181827 | LastModified | test | func (s *FileSource) LastModified() (time.Time, error) {
// Calling os.Stat() for *every* Render of the same source is a waste
// Only call os.Stat() if we haven't done so in the last 1 second
if time.Since(s.LastStat) < time.Second {
// A-ha! it's not that long ago we calculated this value, just return
// the s... | go | {
"resource": ""
} |
q181828 | Reader | test | func (s *FileSource) Reader() (io.Reader, error) {
fh, err := os.Open(s.Path)
if err != nil {
return nil, err
}
return fh, nil
} | go | {
"resource": ""
} |
q181829 | Bytes | test | func (s *FileSource) Bytes() ([]byte, error) {
rdr, err := s.Reader()
if err != nil {
return nil, err
}
return ioutil.ReadAll(rdr)
} | go | {
"resource": ""
} |
q181830 | NewState | test | func NewState() *State {
st := &State{
opidx: 0,
pc: NewByteCode(),
stack: stack.New(5),
markstack: stack.New(5),
framestack: stack.New(5),
frames: stack.New(5),
vars: make(Vars),
warn: os.Stderr,
MaxLoopCount: 1000,
}
st.Pushmark()
st.PushFrame()
return st
} | go | {
"resource": ""
} |
q181831 | PushFrame | test | func (st *State) PushFrame() *frame.Frame {
f := frame.New(st.framestack)
st.frames.Push(f)
f.SetMark(st.frames.Size())
return f
} | go | {
"resource": ""
} |
q181832 | PopFrame | test | func (st *State) PopFrame() *frame.Frame {
x := st.frames.Pop()
if x == nil {
return nil
}
f := x.(*frame.Frame)
for i := st.framestack.Size(); i > f.Mark(); i-- {
st.framestack.Pop()
}
return f
} | go | {
"resource": ""
} |
q181833 | CurrentFrame | test | func (st *State) CurrentFrame() *frame.Frame {
x, err := st.frames.Top()
if err != nil {
return nil
}
return x.(*frame.Frame)
} | go | {
"resource": ""
} |
q181834 | Warnf | test | func (st *State) Warnf(format string, args ...interface{}) {
st.warn.Write([]byte(fmt.Sprintf(format, args...)))
} | go | {
"resource": ""
} |
q181835 | AppendOutputString | test | func (st *State) AppendOutputString(o string) {
st.output.Write([]byte(o))
} | go | {
"resource": ""
} |
q181836 | Popmark | test | func (st *State) Popmark() int {
x := st.markstack.Pop()
return x.(int)
} | go | {
"resource": ""
} |
q181837 | CurrentMark | test | func (st *State) CurrentMark() int {
x, err := st.markstack.Top()
if err != nil {
x = 0
}
return x.(int)
} | go | {
"resource": ""
} |
q181838 | LoadByteCode | test | func (st *State) LoadByteCode(key string) (*ByteCode, error) {
return st.Loader.Load(key)
} | go | {
"resource": ""
} |
q181839 | Reset | test | func (st *State) Reset() {
st.opidx = 0
st.sa = nil
st.sb = nil
st.stack.Reset()
st.markstack.Reset()
st.frames.Reset()
st.framestack.Reset()
st.Pushmark()
st.PushFrame()
} | go | {
"resource": ""
} |
q181840 | DeclareVar | test | func (f *Frame) DeclareVar(v interface{}) int {
f.stack.Push(v)
return f.stack.Size() - 1
} | go | {
"resource": ""
} |
q181841 | GetLvar | test | func (f *Frame) GetLvar(i int) (interface{}, error) {
v, err := f.stack.Get(i)
if err != nil {
return nil, errors.Wrap(err, "failed to get local variable at "+strconv.Itoa(i+f.mark))
}
return v, nil
} | go | {
"resource": ""
} |
q181842 | SetLvar | test | func (f *Frame) SetLvar(i int, v interface{}) {
f.stack.Set(i, v)
} | go | {
"resource": ""
} |
q181843 | NewByteCode | test | func NewByteCode() *ByteCode {
return &ByteCode{
GeneratedOn: time.Now(),
Name: "",
OpList: nil,
Version: 1.0,
}
} | go | {
"resource": ""
} |
q181844 | Append | test | func (b *ByteCode) Append(op Op) {
b.OpList = append(b.OpList, op)
} | go | {
"resource": ""
} |
q181845 | AppendOp | test | func (b *ByteCode) AppendOp(o OpType, args ...interface{}) Op {
x := NewOp(o, args...)
b.Append(x)
return x
} | go | {
"resource": ""
} |
q181846 | String | test | func (b *ByteCode) String() string {
buf := rbpool.Get()
defer rbpool.Release(buf)
fmt.Fprintf(buf,
"// Bytecode for '%s'\n// Generated On: %s\n",
b.Name,
b.GeneratedOn,
)
for k, v := range b.OpList {
fmt.Fprintf(buf, "%03d. %s\n", k+1, v)
}
return buf.String()
} | go | {
"resource": ""
} |
q181847 | NewCachedByteCodeLoader | test | func NewCachedByteCodeLoader(
cache Cache,
cacheLevel CacheStrategy,
fetcher TemplateFetcher,
parser parser.Parser,
compiler compiler.Compiler,
) *CachedByteCodeLoader {
return &CachedByteCodeLoader{
NewStringByteCodeLoader(parser, compiler),
NewReaderByteCodeLoader(parser, compiler),
fetcher,
[]Cache{Mem... | go | {
"resource": ""
} |
q181848 | Load | test | func (l *CachedByteCodeLoader) Load(key string) (bc *vm.ByteCode, err error) {
defer func() {
if bc != nil && err == nil && l.ShouldDumpByteCode() {
fmt.Fprintf(os.Stderr, "%s\n", bc.String())
}
}()
var source TemplateSource
if l.CacheLevel > CacheNone {
var entity *CacheEntity
for _, cache := range l.C... | go | {
"resource": ""
} |
q181849 | NewFileCache | test | func NewFileCache(dir string) (*FileCache, error) {
f := &FileCache{dir}
return f, nil
} | go | {
"resource": ""
} |
q181850 | GetCachePath | test | func (c *FileCache) GetCachePath(key string) string {
// What's the best, portable way to remove make an absolute path into
// a relative path?
key = filepath.Clean(key)
key = strings.TrimPrefix(key, "/")
return filepath.Join(c.Dir, key)
} | go | {
"resource": ""
} |
q181851 | Get | test | func (c *FileCache) Get(key string) (*CacheEntity, error) {
path := c.GetCachePath(key)
// Need to avoid race condition
file, err := os.Open(path)
if err != nil {
return nil, errors.Wrap(err, "failed to open cache file '"+path+"'")
}
defer file.Close()
var entity CacheEntity
dec := gob.NewDecoder(file)
if ... | go | {
"resource": ""
} |
q181852 | Set | test | func (c *FileCache) Set(key string, entity *CacheEntity) error {
path := c.GetCachePath(key)
if err := os.MkdirAll(filepath.Dir(path), 0777); err != nil {
return errors.Wrap(err, "failed to create directory for cache file")
}
// Need to avoid race condition
file, err := os.OpenFile(path, os.O_WRONLY|os.O_CREATE... | go | {
"resource": ""
} |
q181853 | Delete | test | func (c *FileCache) Delete(key string) error {
return errors.Wrap(os.Remove(c.GetCachePath(key)), "failed to remove file cache file")
} | go | {
"resource": ""
} |
q181854 | Get | test | func (c MemoryCache) Get(key string) (*CacheEntity, error) {
bc, ok := c[key]
if !ok {
return nil, errors.New("cache miss")
}
return bc, nil
} | go | {
"resource": ""
} |
q181855 | Set | test | func (c MemoryCache) Set(key string, bc *CacheEntity) error {
c[key] = bc
return nil
} | go | {
"resource": ""
} |
q181856 | Delete | test | func (c MemoryCache) Delete(key string) error {
delete(c, key)
return nil
} | go | {
"resource": ""
} |
q181857 | NewStringLexer | test | func NewStringLexer(template string) *parser.Lexer {
l := parser.NewStringLexer(template, SymbolSet)
l.SetTagStart("[%")
l.SetTagEnd("%]")
return l
} | go | {
"resource": ""
} |
q181858 | NewReaderLexer | test | func NewReaderLexer(rdr io.Reader) *parser.Lexer {
l := parser.NewReaderLexer(rdr, SymbolSet)
l.SetTagStart("[%")
l.SetTagEnd("%]")
return l
} | go | {
"resource": ""
} |
q181859 | NewV4 | test | func NewV4() *UUID {
buf := make([]byte, 16)
rand.Read(buf)
buf[6] = (buf[6] & 0x0f) | 0x40
var uuid UUID
copy(uuid[:], buf[:])
uuid.variantRFC4122()
return &uuid
} | go | {
"resource": ""
} |
q181860 | Parse | test | func (p *Kolonish) Parse(name string, template []byte) (*parser.AST, error) {
return p.ParseString(name, string(template))
} | go | {
"resource": ""
} |
q181861 | ParseReader | test | func (p *Kolonish) ParseReader(name string, rdr io.Reader) (*parser.AST, error) {
b := parser.NewBuilder()
lex := NewReaderLexer(rdr)
return b.Parse(name, lex)
} | go | {
"resource": ""
} |
q181862 | Visit | test | func (ast *AST) Visit() <-chan node.Node {
c := make(chan node.Node)
go func() {
defer close(c)
ast.Root.Visit(c)
}()
return c
} | go | {
"resource": ""
} |
q181863 | String | test | func (ast *AST) String() string {
buf := rbpool.Get()
defer rbpool.Release(buf)
c := ast.Visit()
k := 0
for v := range c {
k++
fmt.Fprintf(buf, "%03d. %s\n", k, v)
}
return buf.String()
} | go | {
"resource": ""
} |
q181864 | Run | test | func (vm *VM) Run(bc *ByteCode, vars Vars, output io.Writer) {
if !vm.IsSupportedByteCodeVersion(bc) {
panic(fmt.Sprintf(
"error: ByteCode version %f no supported",
bc.Version,
))
}
st := vm.st
if _, ok := output.(*bufio.Writer); !ok {
output = bufio.NewWriter(output)
defer output.(*bufio.Writer).Fl... | go | {
"resource": ""
} |
q181865 | DefaultParser | test | func DefaultParser(tx *Xslate, args Args) error {
syntax, ok := args.Get("Syntax")
if !ok {
syntax = "TTerse"
}
switch syntax {
case "TTerse":
tx.Parser = tterse.New()
case "Kolon", "Kolonish":
tx.Parser = kolonish.New()
default:
return errors.New("sytanx '" + syntax.(string) + "' is not available")
}
... | go | {
"resource": ""
} |
q181866 | DefaultLoader | test | func DefaultLoader(tx *Xslate, args Args) error {
var tmp interface{}
tmp, ok := args.Get("CacheDir")
if !ok {
tmp, _ = ioutil.TempDir("", "go-xslate-cache-")
}
cacheDir := tmp.(string)
tmp, ok = args.Get("LoadPaths")
if !ok {
cwd, _ := os.Getwd()
tmp = []string{cwd}
}
paths := tmp.([]string)
cache,... | go | {
"resource": ""
} |
q181867 | DefaultVM | test | func DefaultVM(tx *Xslate, args Args) error {
dvm := vm.NewVM()
dvm.Loader = tx.Loader
tx.VM = dvm
return nil
} | go | {
"resource": ""
} |
q181868 | Get | test | func (args Args) Get(key string) (interface{}, bool) {
ret, ok := args[key]
return ret, ok
} | go | {
"resource": ""
} |
q181869 | NewHTTPSource | test | func NewHTTPSource(r *http.Response) (*HTTPSource, error) {
body, err := ioutil.ReadAll(r.Body)
if err != nil {
return nil, err
}
s := &HTTPSource{
bytes.NewBuffer(body),
time.Time{},
}
if lastmodStr := r.Header.Get("Last-Modified"); lastmodStr != "" {
t, err := time.Parse(http.TimeFormat, lastmodStr)
... | go | {
"resource": ""
} |
q181870 | NewStringByteCodeLoader | test | func NewStringByteCodeLoader(p parser.Parser, c compiler.Compiler) *StringByteCodeLoader {
return &StringByteCodeLoader{NewFlags(), p, c}
} | go | {
"resource": ""
} |
q181871 | LoadString | test | func (l *StringByteCodeLoader) LoadString(name string, template string) (*vm.ByteCode, error) {
ast, err := l.Parser.ParseString(name, template)
if err != nil {
return nil, err
}
if l.ShouldDumpAST() {
fmt.Fprintf(os.Stderr, "AST:\n%s\n", ast)
}
bc, err := l.Compiler.Compile(ast)
if err != nil {
return n... | go | {
"resource": ""
} |
q181872 | Get | test | func (v Vars) Get(k interface{}) (interface{}, bool) {
key, ok := k.(string)
if !ok {
key = fmt.Sprintf("%s", k)
}
x, ok := v[key]
return x, ok
} | go | {
"resource": ""
} |
q181873 | NewOp | test | func NewOp(o OpType, args ...interface{}) Op {
h := optypeToHandler(o)
var arg interface{}
if len(args) > 0 {
arg = args[0]
}
return &op{
OpType: o,
OpHandler: h,
uArg: arg,
}
} | go | {
"resource": ""
} |
q181874 | MarshalBinary | test | func (o op) MarshalBinary() ([]byte, error) {
buf := rbpool.Get()
defer rbpool.Release(buf)
// Write the code/opcode
if err := binary.Write(buf, binary.LittleEndian, int64(o.OpType)); err != nil {
return nil, errors.Wrap(err, "failed to marshal op to binary")
}
// If this has args, we need to encode the args
... | go | {
"resource": ""
} |
q181875 | UnmarshalBinary | test | func (o *op) UnmarshalBinary(data []byte) error {
buf := bytes.NewReader(data)
var t int64
if err := binary.Read(buf, binary.LittleEndian, &t); err != nil {
return errors.Wrap(err, "optype check failed during UnmarshalBinary")
}
o.OpType = OpType(t)
o.OpHandler = optypeToHandler(o.OpType)
var hasArg int8
i... | go | {
"resource": ""
} |
q181876 | ArgInt | test | func (o op) ArgInt() int {
v := interfaceToNumeric(o.uArg)
return int(v.Int())
} | go | {
"resource": ""
} |
q181877 | ArgString | test | func (o op) ArgString() string {
// In most cases we do this because it's a sring
if v, ok := o.uArg.(string); ok {
return v
}
return interfaceToString(o.uArg)
} | go | {
"resource": ""
} |
q181878 | AppendOp | test | func (ctx *context) AppendOp(o vm.OpType, args ...interface{}) vm.Op {
return ctx.ByteCode.AppendOp(o, args...)
} | go | {
"resource": ""
} |
q181879 | Compile | test | func (c *BasicCompiler) Compile(ast *parser.AST) (*vm.ByteCode, error) {
ctx := &context{
ByteCode: vm.NewByteCode(),
}
for _, n := range ast.Root.Nodes {
compile(ctx, n)
}
// When we're done compiling, always append an END op
ctx.ByteCode.AppendOp(vm.TXOPEnd)
opt := &NaiveOptimizer{}
opt.Optimize(ctx.Byt... | go | {
"resource": ""
} |
q181880 | NewV5 | test | func NewV5(namespaceUUID *UUID, name []byte) *UUID {
uuid := newByHash(sha1.New(), namespaceUUID, name)
uuid[6] = (uuid[6] & 0x0f) | 0x50
return uuid
} | go | {
"resource": ""
} |
q181881 | Sort | test | func (list LexSymbolList) Sort() LexSymbolList {
sorter := LexSymbolSorter{
list: list,
}
sort.Sort(sorter)
return sorter.list
} | go | {
"resource": ""
} |
q181882 | Less | test | func (s LexSymbolSorter) Less(i, j int) bool {
return s.list[i].Priority > s.list[j].Priority
} | go | {
"resource": ""
} |
q181883 | Swap | test | func (s LexSymbolSorter) Swap(i, j int) {
s.list[i], s.list[j] = s.list[j], s.list[i]
} | go | {
"resource": ""
} |
q181884 | Copy | test | func (l *LexSymbolSet) Copy() *LexSymbolSet {
c := NewLexSymbolSet()
for k, v := range l.Map {
c.Map[k] = LexSymbol{v.Name, v.Type, v.Priority}
}
return c
} | go | {
"resource": ""
} |
q181885 | Set | test | func (l *LexSymbolSet) Set(name string, typ lex.ItemType, prio ...float32) {
var x float32
if len(prio) < 1 {
x = 1.0
} else {
x = prio[0]
}
l.Map[name] = LexSymbol{name, typ, x}
l.SortedList = nil // reset
} | go | {
"resource": ""
} |
q181886 | GetSortedList | test | func (l *LexSymbolSet) GetSortedList() LexSymbolList {
// Because symbols are parsed automatically in a loop, we need to make
// sure that we search starting with the longest term (e.g., "INCLUDE"
// must come before "IN")
// However, simply sorting the symbols using alphabetical sort then
// max-length forces us ... | go | {
"resource": ""
} |
q181887 | Top | test | func (s *Stack) Top() (interface{}, error) {
if len(*s) == 0 {
return nil, errors.New("nothing on stack")
}
return (*s)[len(*s)-1], nil
} | go | {
"resource": ""
} |
q181888 | Resize | test | func (s *Stack) Resize(size int) {
newl := make([]interface{}, len(*s), size)
copy(newl, *s)
*s = newl
} | go | {
"resource": ""
} |
q181889 | Extend | test | func (s *Stack) Extend(extendBy int) {
s.Resize(s.Size() + extendBy)
} | go | {
"resource": ""
} |
q181890 | Grow | test | func (s *Stack) Grow(min int) {
// Automatically grow the stack to some long-enough length
if min <= s.BufferSize() {
// we have enough
return
}
s.Resize(calcNewSize(min))
} | go | {
"resource": ""
} |
q181891 | Get | test | func (s *Stack) Get(i int) (interface{}, error) {
if i < 0 || i >= len(*s) {
return nil, errors.New(strconv.Itoa(i) + " is out of range")
}
return (*s)[i], nil
} | go | {
"resource": ""
} |
q181892 | Set | test | func (s *Stack) Set(i int, v interface{}) error {
if i < 0 {
return errors.New("invalid index into stack")
}
if i >= s.BufferSize() {
s.Resize(calcNewSize(i))
}
for len(*s) < i + 1 {
*s = append(*s, nil)
}
(*s)[i] = v
return nil
} | go | {
"resource": ""
} |
q181893 | Push | test | func (s *Stack) Push(v interface{}) {
if len(*s) >= s.BufferSize() {
s.Resize(calcNewSize(cap(*s)))
}
*s = append(*s, v)
} | go | {
"resource": ""
} |
q181894 | Pop | test | func (s *Stack) Pop() interface{} {
l := len(*s)
if l == 0 {
return nil
}
v := (*s)[l-1]
*s = (*s)[:l-1]
return v
} | go | {
"resource": ""
} |
q181895 | String | test | func (s *Stack) String() string {
buf := bytes.Buffer{}
for k, v := range *s {
fmt.Fprintf(&buf, "%03d: %q\n", k, v)
}
return buf.String()
} | go | {
"resource": ""
} |
q181896 | GetHostIPs | test | func GetHostIPs() ([]net.IP, error) {
ifaces, err := net.Interfaces()
if err != nil {
return nil, err
}
var ips []net.IP
for _, iface := range ifaces {
if strings.HasPrefix(iface.Name, "docker") {
continue
}
addrs, err := iface.Addrs()
if err != nil {
continue
}
for _, addr := range addrs {
... | go | {
"resource": ""
} |
q181897 | GetPrivateHostIPs | test | func GetPrivateHostIPs() ([]net.IP, error) {
ips, err := GetHostIPs()
if err != nil {
return nil, err
}
var privateIPs []net.IP
for _, ip := range ips {
// skip loopback, non-IPv4 and non-private addresses
if ip.IsLoopback() || ip.To4() == nil || !IsPrivate(ip) {
continue
}
privateIPs = append(privat... | go | {
"resource": ""
} |
q181898 | IsPrivate | test | func IsPrivate(ip net.IP) bool {
for _, ipnet := range privateNets {
if ipnet.Contains(ip) {
return true
}
}
return false
} | go | {
"resource": ""
} |
q181899 | Environ | test | func Environ() []string {
s := make([]string, 0)
FlagSet.VisitAll(func(f *flag.Flag) {
if value, ok := getenv(f.Name); ok {
s = append(s, flagAsEnv(f.Name)+"="+value)
}
})
return s
} | go | {
"resource": ""
} |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.