id stringlengths 2 7 | text stringlengths 17 51.2k | title stringclasses 1
value |
|---|---|---|
c6000 |
return &StaticCall{
FreeFloating: nil,
Class: Class,
Call: Call,
ArgumentList: ArgumentList,
}
} | |
c6001 | Left: Variable,
Right: Expression,
}
} | |
c6002 | Cond: Cond,
Stmt: Stmt,
}
} | |
c6003 | {
return &TraitUsePrecedence{
FreeFloating: nil,
Ref: Ref,
Insteadof: Insteadof,
}
} | |
c6004 | Expr: Expr,
Class: Class,
}
} | |
c6005 | Cond,
Stmt: Stmt,
ElseIf: ElseIf,
Else: Else,
}
} | |
c6006 | node.Node {
n.Else = Else
return n
} | |
c6007 | {
return &StaticPropertyFetch{
FreeFloating: nil,
Class: Class,
Property: Property,
}
} | |
c6008 | PhpDocComment: PhpDocComment,
MethodName: MethodName,
Modifiers: Modifiers,
Params: Params,
ReturnType: ReturnType,
Stmt: Stmt,
}
} | |
c6009 | nil,
Expr: Expr,
}
} | |
c6010 | Left: Variable,
Right: Expression,
}
} | |
c6011 | nil,
Expr: Expr,
}
} | |
c6012 | Static: Static,
PhpDocComment: PhpDocComment,
Params: Params,
ClosureUse: ClosureUse,
ReturnType: ReturnType,
Stmts: Stmts,
}
} | |
c6013 | "Static": n.Static,
"PhpDocComment": n.PhpDocComment,
}
} | |
c6014 | UseType,
Use: use,
Alias: Alias,
}
} | |
c6015 | FreeFloating: nil,
Expr: Expression,
}
} | |
c6016 | Variadic,
IsReference: IsReference,
Expr: Expression,
}
} | |
c6017 |
FreeFloating: nil,
Expr: Expression,
}
} | |
c6018 | FreeFloating: nil,
Vars: Vars,
}
} | |
c6019 | &Yield{
FreeFloating: nil,
Key: Key,
Value: Value,
}
} | |
c6020 | Left: Variable,
Right: Expression,
}
} | |
c6021 | nil,
Stmt: Stmt,
}
} | |
c6022 |
FreeFloating: nil,
Parts: Parts,
}
} | |
c6023 | FreeFloating: nil,
Variable: Variable,
}
} | |
c6024 | Left: Variable,
Right: Expression,
}
} | |
c6025 | nil,
Expr: Expr,
}
} | |
c6026 | } else {
nsr.ResolvedNames[nn] = nsr.Namespace.Namespace + "\\" + nodeName
}
} | |
c6027 |
if err == nil {
nsr.ResolvedNames[nameNode] = resolved
}
} | |
c6028 |
nsr.ResolveType(nn.Expr)
case name.Names:
nsr.ResolveName(n, "")
}
} | |
c6029 | := strings.ToLower(n.Parts[0].(*name.NamePart).Value)
switch part {
case "self":
fallthrough
case "static":
fallthrough
case "parent":
fallthrough
case "int":
fallthrough
case "float":
fallthrough
case "bool":
fallthrough
case "string":
fallthrough
case "void":
... | |
c6030 | qualified names, always against class alias type
firstPartStr = strings.ToLower(firstPartStr)
aliasType = ""
} else {
if aliasType != "const" { // constants are case-sensitive
firstPartStr = strings.ToLower(firstPartStr)
}
}
aliasName, ok := ns.Aliases[aliasType][firstPartStr]
if !ok {
return "", err... | |
c6031 |
return &TraitUseAlias{
FreeFloating: nil,
Ref: Ref,
Modifier: Modifier,
Alias: Alias,
}
} | |
c6032 | Left: Variable,
Right: Expression,
}
} | |
c6033 | FreeFloating: nil,
Expr: Expression,
}
} | |
c6034 | Variable,
Right: Expression,
}
} | |
c6035 | nil,
Expr: Expression,
}
} | |
c6036 | FreeFloating: nil,
Cases: Cases,
}
} | |
c6037 |
}
if unicode.IsDigit(r) {
return classUnicodeDigit
}
if unicode.IsGraphic(r) {
return classUnicodeGraphic
}
if r == lex.RuneEOF {
return int(r)
}
return classOther
} | |
c6038 | PhpDocComment: "",
FreeFloating: nil,
heredocLabel: "",
tokenBytesBuf: &bytes.Buffer{},
TokenPool: &TokenPool{},
}
} | |
c6039 | l.File.Line(firstChar.Pos()),
l.File.Line(lastChar.Pos()),
int(firstChar.Pos()),
int(lastChar.Pos()),
)
l.FreeFloating = append(l.FreeFloating, freefloating.String{
StringType: t,
Value: l.tokenString(chars),
Position: pos,
})
} | |
c6040 | nil,
Items: Items,
}
} | |
c6041 | Left: Variable,
Right: Expression,
}
} | |
c6042 | Condition: Condition,
IfTrue: IfTrue,
IfFalse: IfFalse,
}
} | |
c6043 |
indentStr: indentStr,
indentDepth: 0,
}
} | |
c6044 |
NamespaceName: NamespaceName,
Stmts: Stmts,
}
} | |
c6045 | FreeFloating: nil,
Expr: Expression,
}
} | |
c6046 | Expr,
Key: Key,
Variable: Variable,
Stmt: Stmt,
}
} | |
c6047 | Left: Variable,
Right: Expression,
}
} | |
c6048 | Left: Variable,
Right: Expression,
}
} | |
c6049 | FreeFloating: nil,
Stmts: Stmts,
}
} | |
c6050 | Left: Variable,
Right: Expression,
}
} | |
c6051 | Cond: Cond,
CaseList: CaseList,
}
} | |
c6052 | return &ElseIf{
FreeFloating: nil,
Cond: Cond,
Stmt: Stmt,
}
} | |
c6053 | &Declare{
FreeFloating: nil,
Consts: Consts,
Stmt: Stmt,
Alt: alt,
}
} | |
c6054 | Left: Variable,
Right: Expression,
}
} | |
c6055 | FreeFloating: nil,
Parts: Parts,
}
} | |
c6056 | FreeFloating: nil,
Expr: Expr,
}
} | |
c6057 | {
return &ArrayDimFetch{
FreeFloating: nil,
Variable: Variable,
Dim: Dim,
}
} | |
c6058 | FreeFloating: nil,
Vars: Vars,
}
} | |
c6059 | EndLine: EndLine,
StartPos: StartPos,
EndPos: EndPos,
}
} | |
c6060 | FreeFloating: nil,
Variable: Variable,
}
} | |
c6061 | Expr,
Key: Key,
Variable: Variable,
Stmt: Stmt,
}
} | |
c6062 | nil,
Label: Label,
}
} | |
c6063 | return 1 - x
},
lut: false,
}
} | |
c6064 | }
return float32(math.Pow(float64((x+0.055)/1.055), 2.4))
},
lut: true,
}
} | |
c6065 | func(x float32) float32 {
return powf32(x, e)
},
lut: true,
}
} | |
c6066 | 0.587*px.g + 0.114*px.b
return pixel{y, y, y, px.a}
},
}
} | |
c6067 | append(g.Filters, filters...)
} | |
c6068 | tmpOut
}
if i == last {
tmpOut = dst
} else {
tmpOut = createTempImage(f.Bounds(tmpIn.Bounds()))
}
f.Draw(tmpOut, tmpIn, &g.Options)
}
} | |
c6069 |
center := size / 2
weights := []uweight{}
for i := 0; i < size; i++ {
w := float32(0)
if i < len(kernel) {
w = kernel[i]
}
if w != 0 {
weights = append(weights, uweight{i - center, w})
}
}
return size, weights
} | |
c6070 | {
k := dstu + w.u
if k < 0 {
k = 0
} else if k > max {
k = max
}
c := srcBuf[k]
wa := c.a * w.weight
r += c.r * wa
g += c.g * wa
b += c.b * wa
a += wa
}
if a != 0 {
r /= a
g /= a
b /= a
}
dstBuf[dstu] = pixel{r, g, b, a}
}
} | |
c6071 | srcBuf := make([]pixel, srcb.Dy())
dstBuf := make([]pixel, srcb.Dy())
for x := start; x < stop; x++ {
pixGetter.getPixelColumn(x, &srcBuf)
convolveLine(dstBuf, srcBuf, weights)
pixSetter.setPixelColumn(dstb.Min.X+x-srcb.Min.X, dstBuf)
}
})
} | |
c6072 | srcBuf := make([]pixel, srcb.Dx())
dstBuf := make([]pixel, srcb.Dx())
for y := start; y < stop; y++ {
pixGetter.getPixelRow(y, &srcBuf)
convolveLine(dstBuf, srcBuf, weights)
pixSetter.setPixelRow(dstb.Min.Y+y-srcb.Min.Y, dstBuf)
}
})
} | |
c6073 | width,
h: height,
anchor: anchor,
}
} | |
c6074 | procs, func(pstart, pstop int) {
wg.Add(1)
go func() {
defer wg.Done()
fn(pstart, pstop)
}()
})
wg.Wait()
} | |
c6075 | for i := 0; i < n; i++ {
fn(
start+i*div+minint(i, mod),
start+(i+1)*div+minint(i+1, mod),
)
}
} | |
c6076 | o, ok := img.(opaquer); ok {
return o.Opaque()
}
return false
} | |
c6077 | y := kcenter - j
r := math.Sqrt(float64(x*x + y*y))
if r <= float64(ksize/2) {
disk[j*ksize+i] = 1
}
}
}
return disk
} | |
c6078 | i++ {
if defaultVal := t.Field(i).Tag.Get(fieldName); defaultVal != "-" {
if err := setField(v.Field(i), defaultVal); err != nil {
return err
}
}
}
return nil
} | |
c6079 | ", log.LstdFlags|log.Lmicroseconds)
} | |
c6080 | sizeInMB<<20, groupcache.GetterFunc(generatorFunc))
} else {
iconCache = nil
}
} | |
c6081 | nil
case 3:
n1, ok1 := parseSize(parts[0])
n2, ok2 := parseSize(parts[1])
n3, ok3 := parseSize(parts[2])
if !ok1 || !ok2 || !ok3 {
return nil, errBadSize
}
if !((n1 <= n2) && (n2 <= n3)) {
return nil, errBadSize
}
return &SizeRange{n1, n2, n3}, nil
}
return nil, errBadSize
} | |
c6082 |
sRGB = cf.findMainColor(colorMap, 2, &sRGB)
sRGB = cf.findMainColor(colorMap, 0, &sRGB)
return sRGB.rgb, nil
} | |
c6083 | i := uint16(0); i < dir.Count; i++ {
entry := icondirEntry{}
e := parseIcondirEntry(r, &entry)
if e != nil {
return nil, e
}
dir.Entries = append(dir.Entries, entry)
}
return &dir, err
} | |
c6084 | errInvalid
}
return image.Config{Width: best.width(), Height: best.height()}, nil
} | |
c6085 |
best := dir.FindBestIcon()
if best == nil {
return nil, errInvalid
}
return parseImage(best, icoBytes)
} | |
c6086 | = rand.New(s)
return f
} | |
c6087 | be <= atMost")
}
if atLeast < 0 {
panic("atLeast must be >= 0")
}
f.minElements = atLeast
f.maxElements = atMost
return f
} | |
c6088 | *Fuzzer {
f.maxDepth = d
return f
} | |
c6089 |
}
// Finally: see if there is a default fuzz function.
doCustom, ok = fc.fuzzer.defaultFuzzFuncs[v.Type()]
if !ok {
return false
}
}
switch v.Kind() {
case reflect.Ptr:
if v.IsNil() {
if !v.CanSet() {
return false
}
v.Set(reflect.New(v.Type().Elem()))
}
case reflect.Map:
if v.IsNil... | |
c6090 |
if v.Kind() != reflect.Ptr {
panic("needed ptr!")
}
v = v.Elem()
c.fc.doFuzz(v, 0)
} | |
c6091 | r.first)
return r.first + rune(rand.Int63n(count))
} | |
c6092 | {
return uint64(r.Uint32())<<32 | uint64(r.Uint32())
} | |
c6093 | var dur time.Duration
if tmCacheDur := tm.GetCacheDuration(); tmCacheDur != nil {
dur = time.Duration(tm.GetCacheDuration().Seconds) * time.Second
} else {
dur = 0
}
td := ThreatDescriptor{
ThreatType: ThreatType(tm.ThreatType),
PlatformType: PlatformType(tm.PlatformType),
ThreatEntryTy... | |
c6094 | ask the server what's going on.
return nil, cacheMiss
}
}
if len(threats) > 0 {
// So long as there are valid threats, we report them. The positive TTL
// takes precedence over the negative TTL at the partial hash level.
return threats, positiveCacheHit
}
// Check the negative TTLs to see if there are ... | |
c6095 |
}
}
}
if len(threatTTLs) == 0 {
delete(c.pttls, fullHash)
}
}
// Nuke all partial hashes based on their negative TTL.
for partialHash, nttl := range c.nttls {
if now.After(nttl) {
delete(c.nttls, partialHash)
}
}
} | |
c6096 | threat list stored on disk is not too stale.
if db.isStale(dbf.Time) {
db.log.Printf("database loaded is stale")
db.ml.Lock()
defer db.ml.Unlock()
db.setStale()
return false
}
// Validate that the database threat list stored on disk is at least a
// superset of the specified configuration.
tfuNew := mak... | |
c6097 | db.err
}
if db.isStale(db.last) {
db.setStale()
return db.err
}
return nil
} | |
c6098 |
if lag < db.config.UpdatePeriod {
return 0
}
return lag - db.config.UpdatePeriod
} | |
c6099 | db.ml.RUnlock()
return db.config.now().Sub(db.last)
} |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.