id
int32 0
167k
| repo
stringlengths 5
54
| path
stringlengths 4
155
| func_name
stringlengths 1
118
| original_string
stringlengths 52
85.5k
| language
stringclasses 1
value | code
stringlengths 52
85.5k
| code_tokens
listlengths 21
1.41k
| docstring
stringlengths 6
2.61k
| docstring_tokens
listlengths 3
215
| sha
stringlengths 40
40
| url
stringlengths 85
252
|
|---|---|---|---|---|---|---|---|---|---|---|---|
6,000 |
z7zmey/php-parser
|
node/expr/n_static_call.go
|
NewStaticCall
|
func NewStaticCall(Class node.Node, Call node.Node, ArgumentList *node.ArgumentList) *StaticCall {
return &StaticCall{
FreeFloating: nil,
Class: Class,
Call: Call,
ArgumentList: ArgumentList,
}
}
|
go
|
func NewStaticCall(Class node.Node, Call node.Node, ArgumentList *node.ArgumentList) *StaticCall {
return &StaticCall{
FreeFloating: nil,
Class: Class,
Call: Call,
ArgumentList: ArgumentList,
}
}
|
[
"func",
"NewStaticCall",
"(",
"Class",
"node",
".",
"Node",
",",
"Call",
"node",
".",
"Node",
",",
"ArgumentList",
"*",
"node",
".",
"ArgumentList",
")",
"*",
"StaticCall",
"{",
"return",
"&",
"StaticCall",
"{",
"FreeFloating",
":",
"nil",
",",
"Class",
":",
"Class",
",",
"Call",
":",
"Call",
",",
"ArgumentList",
":",
"ArgumentList",
",",
"}",
"\n",
"}"
] |
// NewStaticCall node constructor
|
[
"NewStaticCall",
"node",
"constructor"
] |
394f8821001f38fe5b4c4aaffd4fa20e50927a3f
|
https://github.com/z7zmey/php-parser/blob/394f8821001f38fe5b4c4aaffd4fa20e50927a3f/node/expr/n_static_call.go#L20-L27
|
6,001 |
z7zmey/php-parser
|
node/expr/binary/n_not_equal.go
|
NewNotEqual
|
func NewNotEqual(Variable node.Node, Expression node.Node) *NotEqual {
return &NotEqual{
FreeFloating: nil,
Left: Variable,
Right: Expression,
}
}
|
go
|
func NewNotEqual(Variable node.Node, Expression node.Node) *NotEqual {
return &NotEqual{
FreeFloating: nil,
Left: Variable,
Right: Expression,
}
}
|
[
"func",
"NewNotEqual",
"(",
"Variable",
"node",
".",
"Node",
",",
"Expression",
"node",
".",
"Node",
")",
"*",
"NotEqual",
"{",
"return",
"&",
"NotEqual",
"{",
"FreeFloating",
":",
"nil",
",",
"Left",
":",
"Variable",
",",
"Right",
":",
"Expression",
",",
"}",
"\n",
"}"
] |
// NewNotEqual node constructor
|
[
"NewNotEqual",
"node",
"constructor"
] |
394f8821001f38fe5b4c4aaffd4fa20e50927a3f
|
https://github.com/z7zmey/php-parser/blob/394f8821001f38fe5b4c4aaffd4fa20e50927a3f/node/expr/binary/n_not_equal.go#L19-L25
|
6,002 |
z7zmey/php-parser
|
node/stmt/n_alt_else_if.go
|
NewAltElseIf
|
func NewAltElseIf(Cond node.Node, Stmt node.Node) *AltElseIf {
return &AltElseIf{
FreeFloating: nil,
Cond: Cond,
Stmt: Stmt,
}
}
|
go
|
func NewAltElseIf(Cond node.Node, Stmt node.Node) *AltElseIf {
return &AltElseIf{
FreeFloating: nil,
Cond: Cond,
Stmt: Stmt,
}
}
|
[
"func",
"NewAltElseIf",
"(",
"Cond",
"node",
".",
"Node",
",",
"Stmt",
"node",
".",
"Node",
")",
"*",
"AltElseIf",
"{",
"return",
"&",
"AltElseIf",
"{",
"FreeFloating",
":",
"nil",
",",
"Cond",
":",
"Cond",
",",
"Stmt",
":",
"Stmt",
",",
"}",
"\n",
"}"
] |
// NewAltElseIf node constructor
|
[
"NewAltElseIf",
"node",
"constructor"
] |
394f8821001f38fe5b4c4aaffd4fa20e50927a3f
|
https://github.com/z7zmey/php-parser/blob/394f8821001f38fe5b4c4aaffd4fa20e50927a3f/node/stmt/n_alt_else_if.go#L19-L25
|
6,003 |
z7zmey/php-parser
|
node/stmt/n_trait_use_precedence.go
|
NewTraitUsePrecedence
|
func NewTraitUsePrecedence(Ref node.Node, Insteadof []node.Node) *TraitUsePrecedence {
return &TraitUsePrecedence{
FreeFloating: nil,
Ref: Ref,
Insteadof: Insteadof,
}
}
|
go
|
func NewTraitUsePrecedence(Ref node.Node, Insteadof []node.Node) *TraitUsePrecedence {
return &TraitUsePrecedence{
FreeFloating: nil,
Ref: Ref,
Insteadof: Insteadof,
}
}
|
[
"func",
"NewTraitUsePrecedence",
"(",
"Ref",
"node",
".",
"Node",
",",
"Insteadof",
"[",
"]",
"node",
".",
"Node",
")",
"*",
"TraitUsePrecedence",
"{",
"return",
"&",
"TraitUsePrecedence",
"{",
"FreeFloating",
":",
"nil",
",",
"Ref",
":",
"Ref",
",",
"Insteadof",
":",
"Insteadof",
",",
"}",
"\n",
"}"
] |
// NewTraitUsePrecedence node constructor
|
[
"NewTraitUsePrecedence",
"node",
"constructor"
] |
394f8821001f38fe5b4c4aaffd4fa20e50927a3f
|
https://github.com/z7zmey/php-parser/blob/394f8821001f38fe5b4c4aaffd4fa20e50927a3f/node/stmt/n_trait_use_precedence.go#L19-L25
|
6,004 |
z7zmey/php-parser
|
node/expr/n_instance_of.go
|
NewInstanceOf
|
func NewInstanceOf(Expr node.Node, Class node.Node) *InstanceOf {
return &InstanceOf{
FreeFloating: nil,
Expr: Expr,
Class: Class,
}
}
|
go
|
func NewInstanceOf(Expr node.Node, Class node.Node) *InstanceOf {
return &InstanceOf{
FreeFloating: nil,
Expr: Expr,
Class: Class,
}
}
|
[
"func",
"NewInstanceOf",
"(",
"Expr",
"node",
".",
"Node",
",",
"Class",
"node",
".",
"Node",
")",
"*",
"InstanceOf",
"{",
"return",
"&",
"InstanceOf",
"{",
"FreeFloating",
":",
"nil",
",",
"Expr",
":",
"Expr",
",",
"Class",
":",
"Class",
",",
"}",
"\n",
"}"
] |
// NewInstanceOf node constructor
|
[
"NewInstanceOf",
"node",
"constructor"
] |
394f8821001f38fe5b4c4aaffd4fa20e50927a3f
|
https://github.com/z7zmey/php-parser/blob/394f8821001f38fe5b4c4aaffd4fa20e50927a3f/node/expr/n_instance_of.go#L19-L25
|
6,005 |
z7zmey/php-parser
|
node/stmt/n_alt_if.go
|
NewAltIf
|
func NewAltIf(Cond node.Node, Stmt node.Node, ElseIf []node.Node, Else node.Node) *AltIf {
return &AltIf{
FreeFloating: nil,
Cond: Cond,
Stmt: Stmt,
ElseIf: ElseIf,
Else: Else,
}
}
|
go
|
func NewAltIf(Cond node.Node, Stmt node.Node, ElseIf []node.Node, Else node.Node) *AltIf {
return &AltIf{
FreeFloating: nil,
Cond: Cond,
Stmt: Stmt,
ElseIf: ElseIf,
Else: Else,
}
}
|
[
"func",
"NewAltIf",
"(",
"Cond",
"node",
".",
"Node",
",",
"Stmt",
"node",
".",
"Node",
",",
"ElseIf",
"[",
"]",
"node",
".",
"Node",
",",
"Else",
"node",
".",
"Node",
")",
"*",
"AltIf",
"{",
"return",
"&",
"AltIf",
"{",
"FreeFloating",
":",
"nil",
",",
"Cond",
":",
"Cond",
",",
"Stmt",
":",
"Stmt",
",",
"ElseIf",
":",
"ElseIf",
",",
"Else",
":",
"Else",
",",
"}",
"\n",
"}"
] |
// NewAltIf node constructor
|
[
"NewAltIf",
"node",
"constructor"
] |
394f8821001f38fe5b4c4aaffd4fa20e50927a3f
|
https://github.com/z7zmey/php-parser/blob/394f8821001f38fe5b4c4aaffd4fa20e50927a3f/node/stmt/n_alt_if.go#L21-L29
|
6,006 |
z7zmey/php-parser
|
node/stmt/n_alt_if.go
|
SetElse
|
func (n *AltIf) SetElse(Else node.Node) node.Node {
n.Else = Else
return n
}
|
go
|
func (n *AltIf) SetElse(Else node.Node) node.Node {
n.Else = Else
return n
}
|
[
"func",
"(",
"n",
"*",
"AltIf",
")",
"SetElse",
"(",
"Else",
"node",
".",
"Node",
")",
"node",
".",
"Node",
"{",
"n",
".",
"Else",
"=",
"Else",
"\n\n",
"return",
"n",
"\n",
"}"
] |
// SetElse set AltElse node and returns AltIf node
|
[
"SetElse",
"set",
"AltElse",
"node",
"and",
"returns",
"AltIf",
"node"
] |
394f8821001f38fe5b4c4aaffd4fa20e50927a3f
|
https://github.com/z7zmey/php-parser/blob/394f8821001f38fe5b4c4aaffd4fa20e50927a3f/node/stmt/n_alt_if.go#L62-L66
|
6,007 |
z7zmey/php-parser
|
node/expr/n_static_property_fetch.go
|
NewStaticPropertyFetch
|
func NewStaticPropertyFetch(Class node.Node, Property node.Node) *StaticPropertyFetch {
return &StaticPropertyFetch{
FreeFloating: nil,
Class: Class,
Property: Property,
}
}
|
go
|
func NewStaticPropertyFetch(Class node.Node, Property node.Node) *StaticPropertyFetch {
return &StaticPropertyFetch{
FreeFloating: nil,
Class: Class,
Property: Property,
}
}
|
[
"func",
"NewStaticPropertyFetch",
"(",
"Class",
"node",
".",
"Node",
",",
"Property",
"node",
".",
"Node",
")",
"*",
"StaticPropertyFetch",
"{",
"return",
"&",
"StaticPropertyFetch",
"{",
"FreeFloating",
":",
"nil",
",",
"Class",
":",
"Class",
",",
"Property",
":",
"Property",
",",
"}",
"\n",
"}"
] |
// NewStaticPropertyFetch node constructor
|
[
"NewStaticPropertyFetch",
"node",
"constructor"
] |
394f8821001f38fe5b4c4aaffd4fa20e50927a3f
|
https://github.com/z7zmey/php-parser/blob/394f8821001f38fe5b4c4aaffd4fa20e50927a3f/node/expr/n_static_property_fetch.go#L19-L25
|
6,008 |
z7zmey/php-parser
|
node/stmt/n_class_method.go
|
NewClassMethod
|
func NewClassMethod(MethodName node.Node, Modifiers []node.Node, ReturnsRef bool, Params []node.Node, ReturnType node.Node, Stmt node.Node, PhpDocComment string) *ClassMethod {
return &ClassMethod{
FreeFloating: nil,
ReturnsRef: ReturnsRef,
PhpDocComment: PhpDocComment,
MethodName: MethodName,
Modifiers: Modifiers,
Params: Params,
ReturnType: ReturnType,
Stmt: Stmt,
}
}
|
go
|
func NewClassMethod(MethodName node.Node, Modifiers []node.Node, ReturnsRef bool, Params []node.Node, ReturnType node.Node, Stmt node.Node, PhpDocComment string) *ClassMethod {
return &ClassMethod{
FreeFloating: nil,
ReturnsRef: ReturnsRef,
PhpDocComment: PhpDocComment,
MethodName: MethodName,
Modifiers: Modifiers,
Params: Params,
ReturnType: ReturnType,
Stmt: Stmt,
}
}
|
[
"func",
"NewClassMethod",
"(",
"MethodName",
"node",
".",
"Node",
",",
"Modifiers",
"[",
"]",
"node",
".",
"Node",
",",
"ReturnsRef",
"bool",
",",
"Params",
"[",
"]",
"node",
".",
"Node",
",",
"ReturnType",
"node",
".",
"Node",
",",
"Stmt",
"node",
".",
"Node",
",",
"PhpDocComment",
"string",
")",
"*",
"ClassMethod",
"{",
"return",
"&",
"ClassMethod",
"{",
"FreeFloating",
":",
"nil",
",",
"ReturnsRef",
":",
"ReturnsRef",
",",
"PhpDocComment",
":",
"PhpDocComment",
",",
"MethodName",
":",
"MethodName",
",",
"Modifiers",
":",
"Modifiers",
",",
"Params",
":",
"Params",
",",
"ReturnType",
":",
"ReturnType",
",",
"Stmt",
":",
"Stmt",
",",
"}",
"\n",
"}"
] |
// NewClassMethod node constructor
|
[
"NewClassMethod",
"node",
"constructor"
] |
394f8821001f38fe5b4c4aaffd4fa20e50927a3f
|
https://github.com/z7zmey/php-parser/blob/394f8821001f38fe5b4c4aaffd4fa20e50927a3f/node/stmt/n_class_method.go#L24-L35
|
6,009 |
z7zmey/php-parser
|
node/stmt/n_break.go
|
NewBreak
|
func NewBreak(Expr node.Node) *Break {
return &Break{
FreeFloating: nil,
Expr: Expr,
}
}
|
go
|
func NewBreak(Expr node.Node) *Break {
return &Break{
FreeFloating: nil,
Expr: Expr,
}
}
|
[
"func",
"NewBreak",
"(",
"Expr",
"node",
".",
"Node",
")",
"*",
"Break",
"{",
"return",
"&",
"Break",
"{",
"FreeFloating",
":",
"nil",
",",
"Expr",
":",
"Expr",
",",
"}",
"\n",
"}"
] |
// NewBreak node constructor
|
[
"NewBreak",
"node",
"constructor"
] |
394f8821001f38fe5b4c4aaffd4fa20e50927a3f
|
https://github.com/z7zmey/php-parser/blob/394f8821001f38fe5b4c4aaffd4fa20e50927a3f/node/stmt/n_break.go#L18-L23
|
6,010 |
z7zmey/php-parser
|
node/expr/binary/n_greater_or_equal.go
|
NewGreaterOrEqual
|
func NewGreaterOrEqual(Variable node.Node, Expression node.Node) *GreaterOrEqual {
return &GreaterOrEqual{
FreeFloating: nil,
Left: Variable,
Right: Expression,
}
}
|
go
|
func NewGreaterOrEqual(Variable node.Node, Expression node.Node) *GreaterOrEqual {
return &GreaterOrEqual{
FreeFloating: nil,
Left: Variable,
Right: Expression,
}
}
|
[
"func",
"NewGreaterOrEqual",
"(",
"Variable",
"node",
".",
"Node",
",",
"Expression",
"node",
".",
"Node",
")",
"*",
"GreaterOrEqual",
"{",
"return",
"&",
"GreaterOrEqual",
"{",
"FreeFloating",
":",
"nil",
",",
"Left",
":",
"Variable",
",",
"Right",
":",
"Expression",
",",
"}",
"\n",
"}"
] |
// NewGreaterOrEqual node constructor
|
[
"NewGreaterOrEqual",
"node",
"constructor"
] |
394f8821001f38fe5b4c4aaffd4fa20e50927a3f
|
https://github.com/z7zmey/php-parser/blob/394f8821001f38fe5b4c4aaffd4fa20e50927a3f/node/expr/binary/n_greater_or_equal.go#L19-L25
|
6,011 |
z7zmey/php-parser
|
node/expr/cast/n_cast_int.go
|
NewInt
|
func NewInt(Expr node.Node) *Int {
return &Int{
FreeFloating: nil,
Expr: Expr,
}
}
|
go
|
func NewInt(Expr node.Node) *Int {
return &Int{
FreeFloating: nil,
Expr: Expr,
}
}
|
[
"func",
"NewInt",
"(",
"Expr",
"node",
".",
"Node",
")",
"*",
"Int",
"{",
"return",
"&",
"Int",
"{",
"FreeFloating",
":",
"nil",
",",
"Expr",
":",
"Expr",
",",
"}",
"\n",
"}"
] |
// NewInt node constructor
|
[
"NewInt",
"node",
"constructor"
] |
394f8821001f38fe5b4c4aaffd4fa20e50927a3f
|
https://github.com/z7zmey/php-parser/blob/394f8821001f38fe5b4c4aaffd4fa20e50927a3f/node/expr/cast/n_cast_int.go#L18-L23
|
6,012 |
z7zmey/php-parser
|
node/expr/n_closure.go
|
NewClosure
|
func NewClosure(Params []node.Node, ClosureUse *ClosureUse, ReturnType node.Node, Stmts []node.Node, Static bool, ReturnsRef bool, PhpDocComment string) *Closure {
return &Closure{
FreeFloating: nil,
ReturnsRef: ReturnsRef,
Static: Static,
PhpDocComment: PhpDocComment,
Params: Params,
ClosureUse: ClosureUse,
ReturnType: ReturnType,
Stmts: Stmts,
}
}
|
go
|
func NewClosure(Params []node.Node, ClosureUse *ClosureUse, ReturnType node.Node, Stmts []node.Node, Static bool, ReturnsRef bool, PhpDocComment string) *Closure {
return &Closure{
FreeFloating: nil,
ReturnsRef: ReturnsRef,
Static: Static,
PhpDocComment: PhpDocComment,
Params: Params,
ClosureUse: ClosureUse,
ReturnType: ReturnType,
Stmts: Stmts,
}
}
|
[
"func",
"NewClosure",
"(",
"Params",
"[",
"]",
"node",
".",
"Node",
",",
"ClosureUse",
"*",
"ClosureUse",
",",
"ReturnType",
"node",
".",
"Node",
",",
"Stmts",
"[",
"]",
"node",
".",
"Node",
",",
"Static",
"bool",
",",
"ReturnsRef",
"bool",
",",
"PhpDocComment",
"string",
")",
"*",
"Closure",
"{",
"return",
"&",
"Closure",
"{",
"FreeFloating",
":",
"nil",
",",
"ReturnsRef",
":",
"ReturnsRef",
",",
"Static",
":",
"Static",
",",
"PhpDocComment",
":",
"PhpDocComment",
",",
"Params",
":",
"Params",
",",
"ClosureUse",
":",
"ClosureUse",
",",
"ReturnType",
":",
"ReturnType",
",",
"Stmts",
":",
"Stmts",
",",
"}",
"\n",
"}"
] |
// NewClosure node constructor
|
[
"NewClosure",
"node",
"constructor"
] |
394f8821001f38fe5b4c4aaffd4fa20e50927a3f
|
https://github.com/z7zmey/php-parser/blob/394f8821001f38fe5b4c4aaffd4fa20e50927a3f/node/expr/n_closure.go#L24-L35
|
6,013 |
z7zmey/php-parser
|
node/expr/n_closure.go
|
Attributes
|
func (n *Closure) Attributes() map[string]interface{} {
return map[string]interface{}{
"ReturnsRef": n.ReturnsRef,
"Static": n.Static,
"PhpDocComment": n.PhpDocComment,
}
}
|
go
|
func (n *Closure) Attributes() map[string]interface{} {
return map[string]interface{}{
"ReturnsRef": n.ReturnsRef,
"Static": n.Static,
"PhpDocComment": n.PhpDocComment,
}
}
|
[
"func",
"(",
"n",
"*",
"Closure",
")",
"Attributes",
"(",
")",
"map",
"[",
"string",
"]",
"interface",
"{",
"}",
"{",
"return",
"map",
"[",
"string",
"]",
"interface",
"{",
"}",
"{",
"\"",
"\"",
":",
"n",
".",
"ReturnsRef",
",",
"\"",
"\"",
":",
"n",
".",
"Static",
",",
"\"",
"\"",
":",
"n",
".",
"PhpDocComment",
",",
"}",
"\n",
"}"
] |
// Attributes returns node attributes as map
|
[
"Attributes",
"returns",
"node",
"attributes",
"as",
"map"
] |
394f8821001f38fe5b4c4aaffd4fa20e50927a3f
|
https://github.com/z7zmey/php-parser/blob/394f8821001f38fe5b4c4aaffd4fa20e50927a3f/node/expr/n_closure.go#L52-L58
|
6,014 |
z7zmey/php-parser
|
node/stmt/n_use.go
|
NewUse
|
func NewUse(UseType node.Node, use node.Node, Alias node.Node) *Use {
return &Use{
FreeFloating: nil,
UseType: UseType,
Use: use,
Alias: Alias,
}
}
|
go
|
func NewUse(UseType node.Node, use node.Node, Alias node.Node) *Use {
return &Use{
FreeFloating: nil,
UseType: UseType,
Use: use,
Alias: Alias,
}
}
|
[
"func",
"NewUse",
"(",
"UseType",
"node",
".",
"Node",
",",
"use",
"node",
".",
"Node",
",",
"Alias",
"node",
".",
"Node",
")",
"*",
"Use",
"{",
"return",
"&",
"Use",
"{",
"FreeFloating",
":",
"nil",
",",
"UseType",
":",
"UseType",
",",
"Use",
":",
"use",
",",
"Alias",
":",
"Alias",
",",
"}",
"\n",
"}"
] |
// NewUse node constructor
|
[
"NewUse",
"node",
"constructor"
] |
394f8821001f38fe5b4c4aaffd4fa20e50927a3f
|
https://github.com/z7zmey/php-parser/blob/394f8821001f38fe5b4c4aaffd4fa20e50927a3f/node/stmt/n_use.go#L20-L27
|
6,015 |
z7zmey/php-parser
|
node/expr/n_print.go
|
NewPrint
|
func NewPrint(Expression node.Node) *Print {
return &Print{
FreeFloating: nil,
Expr: Expression,
}
}
|
go
|
func NewPrint(Expression node.Node) *Print {
return &Print{
FreeFloating: nil,
Expr: Expression,
}
}
|
[
"func",
"NewPrint",
"(",
"Expression",
"node",
".",
"Node",
")",
"*",
"Print",
"{",
"return",
"&",
"Print",
"{",
"FreeFloating",
":",
"nil",
",",
"Expr",
":",
"Expression",
",",
"}",
"\n",
"}"
] |
// NewPrint node constructor
|
[
"NewPrint",
"node",
"constructor"
] |
394f8821001f38fe5b4c4aaffd4fa20e50927a3f
|
https://github.com/z7zmey/php-parser/blob/394f8821001f38fe5b4c4aaffd4fa20e50927a3f/node/expr/n_print.go#L18-L23
|
6,016 |
z7zmey/php-parser
|
node/n_argument.go
|
NewArgument
|
func NewArgument(Expression Node, Variadic bool, IsReference bool) *Argument {
return &Argument{
FreeFloating: nil,
Variadic: Variadic,
IsReference: IsReference,
Expr: Expression,
}
}
|
go
|
func NewArgument(Expression Node, Variadic bool, IsReference bool) *Argument {
return &Argument{
FreeFloating: nil,
Variadic: Variadic,
IsReference: IsReference,
Expr: Expression,
}
}
|
[
"func",
"NewArgument",
"(",
"Expression",
"Node",
",",
"Variadic",
"bool",
",",
"IsReference",
"bool",
")",
"*",
"Argument",
"{",
"return",
"&",
"Argument",
"{",
"FreeFloating",
":",
"nil",
",",
"Variadic",
":",
"Variadic",
",",
"IsReference",
":",
"IsReference",
",",
"Expr",
":",
"Expression",
",",
"}",
"\n",
"}"
] |
// NewArgument node constructor
|
[
"NewArgument",
"node",
"constructor"
] |
394f8821001f38fe5b4c4aaffd4fa20e50927a3f
|
https://github.com/z7zmey/php-parser/blob/394f8821001f38fe5b4c4aaffd4fa20e50927a3f/node/n_argument.go#L19-L26
|
6,017 |
z7zmey/php-parser
|
node/expr/n_include_once.go
|
NewIncludeOnce
|
func NewIncludeOnce(Expression node.Node) *IncludeOnce {
return &IncludeOnce{
FreeFloating: nil,
Expr: Expression,
}
}
|
go
|
func NewIncludeOnce(Expression node.Node) *IncludeOnce {
return &IncludeOnce{
FreeFloating: nil,
Expr: Expression,
}
}
|
[
"func",
"NewIncludeOnce",
"(",
"Expression",
"node",
".",
"Node",
")",
"*",
"IncludeOnce",
"{",
"return",
"&",
"IncludeOnce",
"{",
"FreeFloating",
":",
"nil",
",",
"Expr",
":",
"Expression",
",",
"}",
"\n",
"}"
] |
// NewIncludeOnce node constructor
|
[
"NewIncludeOnce",
"node",
"constructor"
] |
394f8821001f38fe5b4c4aaffd4fa20e50927a3f
|
https://github.com/z7zmey/php-parser/blob/394f8821001f38fe5b4c4aaffd4fa20e50927a3f/node/expr/n_include_once.go#L18-L23
|
6,018 |
z7zmey/php-parser
|
node/stmt/n_static.go
|
NewStatic
|
func NewStatic(Vars []node.Node) *Static {
return &Static{
FreeFloating: nil,
Vars: Vars,
}
}
|
go
|
func NewStatic(Vars []node.Node) *Static {
return &Static{
FreeFloating: nil,
Vars: Vars,
}
}
|
[
"func",
"NewStatic",
"(",
"Vars",
"[",
"]",
"node",
".",
"Node",
")",
"*",
"Static",
"{",
"return",
"&",
"Static",
"{",
"FreeFloating",
":",
"nil",
",",
"Vars",
":",
"Vars",
",",
"}",
"\n",
"}"
] |
// NewStatic node constructor
|
[
"NewStatic",
"node",
"constructor"
] |
394f8821001f38fe5b4c4aaffd4fa20e50927a3f
|
https://github.com/z7zmey/php-parser/blob/394f8821001f38fe5b4c4aaffd4fa20e50927a3f/node/stmt/n_static.go#L18-L23
|
6,019 |
z7zmey/php-parser
|
node/expr/n_yield.go
|
NewYield
|
func NewYield(Key node.Node, Value node.Node) *Yield {
return &Yield{
FreeFloating: nil,
Key: Key,
Value: Value,
}
}
|
go
|
func NewYield(Key node.Node, Value node.Node) *Yield {
return &Yield{
FreeFloating: nil,
Key: Key,
Value: Value,
}
}
|
[
"func",
"NewYield",
"(",
"Key",
"node",
".",
"Node",
",",
"Value",
"node",
".",
"Node",
")",
"*",
"Yield",
"{",
"return",
"&",
"Yield",
"{",
"FreeFloating",
":",
"nil",
",",
"Key",
":",
"Key",
",",
"Value",
":",
"Value",
",",
"}",
"\n",
"}"
] |
// NewYield node constructor
|
[
"NewYield",
"node",
"constructor"
] |
394f8821001f38fe5b4c4aaffd4fa20e50927a3f
|
https://github.com/z7zmey/php-parser/blob/394f8821001f38fe5b4c4aaffd4fa20e50927a3f/node/expr/n_yield.go#L19-L25
|
6,020 |
z7zmey/php-parser
|
node/expr/binary/n_shift_left.go
|
NewShiftLeft
|
func NewShiftLeft(Variable node.Node, Expression node.Node) *ShiftLeft {
return &ShiftLeft{
FreeFloating: nil,
Left: Variable,
Right: Expression,
}
}
|
go
|
func NewShiftLeft(Variable node.Node, Expression node.Node) *ShiftLeft {
return &ShiftLeft{
FreeFloating: nil,
Left: Variable,
Right: Expression,
}
}
|
[
"func",
"NewShiftLeft",
"(",
"Variable",
"node",
".",
"Node",
",",
"Expression",
"node",
".",
"Node",
")",
"*",
"ShiftLeft",
"{",
"return",
"&",
"ShiftLeft",
"{",
"FreeFloating",
":",
"nil",
",",
"Left",
":",
"Variable",
",",
"Right",
":",
"Expression",
",",
"}",
"\n",
"}"
] |
// NewShiftLeft node constructor
|
[
"NewShiftLeft",
"node",
"constructor"
] |
394f8821001f38fe5b4c4aaffd4fa20e50927a3f
|
https://github.com/z7zmey/php-parser/blob/394f8821001f38fe5b4c4aaffd4fa20e50927a3f/node/expr/binary/n_shift_left.go#L19-L25
|
6,021 |
z7zmey/php-parser
|
node/stmt/n_else.go
|
NewElse
|
func NewElse(Stmt node.Node) *Else {
return &Else{
FreeFloating: nil,
Stmt: Stmt,
}
}
|
go
|
func NewElse(Stmt node.Node) *Else {
return &Else{
FreeFloating: nil,
Stmt: Stmt,
}
}
|
[
"func",
"NewElse",
"(",
"Stmt",
"node",
".",
"Node",
")",
"*",
"Else",
"{",
"return",
"&",
"Else",
"{",
"FreeFloating",
":",
"nil",
",",
"Stmt",
":",
"Stmt",
",",
"}",
"\n",
"}"
] |
// NewElse node constructor
|
[
"NewElse",
"node",
"constructor"
] |
394f8821001f38fe5b4c4aaffd4fa20e50927a3f
|
https://github.com/z7zmey/php-parser/blob/394f8821001f38fe5b4c4aaffd4fa20e50927a3f/node/stmt/n_else.go#L18-L23
|
6,022 |
z7zmey/php-parser
|
node/expr/n_shell_exec.go
|
NewShellExec
|
func NewShellExec(Parts []node.Node) *ShellExec {
return &ShellExec{
FreeFloating: nil,
Parts: Parts,
}
}
|
go
|
func NewShellExec(Parts []node.Node) *ShellExec {
return &ShellExec{
FreeFloating: nil,
Parts: Parts,
}
}
|
[
"func",
"NewShellExec",
"(",
"Parts",
"[",
"]",
"node",
".",
"Node",
")",
"*",
"ShellExec",
"{",
"return",
"&",
"ShellExec",
"{",
"FreeFloating",
":",
"nil",
",",
"Parts",
":",
"Parts",
",",
"}",
"\n",
"}"
] |
// NewShellExec node constructor
|
[
"NewShellExec",
"node",
"constructor"
] |
394f8821001f38fe5b4c4aaffd4fa20e50927a3f
|
https://github.com/z7zmey/php-parser/blob/394f8821001f38fe5b4c4aaffd4fa20e50927a3f/node/expr/n_shell_exec.go#L18-L23
|
6,023 |
z7zmey/php-parser
|
node/expr/n_pre_inc.go
|
NewPreInc
|
func NewPreInc(Variable node.Node) *PreInc {
return &PreInc{
FreeFloating: nil,
Variable: Variable,
}
}
|
go
|
func NewPreInc(Variable node.Node) *PreInc {
return &PreInc{
FreeFloating: nil,
Variable: Variable,
}
}
|
[
"func",
"NewPreInc",
"(",
"Variable",
"node",
".",
"Node",
")",
"*",
"PreInc",
"{",
"return",
"&",
"PreInc",
"{",
"FreeFloating",
":",
"nil",
",",
"Variable",
":",
"Variable",
",",
"}",
"\n",
"}"
] |
// NewPreInc node constructor
|
[
"NewPreInc",
"node",
"constructor"
] |
394f8821001f38fe5b4c4aaffd4fa20e50927a3f
|
https://github.com/z7zmey/php-parser/blob/394f8821001f38fe5b4c4aaffd4fa20e50927a3f/node/expr/n_pre_inc.go#L18-L23
|
6,024 |
z7zmey/php-parser
|
node/expr/binary/n_plus.go
|
NewPlus
|
func NewPlus(Variable node.Node, Expression node.Node) *Plus {
return &Plus{
FreeFloating: nil,
Left: Variable,
Right: Expression,
}
}
|
go
|
func NewPlus(Variable node.Node, Expression node.Node) *Plus {
return &Plus{
FreeFloating: nil,
Left: Variable,
Right: Expression,
}
}
|
[
"func",
"NewPlus",
"(",
"Variable",
"node",
".",
"Node",
",",
"Expression",
"node",
".",
"Node",
")",
"*",
"Plus",
"{",
"return",
"&",
"Plus",
"{",
"FreeFloating",
":",
"nil",
",",
"Left",
":",
"Variable",
",",
"Right",
":",
"Expression",
",",
"}",
"\n",
"}"
] |
// NewPlus node constructor
|
[
"NewPlus",
"node",
"constructor"
] |
394f8821001f38fe5b4c4aaffd4fa20e50927a3f
|
https://github.com/z7zmey/php-parser/blob/394f8821001f38fe5b4c4aaffd4fa20e50927a3f/node/expr/binary/n_plus.go#L19-L25
|
6,025 |
z7zmey/php-parser
|
node/expr/cast/n_cast_bool.go
|
NewBool
|
func NewBool(Expr node.Node) *Bool {
return &Bool{
FreeFloating: nil,
Expr: Expr,
}
}
|
go
|
func NewBool(Expr node.Node) *Bool {
return &Bool{
FreeFloating: nil,
Expr: Expr,
}
}
|
[
"func",
"NewBool",
"(",
"Expr",
"node",
".",
"Node",
")",
"*",
"Bool",
"{",
"return",
"&",
"Bool",
"{",
"FreeFloating",
":",
"nil",
",",
"Expr",
":",
"Expr",
",",
"}",
"\n",
"}"
] |
// NewBool node constructor
|
[
"NewBool",
"node",
"constructor"
] |
394f8821001f38fe5b4c4aaffd4fa20e50927a3f
|
https://github.com/z7zmey/php-parser/blob/394f8821001f38fe5b4c4aaffd4fa20e50927a3f/node/expr/cast/n_cast_bool.go#L18-L23
|
6,026 |
z7zmey/php-parser
|
visitor/namespace_resolver.go
|
AddNamespacedName
|
func (nsr *NamespaceResolver) AddNamespacedName(nn node.Node, nodeName string) {
if nsr.Namespace.Namespace == "" {
nsr.ResolvedNames[nn] = nodeName
} else {
nsr.ResolvedNames[nn] = nsr.Namespace.Namespace + "\\" + nodeName
}
}
|
go
|
func (nsr *NamespaceResolver) AddNamespacedName(nn node.Node, nodeName string) {
if nsr.Namespace.Namespace == "" {
nsr.ResolvedNames[nn] = nodeName
} else {
nsr.ResolvedNames[nn] = nsr.Namespace.Namespace + "\\" + nodeName
}
}
|
[
"func",
"(",
"nsr",
"*",
"NamespaceResolver",
")",
"AddNamespacedName",
"(",
"nn",
"node",
".",
"Node",
",",
"nodeName",
"string",
")",
"{",
"if",
"nsr",
".",
"Namespace",
".",
"Namespace",
"==",
"\"",
"\"",
"{",
"nsr",
".",
"ResolvedNames",
"[",
"nn",
"]",
"=",
"nodeName",
"\n",
"}",
"else",
"{",
"nsr",
".",
"ResolvedNames",
"[",
"nn",
"]",
"=",
"nsr",
".",
"Namespace",
".",
"Namespace",
"+",
"\"",
"\\\\",
"\"",
"+",
"nodeName",
"\n",
"}",
"\n",
"}"
] |
// AddNamespacedName adds namespaced name by node
|
[
"AddNamespacedName",
"adds",
"namespaced",
"name",
"by",
"node"
] |
394f8821001f38fe5b4c4aaffd4fa20e50927a3f
|
https://github.com/z7zmey/php-parser/blob/394f8821001f38fe5b4c4aaffd4fa20e50927a3f/visitor/namespace_resolver.go#L231-L237
|
6,027 |
z7zmey/php-parser
|
visitor/namespace_resolver.go
|
ResolveName
|
func (nsr *NamespaceResolver) ResolveName(nameNode node.Node, aliasType string) {
resolved, err := nsr.Namespace.ResolveName(nameNode, aliasType)
if err == nil {
nsr.ResolvedNames[nameNode] = resolved
}
}
|
go
|
func (nsr *NamespaceResolver) ResolveName(nameNode node.Node, aliasType string) {
resolved, err := nsr.Namespace.ResolveName(nameNode, aliasType)
if err == nil {
nsr.ResolvedNames[nameNode] = resolved
}
}
|
[
"func",
"(",
"nsr",
"*",
"NamespaceResolver",
")",
"ResolveName",
"(",
"nameNode",
"node",
".",
"Node",
",",
"aliasType",
"string",
")",
"{",
"resolved",
",",
"err",
":=",
"nsr",
".",
"Namespace",
".",
"ResolveName",
"(",
"nameNode",
",",
"aliasType",
")",
"\n",
"if",
"err",
"==",
"nil",
"{",
"nsr",
".",
"ResolvedNames",
"[",
"nameNode",
"]",
"=",
"resolved",
"\n",
"}",
"\n",
"}"
] |
// ResolveName adds a resolved fully qualified name by node
|
[
"ResolveName",
"adds",
"a",
"resolved",
"fully",
"qualified",
"name",
"by",
"node"
] |
394f8821001f38fe5b4c4aaffd4fa20e50927a3f
|
https://github.com/z7zmey/php-parser/blob/394f8821001f38fe5b4c4aaffd4fa20e50927a3f/visitor/namespace_resolver.go#L240-L245
|
6,028 |
z7zmey/php-parser
|
visitor/namespace_resolver.go
|
ResolveType
|
func (nsr *NamespaceResolver) ResolveType(n node.Node) {
switch nn := n.(type) {
case *node.Nullable:
nsr.ResolveType(nn.Expr)
case name.Names:
nsr.ResolveName(n, "")
}
}
|
go
|
func (nsr *NamespaceResolver) ResolveType(n node.Node) {
switch nn := n.(type) {
case *node.Nullable:
nsr.ResolveType(nn.Expr)
case name.Names:
nsr.ResolveName(n, "")
}
}
|
[
"func",
"(",
"nsr",
"*",
"NamespaceResolver",
")",
"ResolveType",
"(",
"n",
"node",
".",
"Node",
")",
"{",
"switch",
"nn",
":=",
"n",
".",
"(",
"type",
")",
"{",
"case",
"*",
"node",
".",
"Nullable",
":",
"nsr",
".",
"ResolveType",
"(",
"nn",
".",
"Expr",
")",
"\n",
"case",
"name",
".",
"Names",
":",
"nsr",
".",
"ResolveName",
"(",
"n",
",",
"\"",
"\"",
")",
"\n",
"}",
"\n",
"}"
] |
// ResolveType adds a resolved fully qualified type name
|
[
"ResolveType",
"adds",
"a",
"resolved",
"fully",
"qualified",
"type",
"name"
] |
394f8821001f38fe5b4c4aaffd4fa20e50927a3f
|
https://github.com/z7zmey/php-parser/blob/394f8821001f38fe5b4c4aaffd4fa20e50927a3f/visitor/namespace_resolver.go#L248-L255
|
6,029 |
z7zmey/php-parser
|
visitor/namespace_resolver.go
|
ResolveName
|
func (ns *Namespace) ResolveName(nameNode node.Node, aliasType string) (string, error) {
switch n := nameNode.(type) {
case *name.FullyQualified:
// Fully qualifid name is already resolved
return concatNameParts(n.Parts), nil
case *name.Relative:
if ns.Namespace == "" {
return concatNameParts(n.Parts), nil
}
return ns.Namespace + "\\" + concatNameParts(n.Parts), nil
case *name.Name:
if aliasType == "const" && len(n.Parts) == 1 {
part := strings.ToLower(n.Parts[0].(*name.NamePart).Value)
if part == "true" || part == "false" || part == "null" {
return part, nil
}
}
if aliasType == "" && len(n.Parts) == 1 {
part := 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":
fallthrough
case "iterable":
fallthrough
case "object":
return part, nil
}
}
aliasName, err := ns.ResolveAlias(nameNode, aliasType)
if err != nil {
// resolve as relative name if alias not found
if ns.Namespace == "" {
return concatNameParts(n.Parts), nil
}
return ns.Namespace + "\\" + concatNameParts(n.Parts), nil
}
if len(n.Parts) > 1 {
// if name qualified, replace first part by alias
return aliasName + "\\" + concatNameParts(n.Parts[1:]), nil
}
return aliasName, nil
}
return "", errors.New("must be instance of name.Names")
}
|
go
|
func (ns *Namespace) ResolveName(nameNode node.Node, aliasType string) (string, error) {
switch n := nameNode.(type) {
case *name.FullyQualified:
// Fully qualifid name is already resolved
return concatNameParts(n.Parts), nil
case *name.Relative:
if ns.Namespace == "" {
return concatNameParts(n.Parts), nil
}
return ns.Namespace + "\\" + concatNameParts(n.Parts), nil
case *name.Name:
if aliasType == "const" && len(n.Parts) == 1 {
part := strings.ToLower(n.Parts[0].(*name.NamePart).Value)
if part == "true" || part == "false" || part == "null" {
return part, nil
}
}
if aliasType == "" && len(n.Parts) == 1 {
part := 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":
fallthrough
case "iterable":
fallthrough
case "object":
return part, nil
}
}
aliasName, err := ns.ResolveAlias(nameNode, aliasType)
if err != nil {
// resolve as relative name if alias not found
if ns.Namespace == "" {
return concatNameParts(n.Parts), nil
}
return ns.Namespace + "\\" + concatNameParts(n.Parts), nil
}
if len(n.Parts) > 1 {
// if name qualified, replace first part by alias
return aliasName + "\\" + concatNameParts(n.Parts[1:]), nil
}
return aliasName, nil
}
return "", errors.New("must be instance of name.Names")
}
|
[
"func",
"(",
"ns",
"*",
"Namespace",
")",
"ResolveName",
"(",
"nameNode",
"node",
".",
"Node",
",",
"aliasType",
"string",
")",
"(",
"string",
",",
"error",
")",
"{",
"switch",
"n",
":=",
"nameNode",
".",
"(",
"type",
")",
"{",
"case",
"*",
"name",
".",
"FullyQualified",
":",
"// Fully qualifid name is already resolved",
"return",
"concatNameParts",
"(",
"n",
".",
"Parts",
")",
",",
"nil",
"\n\n",
"case",
"*",
"name",
".",
"Relative",
":",
"if",
"ns",
".",
"Namespace",
"==",
"\"",
"\"",
"{",
"return",
"concatNameParts",
"(",
"n",
".",
"Parts",
")",
",",
"nil",
"\n",
"}",
"\n",
"return",
"ns",
".",
"Namespace",
"+",
"\"",
"\\\\",
"\"",
"+",
"concatNameParts",
"(",
"n",
".",
"Parts",
")",
",",
"nil",
"\n\n",
"case",
"*",
"name",
".",
"Name",
":",
"if",
"aliasType",
"==",
"\"",
"\"",
"&&",
"len",
"(",
"n",
".",
"Parts",
")",
"==",
"1",
"{",
"part",
":=",
"strings",
".",
"ToLower",
"(",
"n",
".",
"Parts",
"[",
"0",
"]",
".",
"(",
"*",
"name",
".",
"NamePart",
")",
".",
"Value",
")",
"\n",
"if",
"part",
"==",
"\"",
"\"",
"||",
"part",
"==",
"\"",
"\"",
"||",
"part",
"==",
"\"",
"\"",
"{",
"return",
"part",
",",
"nil",
"\n",
"}",
"\n",
"}",
"\n\n",
"if",
"aliasType",
"==",
"\"",
"\"",
"&&",
"len",
"(",
"n",
".",
"Parts",
")",
"==",
"1",
"{",
"part",
":=",
"strings",
".",
"ToLower",
"(",
"n",
".",
"Parts",
"[",
"0",
"]",
".",
"(",
"*",
"name",
".",
"NamePart",
")",
".",
"Value",
")",
"\n\n",
"switch",
"part",
"{",
"case",
"\"",
"\"",
":",
"fallthrough",
"\n",
"case",
"\"",
"\"",
":",
"fallthrough",
"\n",
"case",
"\"",
"\"",
":",
"fallthrough",
"\n",
"case",
"\"",
"\"",
":",
"fallthrough",
"\n",
"case",
"\"",
"\"",
":",
"fallthrough",
"\n",
"case",
"\"",
"\"",
":",
"fallthrough",
"\n",
"case",
"\"",
"\"",
":",
"fallthrough",
"\n",
"case",
"\"",
"\"",
":",
"fallthrough",
"\n",
"case",
"\"",
"\"",
":",
"fallthrough",
"\n",
"case",
"\"",
"\"",
":",
"return",
"part",
",",
"nil",
"\n",
"}",
"\n",
"}",
"\n\n",
"aliasName",
",",
"err",
":=",
"ns",
".",
"ResolveAlias",
"(",
"nameNode",
",",
"aliasType",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"// resolve as relative name if alias not found",
"if",
"ns",
".",
"Namespace",
"==",
"\"",
"\"",
"{",
"return",
"concatNameParts",
"(",
"n",
".",
"Parts",
")",
",",
"nil",
"\n",
"}",
"\n",
"return",
"ns",
".",
"Namespace",
"+",
"\"",
"\\\\",
"\"",
"+",
"concatNameParts",
"(",
"n",
".",
"Parts",
")",
",",
"nil",
"\n",
"}",
"\n\n",
"if",
"len",
"(",
"n",
".",
"Parts",
")",
">",
"1",
"{",
"// if name qualified, replace first part by alias",
"return",
"aliasName",
"+",
"\"",
"\\\\",
"\"",
"+",
"concatNameParts",
"(",
"n",
".",
"Parts",
"[",
"1",
":",
"]",
")",
",",
"nil",
"\n",
"}",
"\n\n",
"return",
"aliasName",
",",
"nil",
"\n",
"}",
"\n\n",
"return",
"\"",
"\"",
",",
"errors",
".",
"New",
"(",
"\"",
"\"",
")",
"\n",
"}"
] |
// ResolveName returns a resolved fully qualified name
|
[
"ResolveName",
"returns",
"a",
"resolved",
"fully",
"qualified",
"name"
] |
394f8821001f38fe5b4c4aaffd4fa20e50927a3f
|
https://github.com/z7zmey/php-parser/blob/394f8821001f38fe5b4c4aaffd4fa20e50927a3f/visitor/namespace_resolver.go#L287-L352
|
6,030 |
z7zmey/php-parser
|
visitor/namespace_resolver.go
|
ResolveAlias
|
func (ns *Namespace) ResolveAlias(nameNode node.Node, aliasType string) (string, error) {
aliasType = strings.ToLower(aliasType)
nameParts := nameNode.(*name.Name).Parts
firstPartStr := nameParts[0].(*name.NamePart).Value
if len(nameParts) > 1 { // resolve aliases for 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 "", errors.New("Not found")
}
return aliasName, nil
}
|
go
|
func (ns *Namespace) ResolveAlias(nameNode node.Node, aliasType string) (string, error) {
aliasType = strings.ToLower(aliasType)
nameParts := nameNode.(*name.Name).Parts
firstPartStr := nameParts[0].(*name.NamePart).Value
if len(nameParts) > 1 { // resolve aliases for 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 "", errors.New("Not found")
}
return aliasName, nil
}
|
[
"func",
"(",
"ns",
"*",
"Namespace",
")",
"ResolveAlias",
"(",
"nameNode",
"node",
".",
"Node",
",",
"aliasType",
"string",
")",
"(",
"string",
",",
"error",
")",
"{",
"aliasType",
"=",
"strings",
".",
"ToLower",
"(",
"aliasType",
")",
"\n",
"nameParts",
":=",
"nameNode",
".",
"(",
"*",
"name",
".",
"Name",
")",
".",
"Parts",
"\n\n",
"firstPartStr",
":=",
"nameParts",
"[",
"0",
"]",
".",
"(",
"*",
"name",
".",
"NamePart",
")",
".",
"Value",
"\n\n",
"if",
"len",
"(",
"nameParts",
")",
">",
"1",
"{",
"// resolve aliases for qualified names, always against class alias type",
"firstPartStr",
"=",
"strings",
".",
"ToLower",
"(",
"firstPartStr",
")",
"\n",
"aliasType",
"=",
"\"",
"\"",
"\n",
"}",
"else",
"{",
"if",
"aliasType",
"!=",
"\"",
"\"",
"{",
"// constants are case-sensitive",
"firstPartStr",
"=",
"strings",
".",
"ToLower",
"(",
"firstPartStr",
")",
"\n",
"}",
"\n",
"}",
"\n\n",
"aliasName",
",",
"ok",
":=",
"ns",
".",
"Aliases",
"[",
"aliasType",
"]",
"[",
"firstPartStr",
"]",
"\n",
"if",
"!",
"ok",
"{",
"return",
"\"",
"\"",
",",
"errors",
".",
"New",
"(",
"\"",
"\"",
")",
"\n",
"}",
"\n\n",
"return",
"aliasName",
",",
"nil",
"\n",
"}"
] |
// ResolveAlias returns alias or error if not found
|
[
"ResolveAlias",
"returns",
"alias",
"or",
"error",
"if",
"not",
"found"
] |
394f8821001f38fe5b4c4aaffd4fa20e50927a3f
|
https://github.com/z7zmey/php-parser/blob/394f8821001f38fe5b4c4aaffd4fa20e50927a3f/visitor/namespace_resolver.go#L355-L376
|
6,031 |
z7zmey/php-parser
|
node/stmt/n_trait_use_alias.go
|
NewTraitUseAlias
|
func NewTraitUseAlias(Ref node.Node, Modifier node.Node, Alias node.Node) *TraitUseAlias {
return &TraitUseAlias{
FreeFloating: nil,
Ref: Ref,
Modifier: Modifier,
Alias: Alias,
}
}
|
go
|
func NewTraitUseAlias(Ref node.Node, Modifier node.Node, Alias node.Node) *TraitUseAlias {
return &TraitUseAlias{
FreeFloating: nil,
Ref: Ref,
Modifier: Modifier,
Alias: Alias,
}
}
|
[
"func",
"NewTraitUseAlias",
"(",
"Ref",
"node",
".",
"Node",
",",
"Modifier",
"node",
".",
"Node",
",",
"Alias",
"node",
".",
"Node",
")",
"*",
"TraitUseAlias",
"{",
"return",
"&",
"TraitUseAlias",
"{",
"FreeFloating",
":",
"nil",
",",
"Ref",
":",
"Ref",
",",
"Modifier",
":",
"Modifier",
",",
"Alias",
":",
"Alias",
",",
"}",
"\n",
"}"
] |
// NewTraitUseAlias node constructor
|
[
"NewTraitUseAlias",
"node",
"constructor"
] |
394f8821001f38fe5b4c4aaffd4fa20e50927a3f
|
https://github.com/z7zmey/php-parser/blob/394f8821001f38fe5b4c4aaffd4fa20e50927a3f/node/stmt/n_trait_use_alias.go#L20-L27
|
6,032 |
z7zmey/php-parser
|
node/expr/binary/n_equal.go
|
NewEqual
|
func NewEqual(Variable node.Node, Expression node.Node) *Equal {
return &Equal{
FreeFloating: nil,
Left: Variable,
Right: Expression,
}
}
|
go
|
func NewEqual(Variable node.Node, Expression node.Node) *Equal {
return &Equal{
FreeFloating: nil,
Left: Variable,
Right: Expression,
}
}
|
[
"func",
"NewEqual",
"(",
"Variable",
"node",
".",
"Node",
",",
"Expression",
"node",
".",
"Node",
")",
"*",
"Equal",
"{",
"return",
"&",
"Equal",
"{",
"FreeFloating",
":",
"nil",
",",
"Left",
":",
"Variable",
",",
"Right",
":",
"Expression",
",",
"}",
"\n",
"}"
] |
// NewEqual node constructor
|
[
"NewEqual",
"node",
"constructor"
] |
394f8821001f38fe5b4c4aaffd4fa20e50927a3f
|
https://github.com/z7zmey/php-parser/blob/394f8821001f38fe5b4c4aaffd4fa20e50927a3f/node/expr/binary/n_equal.go#L19-L25
|
6,033 |
z7zmey/php-parser
|
node/expr/n_clone.go
|
NewClone
|
func NewClone(Expression node.Node) *Clone {
return &Clone{
FreeFloating: nil,
Expr: Expression,
}
}
|
go
|
func NewClone(Expression node.Node) *Clone {
return &Clone{
FreeFloating: nil,
Expr: Expression,
}
}
|
[
"func",
"NewClone",
"(",
"Expression",
"node",
".",
"Node",
")",
"*",
"Clone",
"{",
"return",
"&",
"Clone",
"{",
"FreeFloating",
":",
"nil",
",",
"Expr",
":",
"Expression",
",",
"}",
"\n",
"}"
] |
// NewClone node constructor
|
[
"NewClone",
"node",
"constructor"
] |
394f8821001f38fe5b4c4aaffd4fa20e50927a3f
|
https://github.com/z7zmey/php-parser/blob/394f8821001f38fe5b4c4aaffd4fa20e50927a3f/node/expr/n_clone.go#L18-L23
|
6,034 |
z7zmey/php-parser
|
node/expr/binary/n_mul.go
|
NewMul
|
func NewMul(Variable node.Node, Expression node.Node) *Mul {
return &Mul{
FreeFloating: nil,
Left: Variable,
Right: Expression,
}
}
|
go
|
func NewMul(Variable node.Node, Expression node.Node) *Mul {
return &Mul{
FreeFloating: nil,
Left: Variable,
Right: Expression,
}
}
|
[
"func",
"NewMul",
"(",
"Variable",
"node",
".",
"Node",
",",
"Expression",
"node",
".",
"Node",
")",
"*",
"Mul",
"{",
"return",
"&",
"Mul",
"{",
"FreeFloating",
":",
"nil",
",",
"Left",
":",
"Variable",
",",
"Right",
":",
"Expression",
",",
"}",
"\n",
"}"
] |
// NewMul node constructor
|
[
"NewMul",
"node",
"constructor"
] |
394f8821001f38fe5b4c4aaffd4fa20e50927a3f
|
https://github.com/z7zmey/php-parser/blob/394f8821001f38fe5b4c4aaffd4fa20e50927a3f/node/expr/binary/n_mul.go#L19-L25
|
6,035 |
z7zmey/php-parser
|
node/expr/n_eval.go
|
NewEval
|
func NewEval(Expression node.Node) *Eval {
return &Eval{
FreeFloating: nil,
Expr: Expression,
}
}
|
go
|
func NewEval(Expression node.Node) *Eval {
return &Eval{
FreeFloating: nil,
Expr: Expression,
}
}
|
[
"func",
"NewEval",
"(",
"Expression",
"node",
".",
"Node",
")",
"*",
"Eval",
"{",
"return",
"&",
"Eval",
"{",
"FreeFloating",
":",
"nil",
",",
"Expr",
":",
"Expression",
",",
"}",
"\n",
"}"
] |
// NewEval node constructor
|
[
"NewEval",
"node",
"constructor"
] |
394f8821001f38fe5b4c4aaffd4fa20e50927a3f
|
https://github.com/z7zmey/php-parser/blob/394f8821001f38fe5b4c4aaffd4fa20e50927a3f/node/expr/n_eval.go#L18-L23
|
6,036 |
z7zmey/php-parser
|
node/stmt/n_case_list.go
|
NewCaseList
|
func NewCaseList(Cases []node.Node) *CaseList {
return &CaseList{
FreeFloating: nil,
Cases: Cases,
}
}
|
go
|
func NewCaseList(Cases []node.Node) *CaseList {
return &CaseList{
FreeFloating: nil,
Cases: Cases,
}
}
|
[
"func",
"NewCaseList",
"(",
"Cases",
"[",
"]",
"node",
".",
"Node",
")",
"*",
"CaseList",
"{",
"return",
"&",
"CaseList",
"{",
"FreeFloating",
":",
"nil",
",",
"Cases",
":",
"Cases",
",",
"}",
"\n",
"}"
] |
// NewCaseList node constructor
|
[
"NewCaseList",
"node",
"constructor"
] |
394f8821001f38fe5b4c4aaffd4fa20e50927a3f
|
https://github.com/z7zmey/php-parser/blob/394f8821001f38fe5b4c4aaffd4fa20e50927a3f/node/stmt/n_case_list.go#L18-L23
|
6,037 |
z7zmey/php-parser
|
scanner/lexer.go
|
Rune2Class
|
func Rune2Class(r rune) int {
if r >= 0 && r < 0x80 { // Keep ASCII as it is.
return int(r)
}
if unicode.IsLetter(r) {
return classUnicodeLeter
}
if unicode.IsDigit(r) {
return classUnicodeDigit
}
if unicode.IsGraphic(r) {
return classUnicodeGraphic
}
if r == lex.RuneEOF {
return int(r)
}
return classOther
}
|
go
|
func Rune2Class(r rune) int {
if r >= 0 && r < 0x80 { // Keep ASCII as it is.
return int(r)
}
if unicode.IsLetter(r) {
return classUnicodeLeter
}
if unicode.IsDigit(r) {
return classUnicodeDigit
}
if unicode.IsGraphic(r) {
return classUnicodeGraphic
}
if r == lex.RuneEOF {
return int(r)
}
return classOther
}
|
[
"func",
"Rune2Class",
"(",
"r",
"rune",
")",
"int",
"{",
"if",
"r",
">=",
"0",
"&&",
"r",
"<",
"0x80",
"{",
"// Keep ASCII as it is.",
"return",
"int",
"(",
"r",
")",
"\n",
"}",
"\n",
"if",
"unicode",
".",
"IsLetter",
"(",
"r",
")",
"{",
"return",
"classUnicodeLeter",
"\n",
"}",
"\n",
"if",
"unicode",
".",
"IsDigit",
"(",
"r",
")",
"{",
"return",
"classUnicodeDigit",
"\n",
"}",
"\n",
"if",
"unicode",
".",
"IsGraphic",
"(",
"r",
")",
"{",
"return",
"classUnicodeGraphic",
"\n",
"}",
"\n",
"if",
"r",
"==",
"lex",
".",
"RuneEOF",
"{",
"return",
"int",
"(",
"r",
")",
"\n",
"}",
"\n",
"return",
"classOther",
"\n",
"}"
] |
// Rune2Class returns the rune integer id
|
[
"Rune2Class",
"returns",
"the",
"rune",
"integer",
"id"
] |
394f8821001f38fe5b4c4aaffd4fa20e50927a3f
|
https://github.com/z7zmey/php-parser/blob/394f8821001f38fe5b4c4aaffd4fa20e50927a3f/scanner/lexer.go#L46-L63
|
6,038 |
z7zmey/php-parser
|
scanner/lexer.go
|
NewLexer
|
func NewLexer(src io.Reader, fName string) *Lexer {
file := t.NewFileSet().AddFile(fName, -1, 1<<31-3)
lx, err := lex.New(file, bufio.NewReader(src), lex.RuneClass(Rune2Class))
if err != nil {
panic(err)
}
return &Lexer{
Lexer: lx,
StateStack: []int{0},
PhpDocComment: "",
FreeFloating: nil,
heredocLabel: "",
tokenBytesBuf: &bytes.Buffer{},
TokenPool: &TokenPool{},
}
}
|
go
|
func NewLexer(src io.Reader, fName string) *Lexer {
file := t.NewFileSet().AddFile(fName, -1, 1<<31-3)
lx, err := lex.New(file, bufio.NewReader(src), lex.RuneClass(Rune2Class))
if err != nil {
panic(err)
}
return &Lexer{
Lexer: lx,
StateStack: []int{0},
PhpDocComment: "",
FreeFloating: nil,
heredocLabel: "",
tokenBytesBuf: &bytes.Buffer{},
TokenPool: &TokenPool{},
}
}
|
[
"func",
"NewLexer",
"(",
"src",
"io",
".",
"Reader",
",",
"fName",
"string",
")",
"*",
"Lexer",
"{",
"file",
":=",
"t",
".",
"NewFileSet",
"(",
")",
".",
"AddFile",
"(",
"fName",
",",
"-",
"1",
",",
"1",
"<<",
"31",
"-",
"3",
")",
"\n",
"lx",
",",
"err",
":=",
"lex",
".",
"New",
"(",
"file",
",",
"bufio",
".",
"NewReader",
"(",
"src",
")",
",",
"lex",
".",
"RuneClass",
"(",
"Rune2Class",
")",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"panic",
"(",
"err",
")",
"\n",
"}",
"\n\n",
"return",
"&",
"Lexer",
"{",
"Lexer",
":",
"lx",
",",
"StateStack",
":",
"[",
"]",
"int",
"{",
"0",
"}",
",",
"PhpDocComment",
":",
"\"",
"\"",
",",
"FreeFloating",
":",
"nil",
",",
"heredocLabel",
":",
"\"",
"\"",
",",
"tokenBytesBuf",
":",
"&",
"bytes",
".",
"Buffer",
"{",
"}",
",",
"TokenPool",
":",
"&",
"TokenPool",
"{",
"}",
",",
"}",
"\n",
"}"
] |
// NewLexer the Lexer constructor
|
[
"NewLexer",
"the",
"Lexer",
"constructor"
] |
394f8821001f38fe5b4c4aaffd4fa20e50927a3f
|
https://github.com/z7zmey/php-parser/blob/394f8821001f38fe5b4c4aaffd4fa20e50927a3f/scanner/lexer.go#L66-L82
|
6,039 |
z7zmey/php-parser
|
scanner/lexer.go
|
addFreeFloating
|
func (l *Lexer) addFreeFloating(t freefloating.StringType, chars []lex.Char) {
if !l.WithFreeFloating {
return
}
firstChar := chars[0]
lastChar := chars[len(chars)-1]
pos := position.NewPosition(
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,
})
}
|
go
|
func (l *Lexer) addFreeFloating(t freefloating.StringType, chars []lex.Char) {
if !l.WithFreeFloating {
return
}
firstChar := chars[0]
lastChar := chars[len(chars)-1]
pos := position.NewPosition(
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,
})
}
|
[
"func",
"(",
"l",
"*",
"Lexer",
")",
"addFreeFloating",
"(",
"t",
"freefloating",
".",
"StringType",
",",
"chars",
"[",
"]",
"lex",
".",
"Char",
")",
"{",
"if",
"!",
"l",
".",
"WithFreeFloating",
"{",
"return",
"\n",
"}",
"\n\n",
"firstChar",
":=",
"chars",
"[",
"0",
"]",
"\n",
"lastChar",
":=",
"chars",
"[",
"len",
"(",
"chars",
")",
"-",
"1",
"]",
"\n\n",
"pos",
":=",
"position",
".",
"NewPosition",
"(",
"l",
".",
"File",
".",
"Line",
"(",
"firstChar",
".",
"Pos",
"(",
")",
")",
",",
"l",
".",
"File",
".",
"Line",
"(",
"lastChar",
".",
"Pos",
"(",
")",
")",
",",
"int",
"(",
"firstChar",
".",
"Pos",
"(",
")",
")",
",",
"int",
"(",
"lastChar",
".",
"Pos",
"(",
")",
")",
",",
")",
"\n\n",
"l",
".",
"FreeFloating",
"=",
"append",
"(",
"l",
".",
"FreeFloating",
",",
"freefloating",
".",
"String",
"{",
"StringType",
":",
"t",
",",
"Value",
":",
"l",
".",
"tokenString",
"(",
"chars",
")",
",",
"Position",
":",
"pos",
",",
"}",
")",
"\n",
"}"
] |
// free-floating
|
[
"free",
"-",
"floating"
] |
394f8821001f38fe5b4c4aaffd4fa20e50927a3f
|
https://github.com/z7zmey/php-parser/blob/394f8821001f38fe5b4c4aaffd4fa20e50927a3f/scanner/lexer.go#L168-L188
|
6,040 |
z7zmey/php-parser
|
node/expr/n_list.go
|
NewList
|
func NewList(Items []node.Node) *List {
return &List{
FreeFloating: nil,
Items: Items,
}
}
|
go
|
func NewList(Items []node.Node) *List {
return &List{
FreeFloating: nil,
Items: Items,
}
}
|
[
"func",
"NewList",
"(",
"Items",
"[",
"]",
"node",
".",
"Node",
")",
"*",
"List",
"{",
"return",
"&",
"List",
"{",
"FreeFloating",
":",
"nil",
",",
"Items",
":",
"Items",
",",
"}",
"\n",
"}"
] |
// NewList node constructor
|
[
"NewList",
"node",
"constructor"
] |
394f8821001f38fe5b4c4aaffd4fa20e50927a3f
|
https://github.com/z7zmey/php-parser/blob/394f8821001f38fe5b4c4aaffd4fa20e50927a3f/node/expr/n_list.go#L18-L23
|
6,041 |
z7zmey/php-parser
|
node/expr/binary/n_bitwise_and.go
|
NewBitwiseAnd
|
func NewBitwiseAnd(Variable node.Node, Expression node.Node) *BitwiseAnd {
return &BitwiseAnd{
FreeFloating: nil,
Left: Variable,
Right: Expression,
}
}
|
go
|
func NewBitwiseAnd(Variable node.Node, Expression node.Node) *BitwiseAnd {
return &BitwiseAnd{
FreeFloating: nil,
Left: Variable,
Right: Expression,
}
}
|
[
"func",
"NewBitwiseAnd",
"(",
"Variable",
"node",
".",
"Node",
",",
"Expression",
"node",
".",
"Node",
")",
"*",
"BitwiseAnd",
"{",
"return",
"&",
"BitwiseAnd",
"{",
"FreeFloating",
":",
"nil",
",",
"Left",
":",
"Variable",
",",
"Right",
":",
"Expression",
",",
"}",
"\n",
"}"
] |
// NewBitwiseAnd node constructor
|
[
"NewBitwiseAnd",
"node",
"constructor"
] |
394f8821001f38fe5b4c4aaffd4fa20e50927a3f
|
https://github.com/z7zmey/php-parser/blob/394f8821001f38fe5b4c4aaffd4fa20e50927a3f/node/expr/binary/n_bitwise_and.go#L19-L25
|
6,042 |
z7zmey/php-parser
|
node/expr/n_ternary.go
|
NewTernary
|
func NewTernary(Condition node.Node, IfTrue node.Node, IfFalse node.Node) *Ternary {
return &Ternary{
FreeFloating: nil,
Condition: Condition,
IfTrue: IfTrue,
IfFalse: IfFalse,
}
}
|
go
|
func NewTernary(Condition node.Node, IfTrue node.Node, IfFalse node.Node) *Ternary {
return &Ternary{
FreeFloating: nil,
Condition: Condition,
IfTrue: IfTrue,
IfFalse: IfFalse,
}
}
|
[
"func",
"NewTernary",
"(",
"Condition",
"node",
".",
"Node",
",",
"IfTrue",
"node",
".",
"Node",
",",
"IfFalse",
"node",
".",
"Node",
")",
"*",
"Ternary",
"{",
"return",
"&",
"Ternary",
"{",
"FreeFloating",
":",
"nil",
",",
"Condition",
":",
"Condition",
",",
"IfTrue",
":",
"IfTrue",
",",
"IfFalse",
":",
"IfFalse",
",",
"}",
"\n",
"}"
] |
// NewTernary node constructor
|
[
"NewTernary",
"node",
"constructor"
] |
394f8821001f38fe5b4c4aaffd4fa20e50927a3f
|
https://github.com/z7zmey/php-parser/blob/394f8821001f38fe5b4c4aaffd4fa20e50927a3f/node/expr/n_ternary.go#L20-L27
|
6,043 |
z7zmey/php-parser
|
printer/pretty_printer.go
|
NewPrettyPrinter
|
func NewPrettyPrinter(w io.Writer, indentStr string) *PrettyPrinter {
return &PrettyPrinter{
w: w,
indentStr: indentStr,
indentDepth: 0,
}
}
|
go
|
func NewPrettyPrinter(w io.Writer, indentStr string) *PrettyPrinter {
return &PrettyPrinter{
w: w,
indentStr: indentStr,
indentDepth: 0,
}
}
|
[
"func",
"NewPrettyPrinter",
"(",
"w",
"io",
".",
"Writer",
",",
"indentStr",
"string",
")",
"*",
"PrettyPrinter",
"{",
"return",
"&",
"PrettyPrinter",
"{",
"w",
":",
"w",
",",
"indentStr",
":",
"indentStr",
",",
"indentDepth",
":",
"0",
",",
"}",
"\n",
"}"
] |
// NewPrettyPrinter - Constructor for PrettyPrinter
|
[
"NewPrettyPrinter",
"-",
"Constructor",
"for",
"PrettyPrinter"
] |
394f8821001f38fe5b4c4aaffd4fa20e50927a3f
|
https://github.com/z7zmey/php-parser/blob/394f8821001f38fe5b4c4aaffd4fa20e50927a3f/printer/pretty_printer.go#L25-L31
|
6,044 |
z7zmey/php-parser
|
node/stmt/n_namespace.go
|
NewNamespace
|
func NewNamespace(NamespaceName node.Node, Stmts []node.Node) *Namespace {
return &Namespace{
FreeFloating: nil,
NamespaceName: NamespaceName,
Stmts: Stmts,
}
}
|
go
|
func NewNamespace(NamespaceName node.Node, Stmts []node.Node) *Namespace {
return &Namespace{
FreeFloating: nil,
NamespaceName: NamespaceName,
Stmts: Stmts,
}
}
|
[
"func",
"NewNamespace",
"(",
"NamespaceName",
"node",
".",
"Node",
",",
"Stmts",
"[",
"]",
"node",
".",
"Node",
")",
"*",
"Namespace",
"{",
"return",
"&",
"Namespace",
"{",
"FreeFloating",
":",
"nil",
",",
"NamespaceName",
":",
"NamespaceName",
",",
"Stmts",
":",
"Stmts",
",",
"}",
"\n",
"}"
] |
// NewNamespace node constructor
|
[
"NewNamespace",
"node",
"constructor"
] |
394f8821001f38fe5b4c4aaffd4fa20e50927a3f
|
https://github.com/z7zmey/php-parser/blob/394f8821001f38fe5b4c4aaffd4fa20e50927a3f/node/stmt/n_namespace.go#L19-L25
|
6,045 |
z7zmey/php-parser
|
node/expr/n_require.go
|
NewRequire
|
func NewRequire(Expression node.Node) *Require {
return &Require{
FreeFloating: nil,
Expr: Expression,
}
}
|
go
|
func NewRequire(Expression node.Node) *Require {
return &Require{
FreeFloating: nil,
Expr: Expression,
}
}
|
[
"func",
"NewRequire",
"(",
"Expression",
"node",
".",
"Node",
")",
"*",
"Require",
"{",
"return",
"&",
"Require",
"{",
"FreeFloating",
":",
"nil",
",",
"Expr",
":",
"Expression",
",",
"}",
"\n",
"}"
] |
// NewRequire node constructor
|
[
"NewRequire",
"node",
"constructor"
] |
394f8821001f38fe5b4c4aaffd4fa20e50927a3f
|
https://github.com/z7zmey/php-parser/blob/394f8821001f38fe5b4c4aaffd4fa20e50927a3f/node/expr/n_require.go#L18-L23
|
6,046 |
z7zmey/php-parser
|
node/stmt/n_foreach.go
|
NewForeach
|
func NewForeach(Expr node.Node, Key node.Node, Variable node.Node, Stmt node.Node) *Foreach {
return &Foreach{
FreeFloating: nil,
Expr: Expr,
Key: Key,
Variable: Variable,
Stmt: Stmt,
}
}
|
go
|
func NewForeach(Expr node.Node, Key node.Node, Variable node.Node, Stmt node.Node) *Foreach {
return &Foreach{
FreeFloating: nil,
Expr: Expr,
Key: Key,
Variable: Variable,
Stmt: Stmt,
}
}
|
[
"func",
"NewForeach",
"(",
"Expr",
"node",
".",
"Node",
",",
"Key",
"node",
".",
"Node",
",",
"Variable",
"node",
".",
"Node",
",",
"Stmt",
"node",
".",
"Node",
")",
"*",
"Foreach",
"{",
"return",
"&",
"Foreach",
"{",
"FreeFloating",
":",
"nil",
",",
"Expr",
":",
"Expr",
",",
"Key",
":",
"Key",
",",
"Variable",
":",
"Variable",
",",
"Stmt",
":",
"Stmt",
",",
"}",
"\n",
"}"
] |
// NewForeach node constructor
|
[
"NewForeach",
"node",
"constructor"
] |
394f8821001f38fe5b4c4aaffd4fa20e50927a3f
|
https://github.com/z7zmey/php-parser/blob/394f8821001f38fe5b4c4aaffd4fa20e50927a3f/node/stmt/n_foreach.go#L21-L29
|
6,047 |
z7zmey/php-parser
|
node/expr/binary/n_coalesce.go
|
NewCoalesce
|
func NewCoalesce(Variable node.Node, Expression node.Node) *Coalesce {
return &Coalesce{
FreeFloating: nil,
Left: Variable,
Right: Expression,
}
}
|
go
|
func NewCoalesce(Variable node.Node, Expression node.Node) *Coalesce {
return &Coalesce{
FreeFloating: nil,
Left: Variable,
Right: Expression,
}
}
|
[
"func",
"NewCoalesce",
"(",
"Variable",
"node",
".",
"Node",
",",
"Expression",
"node",
".",
"Node",
")",
"*",
"Coalesce",
"{",
"return",
"&",
"Coalesce",
"{",
"FreeFloating",
":",
"nil",
",",
"Left",
":",
"Variable",
",",
"Right",
":",
"Expression",
",",
"}",
"\n",
"}"
] |
// NewCoalesce node constructor
|
[
"NewCoalesce",
"node",
"constructor"
] |
394f8821001f38fe5b4c4aaffd4fa20e50927a3f
|
https://github.com/z7zmey/php-parser/blob/394f8821001f38fe5b4c4aaffd4fa20e50927a3f/node/expr/binary/n_coalesce.go#L19-L25
|
6,048 |
z7zmey/php-parser
|
node/expr/binary/n_smaller.go
|
NewSmaller
|
func NewSmaller(Variable node.Node, Expression node.Node) *Smaller {
return &Smaller{
FreeFloating: nil,
Left: Variable,
Right: Expression,
}
}
|
go
|
func NewSmaller(Variable node.Node, Expression node.Node) *Smaller {
return &Smaller{
FreeFloating: nil,
Left: Variable,
Right: Expression,
}
}
|
[
"func",
"NewSmaller",
"(",
"Variable",
"node",
".",
"Node",
",",
"Expression",
"node",
".",
"Node",
")",
"*",
"Smaller",
"{",
"return",
"&",
"Smaller",
"{",
"FreeFloating",
":",
"nil",
",",
"Left",
":",
"Variable",
",",
"Right",
":",
"Expression",
",",
"}",
"\n",
"}"
] |
// NewSmaller node constructor
|
[
"NewSmaller",
"node",
"constructor"
] |
394f8821001f38fe5b4c4aaffd4fa20e50927a3f
|
https://github.com/z7zmey/php-parser/blob/394f8821001f38fe5b4c4aaffd4fa20e50927a3f/node/expr/binary/n_smaller.go#L19-L25
|
6,049 |
z7zmey/php-parser
|
node/stmt/n_stmt_list.go
|
NewStmtList
|
func NewStmtList(Stmts []node.Node) *StmtList {
return &StmtList{
FreeFloating: nil,
Stmts: Stmts,
}
}
|
go
|
func NewStmtList(Stmts []node.Node) *StmtList {
return &StmtList{
FreeFloating: nil,
Stmts: Stmts,
}
}
|
[
"func",
"NewStmtList",
"(",
"Stmts",
"[",
"]",
"node",
".",
"Node",
")",
"*",
"StmtList",
"{",
"return",
"&",
"StmtList",
"{",
"FreeFloating",
":",
"nil",
",",
"Stmts",
":",
"Stmts",
",",
"}",
"\n",
"}"
] |
// NewStmtList node constructor
|
[
"NewStmtList",
"node",
"constructor"
] |
394f8821001f38fe5b4c4aaffd4fa20e50927a3f
|
https://github.com/z7zmey/php-parser/blob/394f8821001f38fe5b4c4aaffd4fa20e50927a3f/node/stmt/n_stmt_list.go#L18-L23
|
6,050 |
z7zmey/php-parser
|
node/expr/binary/n_concat.go
|
NewConcat
|
func NewConcat(Variable node.Node, Expression node.Node) *Concat {
return &Concat{
FreeFloating: nil,
Left: Variable,
Right: Expression,
}
}
|
go
|
func NewConcat(Variable node.Node, Expression node.Node) *Concat {
return &Concat{
FreeFloating: nil,
Left: Variable,
Right: Expression,
}
}
|
[
"func",
"NewConcat",
"(",
"Variable",
"node",
".",
"Node",
",",
"Expression",
"node",
".",
"Node",
")",
"*",
"Concat",
"{",
"return",
"&",
"Concat",
"{",
"FreeFloating",
":",
"nil",
",",
"Left",
":",
"Variable",
",",
"Right",
":",
"Expression",
",",
"}",
"\n",
"}"
] |
// NewConcat node constructor
|
[
"NewConcat",
"node",
"constructor"
] |
394f8821001f38fe5b4c4aaffd4fa20e50927a3f
|
https://github.com/z7zmey/php-parser/blob/394f8821001f38fe5b4c4aaffd4fa20e50927a3f/node/expr/binary/n_concat.go#L19-L25
|
6,051 |
z7zmey/php-parser
|
node/stmt/n_alt_switch.go
|
NewAltSwitch
|
func NewAltSwitch(Cond node.Node, CaseList *CaseList) *AltSwitch {
return &AltSwitch{
FreeFloating: nil,
Cond: Cond,
CaseList: CaseList,
}
}
|
go
|
func NewAltSwitch(Cond node.Node, CaseList *CaseList) *AltSwitch {
return &AltSwitch{
FreeFloating: nil,
Cond: Cond,
CaseList: CaseList,
}
}
|
[
"func",
"NewAltSwitch",
"(",
"Cond",
"node",
".",
"Node",
",",
"CaseList",
"*",
"CaseList",
")",
"*",
"AltSwitch",
"{",
"return",
"&",
"AltSwitch",
"{",
"FreeFloating",
":",
"nil",
",",
"Cond",
":",
"Cond",
",",
"CaseList",
":",
"CaseList",
",",
"}",
"\n",
"}"
] |
// NewAltSwitch node constructor
|
[
"NewAltSwitch",
"node",
"constructor"
] |
394f8821001f38fe5b4c4aaffd4fa20e50927a3f
|
https://github.com/z7zmey/php-parser/blob/394f8821001f38fe5b4c4aaffd4fa20e50927a3f/node/stmt/n_alt_switch.go#L19-L25
|
6,052 |
z7zmey/php-parser
|
node/stmt/n_else_if.go
|
NewElseIf
|
func NewElseIf(Cond node.Node, Stmt node.Node) *ElseIf {
return &ElseIf{
FreeFloating: nil,
Cond: Cond,
Stmt: Stmt,
}
}
|
go
|
func NewElseIf(Cond node.Node, Stmt node.Node) *ElseIf {
return &ElseIf{
FreeFloating: nil,
Cond: Cond,
Stmt: Stmt,
}
}
|
[
"func",
"NewElseIf",
"(",
"Cond",
"node",
".",
"Node",
",",
"Stmt",
"node",
".",
"Node",
")",
"*",
"ElseIf",
"{",
"return",
"&",
"ElseIf",
"{",
"FreeFloating",
":",
"nil",
",",
"Cond",
":",
"Cond",
",",
"Stmt",
":",
"Stmt",
",",
"}",
"\n",
"}"
] |
// NewElseIf node constructor
|
[
"NewElseIf",
"node",
"constructor"
] |
394f8821001f38fe5b4c4aaffd4fa20e50927a3f
|
https://github.com/z7zmey/php-parser/blob/394f8821001f38fe5b4c4aaffd4fa20e50927a3f/node/stmt/n_else_if.go#L19-L25
|
6,053 |
z7zmey/php-parser
|
node/stmt/n_declare.go
|
NewDeclare
|
func NewDeclare(Consts []node.Node, Stmt node.Node, alt bool) *Declare {
return &Declare{
FreeFloating: nil,
Consts: Consts,
Stmt: Stmt,
Alt: alt,
}
}
|
go
|
func NewDeclare(Consts []node.Node, Stmt node.Node, alt bool) *Declare {
return &Declare{
FreeFloating: nil,
Consts: Consts,
Stmt: Stmt,
Alt: alt,
}
}
|
[
"func",
"NewDeclare",
"(",
"Consts",
"[",
"]",
"node",
".",
"Node",
",",
"Stmt",
"node",
".",
"Node",
",",
"alt",
"bool",
")",
"*",
"Declare",
"{",
"return",
"&",
"Declare",
"{",
"FreeFloating",
":",
"nil",
",",
"Consts",
":",
"Consts",
",",
"Stmt",
":",
"Stmt",
",",
"Alt",
":",
"alt",
",",
"}",
"\n",
"}"
] |
// NewDeclare node constructor
|
[
"NewDeclare",
"node",
"constructor"
] |
394f8821001f38fe5b4c4aaffd4fa20e50927a3f
|
https://github.com/z7zmey/php-parser/blob/394f8821001f38fe5b4c4aaffd4fa20e50927a3f/node/stmt/n_declare.go#L20-L27
|
6,054 |
z7zmey/php-parser
|
node/expr/binary/n_minus.go
|
NewMinus
|
func NewMinus(Variable node.Node, Expression node.Node) *Minus {
return &Minus{
FreeFloating: nil,
Left: Variable,
Right: Expression,
}
}
|
go
|
func NewMinus(Variable node.Node, Expression node.Node) *Minus {
return &Minus{
FreeFloating: nil,
Left: Variable,
Right: Expression,
}
}
|
[
"func",
"NewMinus",
"(",
"Variable",
"node",
".",
"Node",
",",
"Expression",
"node",
".",
"Node",
")",
"*",
"Minus",
"{",
"return",
"&",
"Minus",
"{",
"FreeFloating",
":",
"nil",
",",
"Left",
":",
"Variable",
",",
"Right",
":",
"Expression",
",",
"}",
"\n",
"}"
] |
// NewMinus node constructor
|
[
"NewMinus",
"node",
"constructor"
] |
394f8821001f38fe5b4c4aaffd4fa20e50927a3f
|
https://github.com/z7zmey/php-parser/blob/394f8821001f38fe5b4c4aaffd4fa20e50927a3f/node/expr/binary/n_minus.go#L19-L25
|
6,055 |
z7zmey/php-parser
|
node/name/n_relative.go
|
NewRelative
|
func NewRelative(Parts []node.Node) *Relative {
return &Relative{
FreeFloating: nil,
Parts: Parts,
}
}
|
go
|
func NewRelative(Parts []node.Node) *Relative {
return &Relative{
FreeFloating: nil,
Parts: Parts,
}
}
|
[
"func",
"NewRelative",
"(",
"Parts",
"[",
"]",
"node",
".",
"Node",
")",
"*",
"Relative",
"{",
"return",
"&",
"Relative",
"{",
"FreeFloating",
":",
"nil",
",",
"Parts",
":",
"Parts",
",",
"}",
"\n",
"}"
] |
// NewRelative node constructor
|
[
"NewRelative",
"node",
"constructor"
] |
394f8821001f38fe5b4c4aaffd4fa20e50927a3f
|
https://github.com/z7zmey/php-parser/blob/394f8821001f38fe5b4c4aaffd4fa20e50927a3f/node/name/n_relative.go#L18-L23
|
6,056 |
z7zmey/php-parser
|
node/stmt/n_continue.go
|
NewContinue
|
func NewContinue(Expr node.Node) *Continue {
return &Continue{
FreeFloating: nil,
Expr: Expr,
}
}
|
go
|
func NewContinue(Expr node.Node) *Continue {
return &Continue{
FreeFloating: nil,
Expr: Expr,
}
}
|
[
"func",
"NewContinue",
"(",
"Expr",
"node",
".",
"Node",
")",
"*",
"Continue",
"{",
"return",
"&",
"Continue",
"{",
"FreeFloating",
":",
"nil",
",",
"Expr",
":",
"Expr",
",",
"}",
"\n",
"}"
] |
// NewContinue node constructor
|
[
"NewContinue",
"node",
"constructor"
] |
394f8821001f38fe5b4c4aaffd4fa20e50927a3f
|
https://github.com/z7zmey/php-parser/blob/394f8821001f38fe5b4c4aaffd4fa20e50927a3f/node/stmt/n_continue.go#L18-L23
|
6,057 |
z7zmey/php-parser
|
node/expr/n_array_dim_fetch.go
|
NewArrayDimFetch
|
func NewArrayDimFetch(Variable node.Node, Dim node.Node) *ArrayDimFetch {
return &ArrayDimFetch{
FreeFloating: nil,
Variable: Variable,
Dim: Dim,
}
}
|
go
|
func NewArrayDimFetch(Variable node.Node, Dim node.Node) *ArrayDimFetch {
return &ArrayDimFetch{
FreeFloating: nil,
Variable: Variable,
Dim: Dim,
}
}
|
[
"func",
"NewArrayDimFetch",
"(",
"Variable",
"node",
".",
"Node",
",",
"Dim",
"node",
".",
"Node",
")",
"*",
"ArrayDimFetch",
"{",
"return",
"&",
"ArrayDimFetch",
"{",
"FreeFloating",
":",
"nil",
",",
"Variable",
":",
"Variable",
",",
"Dim",
":",
"Dim",
",",
"}",
"\n",
"}"
] |
// NewArrayDimFetch node constructor
|
[
"NewArrayDimFetch",
"node",
"constructor"
] |
394f8821001f38fe5b4c4aaffd4fa20e50927a3f
|
https://github.com/z7zmey/php-parser/blob/394f8821001f38fe5b4c4aaffd4fa20e50927a3f/node/expr/n_array_dim_fetch.go#L19-L25
|
6,058 |
z7zmey/php-parser
|
node/stmt/n_global.go
|
NewGlobal
|
func NewGlobal(Vars []node.Node) *Global {
return &Global{
FreeFloating: nil,
Vars: Vars,
}
}
|
go
|
func NewGlobal(Vars []node.Node) *Global {
return &Global{
FreeFloating: nil,
Vars: Vars,
}
}
|
[
"func",
"NewGlobal",
"(",
"Vars",
"[",
"]",
"node",
".",
"Node",
")",
"*",
"Global",
"{",
"return",
"&",
"Global",
"{",
"FreeFloating",
":",
"nil",
",",
"Vars",
":",
"Vars",
",",
"}",
"\n",
"}"
] |
// NewGlobal node constructor
|
[
"NewGlobal",
"node",
"constructor"
] |
394f8821001f38fe5b4c4aaffd4fa20e50927a3f
|
https://github.com/z7zmey/php-parser/blob/394f8821001f38fe5b4c4aaffd4fa20e50927a3f/node/stmt/n_global.go#L18-L23
|
6,059 |
z7zmey/php-parser
|
position/position.go
|
NewPosition
|
func NewPosition(StartLine int, EndLine int, StartPos int, EndPos int) *Position {
return &Position{
StartLine: StartLine,
EndLine: EndLine,
StartPos: StartPos,
EndPos: EndPos,
}
}
|
go
|
func NewPosition(StartLine int, EndLine int, StartPos int, EndPos int) *Position {
return &Position{
StartLine: StartLine,
EndLine: EndLine,
StartPos: StartPos,
EndPos: EndPos,
}
}
|
[
"func",
"NewPosition",
"(",
"StartLine",
"int",
",",
"EndLine",
"int",
",",
"StartPos",
"int",
",",
"EndPos",
"int",
")",
"*",
"Position",
"{",
"return",
"&",
"Position",
"{",
"StartLine",
":",
"StartLine",
",",
"EndLine",
":",
"EndLine",
",",
"StartPos",
":",
"StartPos",
",",
"EndPos",
":",
"EndPos",
",",
"}",
"\n",
"}"
] |
// NewPosition Position constructor
|
[
"NewPosition",
"Position",
"constructor"
] |
394f8821001f38fe5b4c4aaffd4fa20e50927a3f
|
https://github.com/z7zmey/php-parser/blob/394f8821001f38fe5b4c4aaffd4fa20e50927a3f/position/position.go#L16-L23
|
6,060 |
z7zmey/php-parser
|
node/expr/n_post_inc.go
|
NewPostInc
|
func NewPostInc(Variable node.Node) *PostInc {
return &PostInc{
FreeFloating: nil,
Variable: Variable,
}
}
|
go
|
func NewPostInc(Variable node.Node) *PostInc {
return &PostInc{
FreeFloating: nil,
Variable: Variable,
}
}
|
[
"func",
"NewPostInc",
"(",
"Variable",
"node",
".",
"Node",
")",
"*",
"PostInc",
"{",
"return",
"&",
"PostInc",
"{",
"FreeFloating",
":",
"nil",
",",
"Variable",
":",
"Variable",
",",
"}",
"\n",
"}"
] |
// NewPostInc node constructor
|
[
"NewPostInc",
"node",
"constructor"
] |
394f8821001f38fe5b4c4aaffd4fa20e50927a3f
|
https://github.com/z7zmey/php-parser/blob/394f8821001f38fe5b4c4aaffd4fa20e50927a3f/node/expr/n_post_inc.go#L18-L23
|
6,061 |
z7zmey/php-parser
|
node/stmt/n_alt_foreach.go
|
NewAltForeach
|
func NewAltForeach(Expr node.Node, Key node.Node, Variable node.Node, Stmt node.Node) *AltForeach {
return &AltForeach{
FreeFloating: nil,
Expr: Expr,
Key: Key,
Variable: Variable,
Stmt: Stmt,
}
}
|
go
|
func NewAltForeach(Expr node.Node, Key node.Node, Variable node.Node, Stmt node.Node) *AltForeach {
return &AltForeach{
FreeFloating: nil,
Expr: Expr,
Key: Key,
Variable: Variable,
Stmt: Stmt,
}
}
|
[
"func",
"NewAltForeach",
"(",
"Expr",
"node",
".",
"Node",
",",
"Key",
"node",
".",
"Node",
",",
"Variable",
"node",
".",
"Node",
",",
"Stmt",
"node",
".",
"Node",
")",
"*",
"AltForeach",
"{",
"return",
"&",
"AltForeach",
"{",
"FreeFloating",
":",
"nil",
",",
"Expr",
":",
"Expr",
",",
"Key",
":",
"Key",
",",
"Variable",
":",
"Variable",
",",
"Stmt",
":",
"Stmt",
",",
"}",
"\n",
"}"
] |
// NewAltForeach node constructor
|
[
"NewAltForeach",
"node",
"constructor"
] |
394f8821001f38fe5b4c4aaffd4fa20e50927a3f
|
https://github.com/z7zmey/php-parser/blob/394f8821001f38fe5b4c4aaffd4fa20e50927a3f/node/stmt/n_alt_foreach.go#L21-L29
|
6,062 |
z7zmey/php-parser
|
node/stmt/n_goto.go
|
NewGoto
|
func NewGoto(Label node.Node) *Goto {
return &Goto{
FreeFloating: nil,
Label: Label,
}
}
|
go
|
func NewGoto(Label node.Node) *Goto {
return &Goto{
FreeFloating: nil,
Label: Label,
}
}
|
[
"func",
"NewGoto",
"(",
"Label",
"node",
".",
"Node",
")",
"*",
"Goto",
"{",
"return",
"&",
"Goto",
"{",
"FreeFloating",
":",
"nil",
",",
"Label",
":",
"Label",
",",
"}",
"\n",
"}"
] |
// NewGoto node constructor
|
[
"NewGoto",
"node",
"constructor"
] |
394f8821001f38fe5b4c4aaffd4fa20e50927a3f
|
https://github.com/z7zmey/php-parser/blob/394f8821001f38fe5b4c4aaffd4fa20e50927a3f/node/stmt/n_goto.go#L18-L23
|
6,063 |
disintegration/gift
|
colors.go
|
Invert
|
func Invert() Filter {
return &colorchanFilter{
fn: func(x float32) float32 {
return 1 - x
},
lut: false,
}
}
|
go
|
func Invert() Filter {
return &colorchanFilter{
fn: func(x float32) float32 {
return 1 - x
},
lut: false,
}
}
|
[
"func",
"Invert",
"(",
")",
"Filter",
"{",
"return",
"&",
"colorchanFilter",
"{",
"fn",
":",
"func",
"(",
"x",
"float32",
")",
"float32",
"{",
"return",
"1",
"-",
"x",
"\n",
"}",
",",
"lut",
":",
"false",
",",
"}",
"\n",
"}"
] |
// Invert creates a filter that negates the colors of an image.
|
[
"Invert",
"creates",
"a",
"filter",
"that",
"negates",
"the",
"colors",
"of",
"an",
"image",
"."
] |
5c2e6f4a91b12ffcb309b7602c01be3a2ba55543
|
https://github.com/disintegration/gift/blob/5c2e6f4a91b12ffcb309b7602c01be3a2ba55543/colors.go#L85-L92
|
6,064 |
disintegration/gift
|
colors.go
|
ColorspaceSRGBToLinear
|
func ColorspaceSRGBToLinear() Filter {
return &colorchanFilter{
fn: func(x float32) float32 {
if x <= 0.04045 {
return x / 12.92
}
return float32(math.Pow(float64((x+0.055)/1.055), 2.4))
},
lut: true,
}
}
|
go
|
func ColorspaceSRGBToLinear() Filter {
return &colorchanFilter{
fn: func(x float32) float32 {
if x <= 0.04045 {
return x / 12.92
}
return float32(math.Pow(float64((x+0.055)/1.055), 2.4))
},
lut: true,
}
}
|
[
"func",
"ColorspaceSRGBToLinear",
"(",
")",
"Filter",
"{",
"return",
"&",
"colorchanFilter",
"{",
"fn",
":",
"func",
"(",
"x",
"float32",
")",
"float32",
"{",
"if",
"x",
"<=",
"0.04045",
"{",
"return",
"x",
"/",
"12.92",
"\n",
"}",
"\n",
"return",
"float32",
"(",
"math",
".",
"Pow",
"(",
"float64",
"(",
"(",
"x",
"+",
"0.055",
")",
"/",
"1.055",
")",
",",
"2.4",
")",
")",
"\n",
"}",
",",
"lut",
":",
"true",
",",
"}",
"\n",
"}"
] |
// ColorspaceSRGBToLinear creates a filter that converts the colors of an image from sRGB to linear RGB.
|
[
"ColorspaceSRGBToLinear",
"creates",
"a",
"filter",
"that",
"converts",
"the",
"colors",
"of",
"an",
"image",
"from",
"sRGB",
"to",
"linear",
"RGB",
"."
] |
5c2e6f4a91b12ffcb309b7602c01be3a2ba55543
|
https://github.com/disintegration/gift/blob/5c2e6f4a91b12ffcb309b7602c01be3a2ba55543/colors.go#L95-L105
|
6,065 |
disintegration/gift
|
colors.go
|
Gamma
|
func Gamma(gamma float32) Filter {
e := 1 / maxf32(gamma, 1.0e-5)
return &colorchanFilter{
fn: func(x float32) float32 {
return powf32(x, e)
},
lut: true,
}
}
|
go
|
func Gamma(gamma float32) Filter {
e := 1 / maxf32(gamma, 1.0e-5)
return &colorchanFilter{
fn: func(x float32) float32 {
return powf32(x, e)
},
lut: true,
}
}
|
[
"func",
"Gamma",
"(",
"gamma",
"float32",
")",
"Filter",
"{",
"e",
":=",
"1",
"/",
"maxf32",
"(",
"gamma",
",",
"1.0e-5",
")",
"\n",
"return",
"&",
"colorchanFilter",
"{",
"fn",
":",
"func",
"(",
"x",
"float32",
")",
"float32",
"{",
"return",
"powf32",
"(",
"x",
",",
"e",
")",
"\n",
"}",
",",
"lut",
":",
"true",
",",
"}",
"\n",
"}"
] |
// Gamma creates a filter that performs a gamma correction on an image.
// The gamma parameter must be positive. Gamma = 1 gives the original image.
// Gamma less than 1 darkens the image and gamma greater than 1 lightens it.
|
[
"Gamma",
"creates",
"a",
"filter",
"that",
"performs",
"a",
"gamma",
"correction",
"on",
"an",
"image",
".",
"The",
"gamma",
"parameter",
"must",
"be",
"positive",
".",
"Gamma",
"=",
"1",
"gives",
"the",
"original",
"image",
".",
"Gamma",
"less",
"than",
"1",
"darkens",
"the",
"image",
"and",
"gamma",
"greater",
"than",
"1",
"lightens",
"it",
"."
] |
5c2e6f4a91b12ffcb309b7602c01be3a2ba55543
|
https://github.com/disintegration/gift/blob/5c2e6f4a91b12ffcb309b7602c01be3a2ba55543/colors.go#L123-L131
|
6,066 |
disintegration/gift
|
colors.go
|
Grayscale
|
func Grayscale() Filter {
return &colorFilter{
fn: func(px pixel) pixel {
y := 0.299*px.r + 0.587*px.g + 0.114*px.b
return pixel{y, y, y, px.a}
},
}
}
|
go
|
func Grayscale() Filter {
return &colorFilter{
fn: func(px pixel) pixel {
y := 0.299*px.r + 0.587*px.g + 0.114*px.b
return pixel{y, y, y, px.a}
},
}
}
|
[
"func",
"Grayscale",
"(",
")",
"Filter",
"{",
"return",
"&",
"colorFilter",
"{",
"fn",
":",
"func",
"(",
"px",
"pixel",
")",
"pixel",
"{",
"y",
":=",
"0.299",
"*",
"px",
".",
"r",
"+",
"0.587",
"*",
"px",
".",
"g",
"+",
"0.114",
"*",
"px",
".",
"b",
"\n",
"return",
"pixel",
"{",
"y",
",",
"y",
",",
"y",
",",
"px",
".",
"a",
"}",
"\n",
"}",
",",
"}",
"\n",
"}"
] |
// Grayscale creates a filter that produces a grayscale version of an image.
|
[
"Grayscale",
"creates",
"a",
"filter",
"that",
"produces",
"a",
"grayscale",
"version",
"of",
"an",
"image",
"."
] |
5c2e6f4a91b12ffcb309b7602c01be3a2ba55543
|
https://github.com/disintegration/gift/blob/5c2e6f4a91b12ffcb309b7602c01be3a2ba55543/colors.go#L249-L256
|
6,067 |
disintegration/gift
|
gift.go
|
Add
|
func (g *GIFT) Add(filters ...Filter) {
g.Filters = append(g.Filters, filters...)
}
|
go
|
func (g *GIFT) Add(filters ...Filter) {
g.Filters = append(g.Filters, filters...)
}
|
[
"func",
"(",
"g",
"*",
"GIFT",
")",
"Add",
"(",
"filters",
"...",
"Filter",
")",
"{",
"g",
".",
"Filters",
"=",
"append",
"(",
"g",
".",
"Filters",
",",
"filters",
"...",
")",
"\n",
"}"
] |
// Add appends the given filters to the list of filters.
|
[
"Add",
"appends",
"the",
"given",
"filters",
"to",
"the",
"list",
"of",
"filters",
"."
] |
5c2e6f4a91b12ffcb309b7602c01be3a2ba55543
|
https://github.com/disintegration/gift/blob/5c2e6f4a91b12ffcb309b7602c01be3a2ba55543/gift.go#L70-L72
|
6,068 |
disintegration/gift
|
gift.go
|
Draw
|
func (g *GIFT) Draw(dst draw.Image, src image.Image) {
if len(g.Filters) == 0 {
copyimage(dst, src, &g.Options)
return
}
first, last := 0, len(g.Filters)-1
var tmpIn image.Image
var tmpOut draw.Image
for i, f := range g.Filters {
if i == first {
tmpIn = src
} else {
tmpIn = tmpOut
}
if i == last {
tmpOut = dst
} else {
tmpOut = createTempImage(f.Bounds(tmpIn.Bounds()))
}
f.Draw(tmpOut, tmpIn, &g.Options)
}
}
|
go
|
func (g *GIFT) Draw(dst draw.Image, src image.Image) {
if len(g.Filters) == 0 {
copyimage(dst, src, &g.Options)
return
}
first, last := 0, len(g.Filters)-1
var tmpIn image.Image
var tmpOut draw.Image
for i, f := range g.Filters {
if i == first {
tmpIn = src
} else {
tmpIn = tmpOut
}
if i == last {
tmpOut = dst
} else {
tmpOut = createTempImage(f.Bounds(tmpIn.Bounds()))
}
f.Draw(tmpOut, tmpIn, &g.Options)
}
}
|
[
"func",
"(",
"g",
"*",
"GIFT",
")",
"Draw",
"(",
"dst",
"draw",
".",
"Image",
",",
"src",
"image",
".",
"Image",
")",
"{",
"if",
"len",
"(",
"g",
".",
"Filters",
")",
"==",
"0",
"{",
"copyimage",
"(",
"dst",
",",
"src",
",",
"&",
"g",
".",
"Options",
")",
"\n",
"return",
"\n",
"}",
"\n\n",
"first",
",",
"last",
":=",
"0",
",",
"len",
"(",
"g",
".",
"Filters",
")",
"-",
"1",
"\n",
"var",
"tmpIn",
"image",
".",
"Image",
"\n",
"var",
"tmpOut",
"draw",
".",
"Image",
"\n\n",
"for",
"i",
",",
"f",
":=",
"range",
"g",
".",
"Filters",
"{",
"if",
"i",
"==",
"first",
"{",
"tmpIn",
"=",
"src",
"\n",
"}",
"else",
"{",
"tmpIn",
"=",
"tmpOut",
"\n",
"}",
"\n\n",
"if",
"i",
"==",
"last",
"{",
"tmpOut",
"=",
"dst",
"\n",
"}",
"else",
"{",
"tmpOut",
"=",
"createTempImage",
"(",
"f",
".",
"Bounds",
"(",
"tmpIn",
".",
"Bounds",
"(",
")",
")",
")",
"\n",
"}",
"\n\n",
"f",
".",
"Draw",
"(",
"tmpOut",
",",
"tmpIn",
",",
"&",
"g",
".",
"Options",
")",
"\n",
"}",
"\n",
"}"
] |
// Draw applies all the added filters to the src image and outputs the result to the dst image.
|
[
"Draw",
"applies",
"all",
"the",
"added",
"filters",
"to",
"the",
"src",
"image",
"and",
"outputs",
"the",
"result",
"to",
"the",
"dst",
"image",
"."
] |
5c2e6f4a91b12ffcb309b7602c01be3a2ba55543
|
https://github.com/disintegration/gift/blob/5c2e6f4a91b12ffcb309b7602c01be3a2ba55543/gift.go#L101-L126
|
6,069 |
disintegration/gift
|
convolution.go
|
prepareConvolutionWeights1d
|
func prepareConvolutionWeights1d(kernel []float32) (int, []uweight) {
size := len(kernel)
if size%2 == 0 {
size--
}
if size < 1 {
return 0, []uweight{}
}
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
}
|
go
|
func prepareConvolutionWeights1d(kernel []float32) (int, []uweight) {
size := len(kernel)
if size%2 == 0 {
size--
}
if size < 1 {
return 0, []uweight{}
}
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
}
|
[
"func",
"prepareConvolutionWeights1d",
"(",
"kernel",
"[",
"]",
"float32",
")",
"(",
"int",
",",
"[",
"]",
"uweight",
")",
"{",
"size",
":=",
"len",
"(",
"kernel",
")",
"\n",
"if",
"size",
"%",
"2",
"==",
"0",
"{",
"size",
"--",
"\n",
"}",
"\n",
"if",
"size",
"<",
"1",
"{",
"return",
"0",
",",
"[",
"]",
"uweight",
"{",
"}",
"\n",
"}",
"\n",
"center",
":=",
"size",
"/",
"2",
"\n",
"weights",
":=",
"[",
"]",
"uweight",
"{",
"}",
"\n",
"for",
"i",
":=",
"0",
";",
"i",
"<",
"size",
";",
"i",
"++",
"{",
"w",
":=",
"float32",
"(",
"0",
")",
"\n",
"if",
"i",
"<",
"len",
"(",
"kernel",
")",
"{",
"w",
"=",
"kernel",
"[",
"i",
"]",
"\n",
"}",
"\n",
"if",
"w",
"!=",
"0",
"{",
"weights",
"=",
"append",
"(",
"weights",
",",
"uweight",
"{",
"i",
"-",
"center",
",",
"w",
"}",
")",
"\n",
"}",
"\n",
"}",
"\n",
"return",
"size",
",",
"weights",
"\n",
"}"
] |
// prepareConvolutionWeights1d prepares pixel weights using a convolution kernel.
// Weights equal to 0 are excluded.
|
[
"prepareConvolutionWeights1d",
"prepares",
"pixel",
"weights",
"using",
"a",
"convolution",
"kernel",
".",
"Weights",
"equal",
"to",
"0",
"are",
"excluded",
"."
] |
5c2e6f4a91b12ffcb309b7602c01be3a2ba55543
|
https://github.com/disintegration/gift/blob/5c2e6f4a91b12ffcb309b7602c01be3a2ba55543/convolution.go#L221-L241
|
6,070 |
disintegration/gift
|
convolution.go
|
convolveLine
|
func convolveLine(dstBuf []pixel, srcBuf []pixel, weights []uweight) {
max := len(srcBuf) - 1
if max < 0 {
return
}
for dstu := 0; dstu < len(srcBuf); dstu++ {
var r, g, b, a float32
for _, w := range weights {
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}
}
}
|
go
|
func convolveLine(dstBuf []pixel, srcBuf []pixel, weights []uweight) {
max := len(srcBuf) - 1
if max < 0 {
return
}
for dstu := 0; dstu < len(srcBuf); dstu++ {
var r, g, b, a float32
for _, w := range weights {
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}
}
}
|
[
"func",
"convolveLine",
"(",
"dstBuf",
"[",
"]",
"pixel",
",",
"srcBuf",
"[",
"]",
"pixel",
",",
"weights",
"[",
"]",
"uweight",
")",
"{",
"max",
":=",
"len",
"(",
"srcBuf",
")",
"-",
"1",
"\n",
"if",
"max",
"<",
"0",
"{",
"return",
"\n",
"}",
"\n",
"for",
"dstu",
":=",
"0",
";",
"dstu",
"<",
"len",
"(",
"srcBuf",
")",
";",
"dstu",
"++",
"{",
"var",
"r",
",",
"g",
",",
"b",
",",
"a",
"float32",
"\n",
"for",
"_",
",",
"w",
":=",
"range",
"weights",
"{",
"k",
":=",
"dstu",
"+",
"w",
".",
"u",
"\n",
"if",
"k",
"<",
"0",
"{",
"k",
"=",
"0",
"\n",
"}",
"else",
"if",
"k",
">",
"max",
"{",
"k",
"=",
"max",
"\n",
"}",
"\n",
"c",
":=",
"srcBuf",
"[",
"k",
"]",
"\n",
"wa",
":=",
"c",
".",
"a",
"*",
"w",
".",
"weight",
"\n",
"r",
"+=",
"c",
".",
"r",
"*",
"wa",
"\n",
"g",
"+=",
"c",
".",
"g",
"*",
"wa",
"\n",
"b",
"+=",
"c",
".",
"b",
"*",
"wa",
"\n",
"a",
"+=",
"wa",
"\n",
"}",
"\n",
"if",
"a",
"!=",
"0",
"{",
"r",
"/=",
"a",
"\n",
"g",
"/=",
"a",
"\n",
"b",
"/=",
"a",
"\n",
"}",
"\n",
"dstBuf",
"[",
"dstu",
"]",
"=",
"pixel",
"{",
"r",
",",
"g",
",",
"b",
",",
"a",
"}",
"\n",
"}",
"\n",
"}"
] |
// convolveLine convolves a single line of pixels according to the given weights.
|
[
"convolveLine",
"convolves",
"a",
"single",
"line",
"of",
"pixels",
"according",
"to",
"the",
"given",
"weights",
"."
] |
5c2e6f4a91b12ffcb309b7602c01be3a2ba55543
|
https://github.com/disintegration/gift/blob/5c2e6f4a91b12ffcb309b7602c01be3a2ba55543/convolution.go#L244-L272
|
6,071 |
disintegration/gift
|
convolution.go
|
convolve1dv
|
func convolve1dv(dst draw.Image, src image.Image, kernel []float32, options *Options) {
srcb := src.Bounds()
dstb := dst.Bounds()
if srcb.Dx() <= 0 || srcb.Dy() <= 0 {
return
}
if kernel == nil || len(kernel) < 1 {
copyimage(dst, src, options)
return
}
_, weights := prepareConvolutionWeights1d(kernel)
pixGetter := newPixelGetter(src)
pixSetter := newPixelSetter(dst)
parallelize(options.Parallelization, srcb.Min.X, srcb.Max.X, func(start, stop int) {
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)
}
})
}
|
go
|
func convolve1dv(dst draw.Image, src image.Image, kernel []float32, options *Options) {
srcb := src.Bounds()
dstb := dst.Bounds()
if srcb.Dx() <= 0 || srcb.Dy() <= 0 {
return
}
if kernel == nil || len(kernel) < 1 {
copyimage(dst, src, options)
return
}
_, weights := prepareConvolutionWeights1d(kernel)
pixGetter := newPixelGetter(src)
pixSetter := newPixelSetter(dst)
parallelize(options.Parallelization, srcb.Min.X, srcb.Max.X, func(start, stop int) {
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)
}
})
}
|
[
"func",
"convolve1dv",
"(",
"dst",
"draw",
".",
"Image",
",",
"src",
"image",
".",
"Image",
",",
"kernel",
"[",
"]",
"float32",
",",
"options",
"*",
"Options",
")",
"{",
"srcb",
":=",
"src",
".",
"Bounds",
"(",
")",
"\n",
"dstb",
":=",
"dst",
".",
"Bounds",
"(",
")",
"\n",
"if",
"srcb",
".",
"Dx",
"(",
")",
"<=",
"0",
"||",
"srcb",
".",
"Dy",
"(",
")",
"<=",
"0",
"{",
"return",
"\n",
"}",
"\n",
"if",
"kernel",
"==",
"nil",
"||",
"len",
"(",
"kernel",
")",
"<",
"1",
"{",
"copyimage",
"(",
"dst",
",",
"src",
",",
"options",
")",
"\n",
"return",
"\n",
"}",
"\n",
"_",
",",
"weights",
":=",
"prepareConvolutionWeights1d",
"(",
"kernel",
")",
"\n",
"pixGetter",
":=",
"newPixelGetter",
"(",
"src",
")",
"\n",
"pixSetter",
":=",
"newPixelSetter",
"(",
"dst",
")",
"\n",
"parallelize",
"(",
"options",
".",
"Parallelization",
",",
"srcb",
".",
"Min",
".",
"X",
",",
"srcb",
".",
"Max",
".",
"X",
",",
"func",
"(",
"start",
",",
"stop",
"int",
")",
"{",
"srcBuf",
":=",
"make",
"(",
"[",
"]",
"pixel",
",",
"srcb",
".",
"Dy",
"(",
")",
")",
"\n",
"dstBuf",
":=",
"make",
"(",
"[",
"]",
"pixel",
",",
"srcb",
".",
"Dy",
"(",
")",
")",
"\n",
"for",
"x",
":=",
"start",
";",
"x",
"<",
"stop",
";",
"x",
"++",
"{",
"pixGetter",
".",
"getPixelColumn",
"(",
"x",
",",
"&",
"srcBuf",
")",
"\n",
"convolveLine",
"(",
"dstBuf",
",",
"srcBuf",
",",
"weights",
")",
"\n",
"pixSetter",
".",
"setPixelColumn",
"(",
"dstb",
".",
"Min",
".",
"X",
"+",
"x",
"-",
"srcb",
".",
"Min",
".",
"X",
",",
"dstBuf",
")",
"\n",
"}",
"\n",
"}",
")",
"\n",
"}"
] |
// convolve1dv performs a fast vertical 1d convolution.
|
[
"convolve1dv",
"performs",
"a",
"fast",
"vertical",
"1d",
"convolution",
"."
] |
5c2e6f4a91b12ffcb309b7602c01be3a2ba55543
|
https://github.com/disintegration/gift/blob/5c2e6f4a91b12ffcb309b7602c01be3a2ba55543/convolution.go#L275-L297
|
6,072 |
disintegration/gift
|
convolution.go
|
convolve1dh
|
func convolve1dh(dst draw.Image, src image.Image, kernel []float32, options *Options) {
srcb := src.Bounds()
dstb := dst.Bounds()
if srcb.Dx() <= 0 || srcb.Dy() <= 0 {
return
}
if kernel == nil || len(kernel) < 1 {
copyimage(dst, src, options)
return
}
_, weights := prepareConvolutionWeights1d(kernel)
pixGetter := newPixelGetter(src)
pixSetter := newPixelSetter(dst)
parallelize(options.Parallelization, srcb.Min.Y, srcb.Max.Y, func(start, stop int) {
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)
}
})
}
|
go
|
func convolve1dh(dst draw.Image, src image.Image, kernel []float32, options *Options) {
srcb := src.Bounds()
dstb := dst.Bounds()
if srcb.Dx() <= 0 || srcb.Dy() <= 0 {
return
}
if kernel == nil || len(kernel) < 1 {
copyimage(dst, src, options)
return
}
_, weights := prepareConvolutionWeights1d(kernel)
pixGetter := newPixelGetter(src)
pixSetter := newPixelSetter(dst)
parallelize(options.Parallelization, srcb.Min.Y, srcb.Max.Y, func(start, stop int) {
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)
}
})
}
|
[
"func",
"convolve1dh",
"(",
"dst",
"draw",
".",
"Image",
",",
"src",
"image",
".",
"Image",
",",
"kernel",
"[",
"]",
"float32",
",",
"options",
"*",
"Options",
")",
"{",
"srcb",
":=",
"src",
".",
"Bounds",
"(",
")",
"\n",
"dstb",
":=",
"dst",
".",
"Bounds",
"(",
")",
"\n",
"if",
"srcb",
".",
"Dx",
"(",
")",
"<=",
"0",
"||",
"srcb",
".",
"Dy",
"(",
")",
"<=",
"0",
"{",
"return",
"\n",
"}",
"\n",
"if",
"kernel",
"==",
"nil",
"||",
"len",
"(",
"kernel",
")",
"<",
"1",
"{",
"copyimage",
"(",
"dst",
",",
"src",
",",
"options",
")",
"\n",
"return",
"\n",
"}",
"\n",
"_",
",",
"weights",
":=",
"prepareConvolutionWeights1d",
"(",
"kernel",
")",
"\n",
"pixGetter",
":=",
"newPixelGetter",
"(",
"src",
")",
"\n",
"pixSetter",
":=",
"newPixelSetter",
"(",
"dst",
")",
"\n",
"parallelize",
"(",
"options",
".",
"Parallelization",
",",
"srcb",
".",
"Min",
".",
"Y",
",",
"srcb",
".",
"Max",
".",
"Y",
",",
"func",
"(",
"start",
",",
"stop",
"int",
")",
"{",
"srcBuf",
":=",
"make",
"(",
"[",
"]",
"pixel",
",",
"srcb",
".",
"Dx",
"(",
")",
")",
"\n",
"dstBuf",
":=",
"make",
"(",
"[",
"]",
"pixel",
",",
"srcb",
".",
"Dx",
"(",
")",
")",
"\n",
"for",
"y",
":=",
"start",
";",
"y",
"<",
"stop",
";",
"y",
"++",
"{",
"pixGetter",
".",
"getPixelRow",
"(",
"y",
",",
"&",
"srcBuf",
")",
"\n",
"convolveLine",
"(",
"dstBuf",
",",
"srcBuf",
",",
"weights",
")",
"\n",
"pixSetter",
".",
"setPixelRow",
"(",
"dstb",
".",
"Min",
".",
"Y",
"+",
"y",
"-",
"srcb",
".",
"Min",
".",
"Y",
",",
"dstBuf",
")",
"\n",
"}",
"\n",
"}",
")",
"\n",
"}"
] |
// convolve1dh performs afast horizontal 1d convolution.
|
[
"convolve1dh",
"performs",
"afast",
"horizontal",
"1d",
"convolution",
"."
] |
5c2e6f4a91b12ffcb309b7602c01be3a2ba55543
|
https://github.com/disintegration/gift/blob/5c2e6f4a91b12ffcb309b7602c01be3a2ba55543/convolution.go#L300-L322
|
6,073 |
disintegration/gift
|
transform.go
|
CropToSize
|
func CropToSize(width, height int, anchor Anchor) Filter {
return &cropToSizeFilter{
w: width,
h: height,
anchor: anchor,
}
}
|
go
|
func CropToSize(width, height int, anchor Anchor) Filter {
return &cropToSizeFilter{
w: width,
h: height,
anchor: anchor,
}
}
|
[
"func",
"CropToSize",
"(",
"width",
",",
"height",
"int",
",",
"anchor",
"Anchor",
")",
"Filter",
"{",
"return",
"&",
"cropToSizeFilter",
"{",
"w",
":",
"width",
",",
"h",
":",
"height",
",",
"anchor",
":",
"anchor",
",",
"}",
"\n",
"}"
] |
// CropToSize creates a filter that crops an image to the specified size using the specified anchor point.
|
[
"CropToSize",
"creates",
"a",
"filter",
"that",
"crops",
"an",
"image",
"to",
"the",
"specified",
"size",
"using",
"the",
"specified",
"anchor",
"point",
"."
] |
5c2e6f4a91b12ffcb309b7602c01be3a2ba55543
|
https://github.com/disintegration/gift/blob/5c2e6f4a91b12ffcb309b7602c01be3a2ba55543/transform.go#L492-L498
|
6,074 |
disintegration/gift
|
utils.go
|
parallelize
|
func parallelize(enabled bool, start, stop int, fn func(start, stop int)) {
procs := 1
if enabled {
procs = runtime.GOMAXPROCS(0)
}
var wg sync.WaitGroup
splitRange(start, stop, procs, func(pstart, pstop int) {
wg.Add(1)
go func() {
defer wg.Done()
fn(pstart, pstop)
}()
})
wg.Wait()
}
|
go
|
func parallelize(enabled bool, start, stop int, fn func(start, stop int)) {
procs := 1
if enabled {
procs = runtime.GOMAXPROCS(0)
}
var wg sync.WaitGroup
splitRange(start, stop, procs, func(pstart, pstop int) {
wg.Add(1)
go func() {
defer wg.Done()
fn(pstart, pstop)
}()
})
wg.Wait()
}
|
[
"func",
"parallelize",
"(",
"enabled",
"bool",
",",
"start",
",",
"stop",
"int",
",",
"fn",
"func",
"(",
"start",
",",
"stop",
"int",
")",
")",
"{",
"procs",
":=",
"1",
"\n",
"if",
"enabled",
"{",
"procs",
"=",
"runtime",
".",
"GOMAXPROCS",
"(",
"0",
")",
"\n",
"}",
"\n",
"var",
"wg",
"sync",
".",
"WaitGroup",
"\n",
"splitRange",
"(",
"start",
",",
"stop",
",",
"procs",
",",
"func",
"(",
"pstart",
",",
"pstop",
"int",
")",
"{",
"wg",
".",
"Add",
"(",
"1",
")",
"\n",
"go",
"func",
"(",
")",
"{",
"defer",
"wg",
".",
"Done",
"(",
")",
"\n",
"fn",
"(",
"pstart",
",",
"pstop",
")",
"\n",
"}",
"(",
")",
"\n",
"}",
")",
"\n",
"wg",
".",
"Wait",
"(",
")",
"\n",
"}"
] |
// parallelize parallelizes the data processing.
|
[
"parallelize",
"parallelizes",
"the",
"data",
"processing",
"."
] |
5c2e6f4a91b12ffcb309b7602c01be3a2ba55543
|
https://github.com/disintegration/gift/blob/5c2e6f4a91b12ffcb309b7602c01be3a2ba55543/utils.go#L12-L26
|
6,075 |
disintegration/gift
|
utils.go
|
splitRange
|
func splitRange(start, stop, n int, fn func(pstart, pstop int)) {
count := stop - start
if count < 1 {
return
}
if n < 1 {
n = 1
}
if n > count {
n = count
}
div := count / n
mod := count % n
for i := 0; i < n; i++ {
fn(
start+i*div+minint(i, mod),
start+(i+1)*div+minint(i+1, mod),
)
}
}
|
go
|
func splitRange(start, stop, n int, fn func(pstart, pstop int)) {
count := stop - start
if count < 1 {
return
}
if n < 1 {
n = 1
}
if n > count {
n = count
}
div := count / n
mod := count % n
for i := 0; i < n; i++ {
fn(
start+i*div+minint(i, mod),
start+(i+1)*div+minint(i+1, mod),
)
}
}
|
[
"func",
"splitRange",
"(",
"start",
",",
"stop",
",",
"n",
"int",
",",
"fn",
"func",
"(",
"pstart",
",",
"pstop",
"int",
")",
")",
"{",
"count",
":=",
"stop",
"-",
"start",
"\n",
"if",
"count",
"<",
"1",
"{",
"return",
"\n",
"}",
"\n\n",
"if",
"n",
"<",
"1",
"{",
"n",
"=",
"1",
"\n",
"}",
"\n",
"if",
"n",
">",
"count",
"{",
"n",
"=",
"count",
"\n",
"}",
"\n\n",
"div",
":=",
"count",
"/",
"n",
"\n",
"mod",
":=",
"count",
"%",
"n",
"\n\n",
"for",
"i",
":=",
"0",
";",
"i",
"<",
"n",
";",
"i",
"++",
"{",
"fn",
"(",
"start",
"+",
"i",
"*",
"div",
"+",
"minint",
"(",
"i",
",",
"mod",
")",
",",
"start",
"+",
"(",
"i",
"+",
"1",
")",
"*",
"div",
"+",
"minint",
"(",
"i",
"+",
"1",
",",
"mod",
")",
",",
")",
"\n",
"}",
"\n",
"}"
] |
// splitRange splits a range into n parts and calls a function for each of them.
|
[
"splitRange",
"splits",
"a",
"range",
"into",
"n",
"parts",
"and",
"calls",
"a",
"function",
"for",
"each",
"of",
"them",
"."
] |
5c2e6f4a91b12ffcb309b7602c01be3a2ba55543
|
https://github.com/disintegration/gift/blob/5c2e6f4a91b12ffcb309b7602c01be3a2ba55543/utils.go#L29-L51
|
6,076 |
disintegration/gift
|
utils.go
|
isOpaque
|
func isOpaque(img image.Image) bool {
type opaquer interface {
Opaque() bool
}
if o, ok := img.(opaquer); ok {
return o.Opaque()
}
return false
}
|
go
|
func isOpaque(img image.Image) bool {
type opaquer interface {
Opaque() bool
}
if o, ok := img.(opaquer); ok {
return o.Opaque()
}
return false
}
|
[
"func",
"isOpaque",
"(",
"img",
"image",
".",
"Image",
")",
"bool",
"{",
"type",
"opaquer",
"interface",
"{",
"Opaque",
"(",
")",
"bool",
"\n",
"}",
"\n",
"if",
"o",
",",
"ok",
":=",
"img",
".",
"(",
"opaquer",
")",
";",
"ok",
"{",
"return",
"o",
".",
"Opaque",
"(",
")",
"\n",
"}",
"\n",
"return",
"false",
"\n",
"}"
] |
// isOpaque checks if the given image is opaque.
|
[
"isOpaque",
"checks",
"if",
"the",
"given",
"image",
"is",
"opaque",
"."
] |
5c2e6f4a91b12ffcb309b7602c01be3a2ba55543
|
https://github.com/disintegration/gift/blob/5c2e6f4a91b12ffcb309b7602c01be3a2ba55543/utils.go#L162-L170
|
6,077 |
disintegration/gift
|
utils.go
|
genDisk
|
func genDisk(ksize int) []float32 {
if ksize%2 == 0 {
ksize--
}
if ksize < 1 {
return []float32{}
}
disk := make([]float32, ksize*ksize)
kcenter := ksize / 2
for i := 0; i < ksize; i++ {
for j := 0; j < ksize; j++ {
x := kcenter - i
y := kcenter - j
r := math.Sqrt(float64(x*x + y*y))
if r <= float64(ksize/2) {
disk[j*ksize+i] = 1
}
}
}
return disk
}
|
go
|
func genDisk(ksize int) []float32 {
if ksize%2 == 0 {
ksize--
}
if ksize < 1 {
return []float32{}
}
disk := make([]float32, ksize*ksize)
kcenter := ksize / 2
for i := 0; i < ksize; i++ {
for j := 0; j < ksize; j++ {
x := kcenter - i
y := kcenter - j
r := math.Sqrt(float64(x*x + y*y))
if r <= float64(ksize/2) {
disk[j*ksize+i] = 1
}
}
}
return disk
}
|
[
"func",
"genDisk",
"(",
"ksize",
"int",
")",
"[",
"]",
"float32",
"{",
"if",
"ksize",
"%",
"2",
"==",
"0",
"{",
"ksize",
"--",
"\n",
"}",
"\n",
"if",
"ksize",
"<",
"1",
"{",
"return",
"[",
"]",
"float32",
"{",
"}",
"\n",
"}",
"\n",
"disk",
":=",
"make",
"(",
"[",
"]",
"float32",
",",
"ksize",
"*",
"ksize",
")",
"\n",
"kcenter",
":=",
"ksize",
"/",
"2",
"\n",
"for",
"i",
":=",
"0",
";",
"i",
"<",
"ksize",
";",
"i",
"++",
"{",
"for",
"j",
":=",
"0",
";",
"j",
"<",
"ksize",
";",
"j",
"++",
"{",
"x",
":=",
"kcenter",
"-",
"i",
"\n",
"y",
":=",
"kcenter",
"-",
"j",
"\n",
"r",
":=",
"math",
".",
"Sqrt",
"(",
"float64",
"(",
"x",
"*",
"x",
"+",
"y",
"*",
"y",
")",
")",
"\n",
"if",
"r",
"<=",
"float64",
"(",
"ksize",
"/",
"2",
")",
"{",
"disk",
"[",
"j",
"*",
"ksize",
"+",
"i",
"]",
"=",
"1",
"\n",
"}",
"\n",
"}",
"\n",
"}",
"\n",
"return",
"disk",
"\n",
"}"
] |
// genDisk generates a disk-shaped kernel.
|
[
"genDisk",
"generates",
"a",
"disk",
"-",
"shaped",
"kernel",
"."
] |
5c2e6f4a91b12ffcb309b7602c01be3a2ba55543
|
https://github.com/disintegration/gift/blob/5c2e6f4a91b12ffcb309b7602c01be3a2ba55543/utils.go#L173-L193
|
6,078 |
creasty/defaults
|
defaults.go
|
Set
|
func Set(ptr interface{}) error {
if reflect.TypeOf(ptr).Kind() != reflect.Ptr {
return errInvalidType
}
v := reflect.ValueOf(ptr).Elem()
t := v.Type()
if t.Kind() != reflect.Struct {
return errInvalidType
}
for i := 0; i < t.NumField(); i++ {
if defaultVal := t.Field(i).Tag.Get(fieldName); defaultVal != "-" {
if err := setField(v.Field(i), defaultVal); err != nil {
return err
}
}
}
return nil
}
|
go
|
func Set(ptr interface{}) error {
if reflect.TypeOf(ptr).Kind() != reflect.Ptr {
return errInvalidType
}
v := reflect.ValueOf(ptr).Elem()
t := v.Type()
if t.Kind() != reflect.Struct {
return errInvalidType
}
for i := 0; i < t.NumField(); i++ {
if defaultVal := t.Field(i).Tag.Get(fieldName); defaultVal != "-" {
if err := setField(v.Field(i), defaultVal); err != nil {
return err
}
}
}
return nil
}
|
[
"func",
"Set",
"(",
"ptr",
"interface",
"{",
"}",
")",
"error",
"{",
"if",
"reflect",
".",
"TypeOf",
"(",
"ptr",
")",
".",
"Kind",
"(",
")",
"!=",
"reflect",
".",
"Ptr",
"{",
"return",
"errInvalidType",
"\n",
"}",
"\n\n",
"v",
":=",
"reflect",
".",
"ValueOf",
"(",
"ptr",
")",
".",
"Elem",
"(",
")",
"\n",
"t",
":=",
"v",
".",
"Type",
"(",
")",
"\n\n",
"if",
"t",
".",
"Kind",
"(",
")",
"!=",
"reflect",
".",
"Struct",
"{",
"return",
"errInvalidType",
"\n",
"}",
"\n\n",
"for",
"i",
":=",
"0",
";",
"i",
"<",
"t",
".",
"NumField",
"(",
")",
";",
"i",
"++",
"{",
"if",
"defaultVal",
":=",
"t",
".",
"Field",
"(",
"i",
")",
".",
"Tag",
".",
"Get",
"(",
"fieldName",
")",
";",
"defaultVal",
"!=",
"\"",
"\"",
"{",
"if",
"err",
":=",
"setField",
"(",
"v",
".",
"Field",
"(",
"i",
")",
",",
"defaultVal",
")",
";",
"err",
"!=",
"nil",
"{",
"return",
"err",
"\n",
"}",
"\n",
"}",
"\n",
"}",
"\n\n",
"return",
"nil",
"\n",
"}"
] |
// Set initializes members in a struct referenced by a pointer.
// Maps and slices are initialized by `make` and other primitive types are set with default values.
// `ptr` should be a struct pointer
|
[
"Set",
"initializes",
"members",
"in",
"a",
"struct",
"referenced",
"by",
"a",
"pointer",
".",
"Maps",
"and",
"slices",
"are",
"initialized",
"by",
"make",
"and",
"other",
"primitive",
"types",
"are",
"set",
"with",
"default",
"values",
".",
"ptr",
"should",
"be",
"a",
"struct",
"pointer"
] |
edf4f6a95a3223dfff4eff2c404103e756fef68d
|
https://github.com/creasty/defaults/blob/edf4f6a95a3223dfff4eff2c404103e756fef68d/defaults.go#L22-L43
|
6,079 |
mat/besticon
|
besticon/besticon.go
|
SetLogOutput
|
func SetLogOutput(w io.Writer) {
logger = log.New(w, "http: ", log.LstdFlags|log.Lmicroseconds)
}
|
go
|
func SetLogOutput(w io.Writer) {
logger = log.New(w, "http: ", log.LstdFlags|log.Lmicroseconds)
}
|
[
"func",
"SetLogOutput",
"(",
"w",
"io",
".",
"Writer",
")",
"{",
"logger",
"=",
"log",
".",
"New",
"(",
"w",
",",
"\"",
"\"",
",",
"log",
".",
"LstdFlags",
"|",
"log",
".",
"Lmicroseconds",
")",
"\n",
"}"
] |
// SetLogOutput sets the output for the package's logger.
|
[
"SetLogOutput",
"sets",
"the",
"output",
"for",
"the",
"package",
"s",
"logger",
"."
] |
8d6f841790b47dbcab3399592f065e53a56ec2b7
|
https://github.com/mat/besticon/blob/8d6f841790b47dbcab3399592f065e53a56ec2b7/besticon/besticon.go#L553-L555
|
6,080 |
mat/besticon
|
besticon/caching.go
|
SetCacheMaxSize
|
func SetCacheMaxSize(sizeInMB int64) {
if sizeInMB > 0 {
iconCache = groupcache.NewGroup("icons", sizeInMB<<20, groupcache.GetterFunc(generatorFunc))
} else {
iconCache = nil
}
}
|
go
|
func SetCacheMaxSize(sizeInMB int64) {
if sizeInMB > 0 {
iconCache = groupcache.NewGroup("icons", sizeInMB<<20, groupcache.GetterFunc(generatorFunc))
} else {
iconCache = nil
}
}
|
[
"func",
"SetCacheMaxSize",
"(",
"sizeInMB",
"int64",
")",
"{",
"if",
"sizeInMB",
">",
"0",
"{",
"iconCache",
"=",
"groupcache",
".",
"NewGroup",
"(",
"\"",
"\"",
",",
"sizeInMB",
"<<",
"20",
",",
"groupcache",
".",
"GetterFunc",
"(",
"generatorFunc",
")",
")",
"\n",
"}",
"else",
"{",
"iconCache",
"=",
"nil",
"\n",
"}",
"\n",
"}"
] |
// SetCacheMaxSize enables icon caching if sizeInMB > 0.
|
[
"SetCacheMaxSize",
"enables",
"icon",
"caching",
"if",
"sizeInMB",
">",
"0",
"."
] |
8d6f841790b47dbcab3399592f065e53a56ec2b7
|
https://github.com/mat/besticon/blob/8d6f841790b47dbcab3399592f065e53a56ec2b7/besticon/caching.go#L72-L78
|
6,081 |
mat/besticon
|
besticon/size_range.go
|
ParseSizeRange
|
func ParseSizeRange(s string) (*SizeRange, error) {
parts := strings.SplitN(s, "..", 3)
switch len(parts) {
case 1:
size, ok := parseSize(parts[0])
if !ok {
return nil, errBadSize
}
return &SizeRange{size, size, MaxIconSize}, 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
}
|
go
|
func ParseSizeRange(s string) (*SizeRange, error) {
parts := strings.SplitN(s, "..", 3)
switch len(parts) {
case 1:
size, ok := parseSize(parts[0])
if !ok {
return nil, errBadSize
}
return &SizeRange{size, size, MaxIconSize}, 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
}
|
[
"func",
"ParseSizeRange",
"(",
"s",
"string",
")",
"(",
"*",
"SizeRange",
",",
"error",
")",
"{",
"parts",
":=",
"strings",
".",
"SplitN",
"(",
"s",
",",
"\"",
"\"",
",",
"3",
")",
"\n",
"switch",
"len",
"(",
"parts",
")",
"{",
"case",
"1",
":",
"size",
",",
"ok",
":=",
"parseSize",
"(",
"parts",
"[",
"0",
"]",
")",
"\n",
"if",
"!",
"ok",
"{",
"return",
"nil",
",",
"errBadSize",
"\n",
"}",
"\n",
"return",
"&",
"SizeRange",
"{",
"size",
",",
"size",
",",
"MaxIconSize",
"}",
",",
"nil",
"\n",
"case",
"3",
":",
"n1",
",",
"ok1",
":=",
"parseSize",
"(",
"parts",
"[",
"0",
"]",
")",
"\n",
"n2",
",",
"ok2",
":=",
"parseSize",
"(",
"parts",
"[",
"1",
"]",
")",
"\n",
"n3",
",",
"ok3",
":=",
"parseSize",
"(",
"parts",
"[",
"2",
"]",
")",
"\n",
"if",
"!",
"ok1",
"||",
"!",
"ok2",
"||",
"!",
"ok3",
"{",
"return",
"nil",
",",
"errBadSize",
"\n",
"}",
"\n",
"if",
"!",
"(",
"(",
"n1",
"<=",
"n2",
")",
"&&",
"(",
"n2",
"<=",
"n3",
")",
")",
"{",
"return",
"nil",
",",
"errBadSize",
"\n",
"}",
"\n",
"return",
"&",
"SizeRange",
"{",
"n1",
",",
"n2",
",",
"n3",
"}",
",",
"nil",
"\n",
"}",
"\n\n",
"return",
"nil",
",",
"errBadSize",
"\n",
"}"
] |
// ParseSizeRange parses a string like 60..100..200 into a SizeRange
|
[
"ParseSizeRange",
"parses",
"a",
"string",
"like",
"60",
"..",
"100",
"..",
"200",
"into",
"a",
"SizeRange"
] |
8d6f841790b47dbcab3399592f065e53a56ec2b7
|
https://github.com/mat/besticon/blob/8d6f841790b47dbcab3399592f065e53a56ec2b7/besticon/size_range.go#L19-L42
|
6,082 |
mat/besticon
|
colorfinder/colorfinder.go
|
FindMainColor
|
func (cf *ColorFinder) FindMainColor(img image.Image) (color.RGBA, error) {
cf.img = img
colorMap := cf.buildColorMap()
sRGB := cf.findMainColor(colorMap, 6, nil)
sRGB = cf.findMainColor(colorMap, 4, &sRGB)
sRGB = cf.findMainColor(colorMap, 2, &sRGB)
sRGB = cf.findMainColor(colorMap, 0, &sRGB)
return sRGB.rgb, nil
}
|
go
|
func (cf *ColorFinder) FindMainColor(img image.Image) (color.RGBA, error) {
cf.img = img
colorMap := cf.buildColorMap()
sRGB := cf.findMainColor(colorMap, 6, nil)
sRGB = cf.findMainColor(colorMap, 4, &sRGB)
sRGB = cf.findMainColor(colorMap, 2, &sRGB)
sRGB = cf.findMainColor(colorMap, 0, &sRGB)
return sRGB.rgb, nil
}
|
[
"func",
"(",
"cf",
"*",
"ColorFinder",
")",
"FindMainColor",
"(",
"img",
"image",
".",
"Image",
")",
"(",
"color",
".",
"RGBA",
",",
"error",
")",
"{",
"cf",
".",
"img",
"=",
"img",
"\n\n",
"colorMap",
":=",
"cf",
".",
"buildColorMap",
"(",
")",
"\n\n",
"sRGB",
":=",
"cf",
".",
"findMainColor",
"(",
"colorMap",
",",
"6",
",",
"nil",
")",
"\n",
"sRGB",
"=",
"cf",
".",
"findMainColor",
"(",
"colorMap",
",",
"4",
",",
"&",
"sRGB",
")",
"\n",
"sRGB",
"=",
"cf",
".",
"findMainColor",
"(",
"colorMap",
",",
"2",
",",
"&",
"sRGB",
")",
"\n",
"sRGB",
"=",
"cf",
".",
"findMainColor",
"(",
"colorMap",
",",
"0",
",",
"&",
"sRGB",
")",
"\n\n",
"return",
"sRGB",
".",
"rgb",
",",
"nil",
"\n",
"}"
] |
// FindMainColor tries to identify the most important color in the given logo.
|
[
"FindMainColor",
"tries",
"to",
"identify",
"the",
"most",
"important",
"color",
"in",
"the",
"given",
"logo",
"."
] |
8d6f841790b47dbcab3399592f065e53a56ec2b7
|
https://github.com/mat/besticon/blob/8d6f841790b47dbcab3399592f065e53a56ec2b7/colorfinder/colorfinder.go#L64-L75
|
6,083 |
mat/besticon
|
ico/ico.go
|
ParseIco
|
func ParseIco(r io.Reader) (*icondir, error) {
dir := icondir{}
var err error
err = binary.Read(r, binary.LittleEndian, &dir.Reserved)
if err != nil {
return nil, err
}
err = binary.Read(r, binary.LittleEndian, &dir.Type)
if err != nil {
return nil, err
}
err = binary.Read(r, binary.LittleEndian, &dir.Count)
if err != nil {
return nil, err
}
for 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
}
|
go
|
func ParseIco(r io.Reader) (*icondir, error) {
dir := icondir{}
var err error
err = binary.Read(r, binary.LittleEndian, &dir.Reserved)
if err != nil {
return nil, err
}
err = binary.Read(r, binary.LittleEndian, &dir.Type)
if err != nil {
return nil, err
}
err = binary.Read(r, binary.LittleEndian, &dir.Count)
if err != nil {
return nil, err
}
for 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
}
|
[
"func",
"ParseIco",
"(",
"r",
"io",
".",
"Reader",
")",
"(",
"*",
"icondir",
",",
"error",
")",
"{",
"dir",
":=",
"icondir",
"{",
"}",
"\n\n",
"var",
"err",
"error",
"\n",
"err",
"=",
"binary",
".",
"Read",
"(",
"r",
",",
"binary",
".",
"LittleEndian",
",",
"&",
"dir",
".",
"Reserved",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"return",
"nil",
",",
"err",
"\n",
"}",
"\n\n",
"err",
"=",
"binary",
".",
"Read",
"(",
"r",
",",
"binary",
".",
"LittleEndian",
",",
"&",
"dir",
".",
"Type",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"return",
"nil",
",",
"err",
"\n",
"}",
"\n\n",
"err",
"=",
"binary",
".",
"Read",
"(",
"r",
",",
"binary",
".",
"LittleEndian",
",",
"&",
"dir",
".",
"Count",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"return",
"nil",
",",
"err",
"\n",
"}",
"\n\n",
"for",
"i",
":=",
"uint16",
"(",
"0",
")",
";",
"i",
"<",
"dir",
".",
"Count",
";",
"i",
"++",
"{",
"entry",
":=",
"icondirEntry",
"{",
"}",
"\n",
"e",
":=",
"parseIcondirEntry",
"(",
"r",
",",
"&",
"entry",
")",
"\n",
"if",
"e",
"!=",
"nil",
"{",
"return",
"nil",
",",
"e",
"\n",
"}",
"\n",
"dir",
".",
"Entries",
"=",
"append",
"(",
"dir",
".",
"Entries",
",",
"entry",
")",
"\n",
"}",
"\n\n",
"return",
"&",
"dir",
",",
"err",
"\n",
"}"
] |
// ParseIco parses the icon and returns meta information for the icons as icondir.
|
[
"ParseIco",
"parses",
"the",
"icon",
"and",
"returns",
"meta",
"information",
"for",
"the",
"icons",
"as",
"icondir",
"."
] |
8d6f841790b47dbcab3399592f065e53a56ec2b7
|
https://github.com/mat/besticon/blob/8d6f841790b47dbcab3399592f065e53a56ec2b7/ico/ico.go#L51-L80
|
6,084 |
mat/besticon
|
ico/ico.go
|
DecodeConfig
|
func DecodeConfig(r io.Reader) (image.Config, error) {
dir, err := ParseIco(r)
if err != nil {
return image.Config{}, err
}
best := dir.FindBestIcon()
if best == nil {
return image.Config{}, errInvalid
}
return image.Config{Width: best.width(), Height: best.height()}, nil
}
|
go
|
func DecodeConfig(r io.Reader) (image.Config, error) {
dir, err := ParseIco(r)
if err != nil {
return image.Config{}, err
}
best := dir.FindBestIcon()
if best == nil {
return image.Config{}, errInvalid
}
return image.Config{Width: best.width(), Height: best.height()}, nil
}
|
[
"func",
"DecodeConfig",
"(",
"r",
"io",
".",
"Reader",
")",
"(",
"image",
".",
"Config",
",",
"error",
")",
"{",
"dir",
",",
"err",
":=",
"ParseIco",
"(",
"r",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"return",
"image",
".",
"Config",
"{",
"}",
",",
"err",
"\n",
"}",
"\n\n",
"best",
":=",
"dir",
".",
"FindBestIcon",
"(",
")",
"\n",
"if",
"best",
"==",
"nil",
"{",
"return",
"image",
".",
"Config",
"{",
"}",
",",
"errInvalid",
"\n",
"}",
"\n",
"return",
"image",
".",
"Config",
"{",
"Width",
":",
"best",
".",
"width",
"(",
")",
",",
"Height",
":",
"best",
".",
"height",
"(",
")",
"}",
",",
"nil",
"\n",
"}"
] |
// DecodeConfig returns just the dimensions of the largest image
// contained in the icon withou decoding the entire icon file.
|
[
"DecodeConfig",
"returns",
"just",
"the",
"dimensions",
"of",
"the",
"largest",
"image",
"contained",
"in",
"the",
"icon",
"withou",
"decoding",
"the",
"entire",
"icon",
"file",
"."
] |
8d6f841790b47dbcab3399592f065e53a56ec2b7
|
https://github.com/mat/besticon/blob/8d6f841790b47dbcab3399592f065e53a56ec2b7/ico/ico.go#L120-L131
|
6,085 |
mat/besticon
|
ico/ico.go
|
Decode
|
func Decode(r io.Reader) (image.Image, error) {
icoBytes, err := ioutil.ReadAll(r)
if err != nil {
return nil, err
}
r = bytes.NewReader(icoBytes)
dir, err := ParseIco(r)
if err != nil {
return nil, errInvalid
}
best := dir.FindBestIcon()
if best == nil {
return nil, errInvalid
}
return parseImage(best, icoBytes)
}
|
go
|
func Decode(r io.Reader) (image.Image, error) {
icoBytes, err := ioutil.ReadAll(r)
if err != nil {
return nil, err
}
r = bytes.NewReader(icoBytes)
dir, err := ParseIco(r)
if err != nil {
return nil, errInvalid
}
best := dir.FindBestIcon()
if best == nil {
return nil, errInvalid
}
return parseImage(best, icoBytes)
}
|
[
"func",
"Decode",
"(",
"r",
"io",
".",
"Reader",
")",
"(",
"image",
".",
"Image",
",",
"error",
")",
"{",
"icoBytes",
",",
"err",
":=",
"ioutil",
".",
"ReadAll",
"(",
"r",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"return",
"nil",
",",
"err",
"\n",
"}",
"\n\n",
"r",
"=",
"bytes",
".",
"NewReader",
"(",
"icoBytes",
")",
"\n",
"dir",
",",
"err",
":=",
"ParseIco",
"(",
"r",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"return",
"nil",
",",
"errInvalid",
"\n",
"}",
"\n\n",
"best",
":=",
"dir",
".",
"FindBestIcon",
"(",
")",
"\n",
"if",
"best",
"==",
"nil",
"{",
"return",
"nil",
",",
"errInvalid",
"\n",
"}",
"\n\n",
"return",
"parseImage",
"(",
"best",
",",
"icoBytes",
")",
"\n",
"}"
] |
// Decode returns the largest image contained in the icon
// which might be a bmp or png
|
[
"Decode",
"returns",
"the",
"largest",
"image",
"contained",
"in",
"the",
"icon",
"which",
"might",
"be",
"a",
"bmp",
"or",
"png"
] |
8d6f841790b47dbcab3399592f065e53a56ec2b7
|
https://github.com/mat/besticon/blob/8d6f841790b47dbcab3399592f065e53a56ec2b7/ico/ico.go#L171-L189
|
6,086 |
google/gofuzz
|
fuzz.go
|
RandSource
|
func (f *Fuzzer) RandSource(s rand.Source) *Fuzzer {
f.r = rand.New(s)
return f
}
|
go
|
func (f *Fuzzer) RandSource(s rand.Source) *Fuzzer {
f.r = rand.New(s)
return f
}
|
[
"func",
"(",
"f",
"*",
"Fuzzer",
")",
"RandSource",
"(",
"s",
"rand",
".",
"Source",
")",
"*",
"Fuzzer",
"{",
"f",
".",
"r",
"=",
"rand",
".",
"New",
"(",
"s",
")",
"\n",
"return",
"f",
"\n",
"}"
] |
// RandSource causes f to get values from the given source of randomness.
// Use if you want deterministic fuzzing.
|
[
"RandSource",
"causes",
"f",
"to",
"get",
"values",
"from",
"the",
"given",
"source",
"of",
"randomness",
".",
"Use",
"if",
"you",
"want",
"deterministic",
"fuzzing",
"."
] |
f140a6486e521aad38f5917de355cbf147cc0496
|
https://github.com/google/gofuzz/blob/f140a6486e521aad38f5917de355cbf147cc0496/fuzz.go#L105-L108
|
6,087 |
google/gofuzz
|
fuzz.go
|
NumElements
|
func (f *Fuzzer) NumElements(atLeast, atMost int) *Fuzzer {
if atLeast > atMost {
panic("atLeast must be <= atMost")
}
if atLeast < 0 {
panic("atLeast must be >= 0")
}
f.minElements = atLeast
f.maxElements = atMost
return f
}
|
go
|
func (f *Fuzzer) NumElements(atLeast, atMost int) *Fuzzer {
if atLeast > atMost {
panic("atLeast must be <= atMost")
}
if atLeast < 0 {
panic("atLeast must be >= 0")
}
f.minElements = atLeast
f.maxElements = atMost
return f
}
|
[
"func",
"(",
"f",
"*",
"Fuzzer",
")",
"NumElements",
"(",
"atLeast",
",",
"atMost",
"int",
")",
"*",
"Fuzzer",
"{",
"if",
"atLeast",
">",
"atMost",
"{",
"panic",
"(",
"\"",
"\"",
")",
"\n",
"}",
"\n",
"if",
"atLeast",
"<",
"0",
"{",
"panic",
"(",
"\"",
"\"",
")",
"\n",
"}",
"\n",
"f",
".",
"minElements",
"=",
"atLeast",
"\n",
"f",
".",
"maxElements",
"=",
"atMost",
"\n",
"return",
"f",
"\n",
"}"
] |
// NumElements sets the minimum and maximum number of elements that will be
// added to a non-nil map or slice.
|
[
"NumElements",
"sets",
"the",
"minimum",
"and",
"maximum",
"number",
"of",
"elements",
"that",
"will",
"be",
"added",
"to",
"a",
"non",
"-",
"nil",
"map",
"or",
"slice",
"."
] |
f140a6486e521aad38f5917de355cbf147cc0496
|
https://github.com/google/gofuzz/blob/f140a6486e521aad38f5917de355cbf147cc0496/fuzz.go#L122-L132
|
6,088 |
google/gofuzz
|
fuzz.go
|
MaxDepth
|
func (f *Fuzzer) MaxDepth(d int) *Fuzzer {
f.maxDepth = d
return f
}
|
go
|
func (f *Fuzzer) MaxDepth(d int) *Fuzzer {
f.maxDepth = d
return f
}
|
[
"func",
"(",
"f",
"*",
"Fuzzer",
")",
"MaxDepth",
"(",
"d",
"int",
")",
"*",
"Fuzzer",
"{",
"f",
".",
"maxDepth",
"=",
"d",
"\n",
"return",
"f",
"\n",
"}"
] |
// MaxDepth sets the maximum number of recursive fuzz calls that will be made
// before stopping. This includes struct members, pointers, and map and slice
// elements.
|
[
"MaxDepth",
"sets",
"the",
"maximum",
"number",
"of",
"recursive",
"fuzz",
"calls",
"that",
"will",
"be",
"made",
"before",
"stopping",
".",
"This",
"includes",
"struct",
"members",
"pointers",
"and",
"map",
"and",
"slice",
"elements",
"."
] |
f140a6486e521aad38f5917de355cbf147cc0496
|
https://github.com/google/gofuzz/blob/f140a6486e521aad38f5917de355cbf147cc0496/fuzz.go#L148-L151
|
6,089 |
google/gofuzz
|
fuzz.go
|
tryCustom
|
func (fc *fuzzerContext) tryCustom(v reflect.Value) bool {
// First: see if we have a fuzz function for it.
doCustom, ok := fc.fuzzer.fuzzFuncs[v.Type()]
if !ok {
// Second: see if it can fuzz itself.
if v.CanInterface() {
intf := v.Interface()
if fuzzable, ok := intf.(Interface); ok {
fuzzable.Fuzz(Continue{fc: fc, Rand: fc.fuzzer.r})
return true
}
}
// 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() {
if !v.CanSet() {
return false
}
v.Set(reflect.MakeMap(v.Type()))
}
default:
return false
}
doCustom.Call([]reflect.Value{v, reflect.ValueOf(Continue{
fc: fc,
Rand: fc.fuzzer.r,
})})
return true
}
|
go
|
func (fc *fuzzerContext) tryCustom(v reflect.Value) bool {
// First: see if we have a fuzz function for it.
doCustom, ok := fc.fuzzer.fuzzFuncs[v.Type()]
if !ok {
// Second: see if it can fuzz itself.
if v.CanInterface() {
intf := v.Interface()
if fuzzable, ok := intf.(Interface); ok {
fuzzable.Fuzz(Continue{fc: fc, Rand: fc.fuzzer.r})
return true
}
}
// 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() {
if !v.CanSet() {
return false
}
v.Set(reflect.MakeMap(v.Type()))
}
default:
return false
}
doCustom.Call([]reflect.Value{v, reflect.ValueOf(Continue{
fc: fc,
Rand: fc.fuzzer.r,
})})
return true
}
|
[
"func",
"(",
"fc",
"*",
"fuzzerContext",
")",
"tryCustom",
"(",
"v",
"reflect",
".",
"Value",
")",
"bool",
"{",
"// First: see if we have a fuzz function for it.",
"doCustom",
",",
"ok",
":=",
"fc",
".",
"fuzzer",
".",
"fuzzFuncs",
"[",
"v",
".",
"Type",
"(",
")",
"]",
"\n",
"if",
"!",
"ok",
"{",
"// Second: see if it can fuzz itself.",
"if",
"v",
".",
"CanInterface",
"(",
")",
"{",
"intf",
":=",
"v",
".",
"Interface",
"(",
")",
"\n",
"if",
"fuzzable",
",",
"ok",
":=",
"intf",
".",
"(",
"Interface",
")",
";",
"ok",
"{",
"fuzzable",
".",
"Fuzz",
"(",
"Continue",
"{",
"fc",
":",
"fc",
",",
"Rand",
":",
"fc",
".",
"fuzzer",
".",
"r",
"}",
")",
"\n",
"return",
"true",
"\n",
"}",
"\n",
"}",
"\n",
"// Finally: see if there is a default fuzz function.",
"doCustom",
",",
"ok",
"=",
"fc",
".",
"fuzzer",
".",
"defaultFuzzFuncs",
"[",
"v",
".",
"Type",
"(",
")",
"]",
"\n",
"if",
"!",
"ok",
"{",
"return",
"false",
"\n",
"}",
"\n",
"}",
"\n\n",
"switch",
"v",
".",
"Kind",
"(",
")",
"{",
"case",
"reflect",
".",
"Ptr",
":",
"if",
"v",
".",
"IsNil",
"(",
")",
"{",
"if",
"!",
"v",
".",
"CanSet",
"(",
")",
"{",
"return",
"false",
"\n",
"}",
"\n",
"v",
".",
"Set",
"(",
"reflect",
".",
"New",
"(",
"v",
".",
"Type",
"(",
")",
".",
"Elem",
"(",
")",
")",
")",
"\n",
"}",
"\n",
"case",
"reflect",
".",
"Map",
":",
"if",
"v",
".",
"IsNil",
"(",
")",
"{",
"if",
"!",
"v",
".",
"CanSet",
"(",
")",
"{",
"return",
"false",
"\n",
"}",
"\n",
"v",
".",
"Set",
"(",
"reflect",
".",
"MakeMap",
"(",
"v",
".",
"Type",
"(",
")",
")",
")",
"\n",
"}",
"\n",
"default",
":",
"return",
"false",
"\n",
"}",
"\n\n",
"doCustom",
".",
"Call",
"(",
"[",
"]",
"reflect",
".",
"Value",
"{",
"v",
",",
"reflect",
".",
"ValueOf",
"(",
"Continue",
"{",
"fc",
":",
"fc",
",",
"Rand",
":",
"fc",
".",
"fuzzer",
".",
"r",
",",
"}",
")",
"}",
")",
"\n",
"return",
"true",
"\n",
"}"
] |
// tryCustom searches for custom handlers, and returns true iff it finds a match
// and successfully randomizes v.
|
[
"tryCustom",
"searches",
"for",
"custom",
"handlers",
"and",
"returns",
"true",
"iff",
"it",
"finds",
"a",
"match",
"and",
"successfully",
"randomizes",
"v",
"."
] |
f140a6486e521aad38f5917de355cbf147cc0496
|
https://github.com/google/gofuzz/blob/f140a6486e521aad38f5917de355cbf147cc0496/fuzz.go#L292-L335
|
6,090 |
google/gofuzz
|
fuzz.go
|
Fuzz
|
func (c Continue) Fuzz(obj interface{}) {
v := reflect.ValueOf(obj)
if v.Kind() != reflect.Ptr {
panic("needed ptr!")
}
v = v.Elem()
c.fc.doFuzz(v, 0)
}
|
go
|
func (c Continue) Fuzz(obj interface{}) {
v := reflect.ValueOf(obj)
if v.Kind() != reflect.Ptr {
panic("needed ptr!")
}
v = v.Elem()
c.fc.doFuzz(v, 0)
}
|
[
"func",
"(",
"c",
"Continue",
")",
"Fuzz",
"(",
"obj",
"interface",
"{",
"}",
")",
"{",
"v",
":=",
"reflect",
".",
"ValueOf",
"(",
"obj",
")",
"\n",
"if",
"v",
".",
"Kind",
"(",
")",
"!=",
"reflect",
".",
"Ptr",
"{",
"panic",
"(",
"\"",
"\"",
")",
"\n",
"}",
"\n",
"v",
"=",
"v",
".",
"Elem",
"(",
")",
"\n",
"c",
".",
"fc",
".",
"doFuzz",
"(",
"v",
",",
"0",
")",
"\n",
"}"
] |
// Fuzz continues fuzzing obj. obj must be a pointer.
|
[
"Fuzz",
"continues",
"fuzzing",
"obj",
".",
"obj",
"must",
"be",
"a",
"pointer",
"."
] |
f140a6486e521aad38f5917de355cbf147cc0496
|
https://github.com/google/gofuzz/blob/f140a6486e521aad38f5917de355cbf147cc0496/fuzz.go#L356-L363
|
6,091 |
google/gofuzz
|
fuzz.go
|
choose
|
func (r *charRange) choose(rand *rand.Rand) rune {
count := int64(r.last - r.first)
return r.first + rune(rand.Int63n(count))
}
|
go
|
func (r *charRange) choose(rand *rand.Rand) rune {
count := int64(r.last - r.first)
return r.first + rune(rand.Int63n(count))
}
|
[
"func",
"(",
"r",
"*",
"charRange",
")",
"choose",
"(",
"rand",
"*",
"rand",
".",
"Rand",
")",
"rune",
"{",
"count",
":=",
"int64",
"(",
"r",
".",
"last",
"-",
"r",
".",
"first",
")",
"\n",
"return",
"r",
".",
"first",
"+",
"rune",
"(",
"rand",
".",
"Int63n",
"(",
"count",
")",
")",
"\n",
"}"
] |
// choose returns a random unicode character from the given range, using the
// given randomness source.
|
[
"choose",
"returns",
"a",
"random",
"unicode",
"character",
"from",
"the",
"given",
"range",
"using",
"the",
"given",
"randomness",
"source",
"."
] |
f140a6486e521aad38f5917de355cbf147cc0496
|
https://github.com/google/gofuzz/blob/f140a6486e521aad38f5917de355cbf147cc0496/fuzz.go#L461-L464
|
6,092 |
google/gofuzz
|
fuzz.go
|
randUint64
|
func randUint64(r *rand.Rand) uint64 {
return uint64(r.Uint32())<<32 | uint64(r.Uint32())
}
|
go
|
func randUint64(r *rand.Rand) uint64 {
return uint64(r.Uint32())<<32 | uint64(r.Uint32())
}
|
[
"func",
"randUint64",
"(",
"r",
"*",
"rand",
".",
"Rand",
")",
"uint64",
"{",
"return",
"uint64",
"(",
"r",
".",
"Uint32",
"(",
")",
")",
"<<",
"32",
"|",
"uint64",
"(",
"r",
".",
"Uint32",
"(",
")",
")",
"\n",
"}"
] |
// randUint64 makes random 64 bit numbers.
// Weirdly, rand doesn't have a function that gives you 64 random bits.
|
[
"randUint64",
"makes",
"random",
"64",
"bit",
"numbers",
".",
"Weirdly",
"rand",
"doesn",
"t",
"have",
"a",
"function",
"that",
"gives",
"you",
"64",
"random",
"bits",
"."
] |
f140a6486e521aad38f5917de355cbf147cc0496
|
https://github.com/google/gofuzz/blob/f140a6486e521aad38f5917de355cbf147cc0496/fuzz.go#L485-L487
|
6,093 |
google/safebrowsing
|
cache.go
|
Update
|
func (c *cache) Update(req *pb.FindFullHashesRequest, resp *pb.FindFullHashesResponse) {
c.Lock()
defer c.Unlock()
now := c.now()
if c.pttls == nil {
c.pttls = make(map[hashPrefix]map[ThreatDescriptor]time.Time)
c.nttls = make(map[hashPrefix]time.Time)
}
// Insert each threat match into the cache by full hash.
for _, tm := range resp.GetMatches() {
fullHash := hashPrefix(tm.GetThreat().Hash)
if !fullHash.IsFull() {
continue
}
if c.pttls[fullHash] == nil {
c.pttls[fullHash] = make(map[ThreatDescriptor]time.Time)
}
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),
ThreatEntryType: ThreatEntryType(tm.ThreatEntryType),
}
c.pttls[fullHash][td] = now.Add(dur)
}
// Insert negative TTLs for partial hashes.
if resp.GetNegativeCacheDuration() != nil {
dur := time.Duration(resp.GetNegativeCacheDuration().Seconds) * time.Second
nttl := now.Add(dur)
for _, te := range req.GetThreatInfo().GetThreatEntries() {
partialHash := hashPrefix(te.Hash)
c.nttls[partialHash] = nttl
}
}
}
|
go
|
func (c *cache) Update(req *pb.FindFullHashesRequest, resp *pb.FindFullHashesResponse) {
c.Lock()
defer c.Unlock()
now := c.now()
if c.pttls == nil {
c.pttls = make(map[hashPrefix]map[ThreatDescriptor]time.Time)
c.nttls = make(map[hashPrefix]time.Time)
}
// Insert each threat match into the cache by full hash.
for _, tm := range resp.GetMatches() {
fullHash := hashPrefix(tm.GetThreat().Hash)
if !fullHash.IsFull() {
continue
}
if c.pttls[fullHash] == nil {
c.pttls[fullHash] = make(map[ThreatDescriptor]time.Time)
}
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),
ThreatEntryType: ThreatEntryType(tm.ThreatEntryType),
}
c.pttls[fullHash][td] = now.Add(dur)
}
// Insert negative TTLs for partial hashes.
if resp.GetNegativeCacheDuration() != nil {
dur := time.Duration(resp.GetNegativeCacheDuration().Seconds) * time.Second
nttl := now.Add(dur)
for _, te := range req.GetThreatInfo().GetThreatEntries() {
partialHash := hashPrefix(te.Hash)
c.nttls[partialHash] = nttl
}
}
}
|
[
"func",
"(",
"c",
"*",
"cache",
")",
"Update",
"(",
"req",
"*",
"pb",
".",
"FindFullHashesRequest",
",",
"resp",
"*",
"pb",
".",
"FindFullHashesResponse",
")",
"{",
"c",
".",
"Lock",
"(",
")",
"\n",
"defer",
"c",
".",
"Unlock",
"(",
")",
"\n",
"now",
":=",
"c",
".",
"now",
"(",
")",
"\n\n",
"if",
"c",
".",
"pttls",
"==",
"nil",
"{",
"c",
".",
"pttls",
"=",
"make",
"(",
"map",
"[",
"hashPrefix",
"]",
"map",
"[",
"ThreatDescriptor",
"]",
"time",
".",
"Time",
")",
"\n",
"c",
".",
"nttls",
"=",
"make",
"(",
"map",
"[",
"hashPrefix",
"]",
"time",
".",
"Time",
")",
"\n",
"}",
"\n\n",
"// Insert each threat match into the cache by full hash.",
"for",
"_",
",",
"tm",
":=",
"range",
"resp",
".",
"GetMatches",
"(",
")",
"{",
"fullHash",
":=",
"hashPrefix",
"(",
"tm",
".",
"GetThreat",
"(",
")",
".",
"Hash",
")",
"\n",
"if",
"!",
"fullHash",
".",
"IsFull",
"(",
")",
"{",
"continue",
"\n",
"}",
"\n",
"if",
"c",
".",
"pttls",
"[",
"fullHash",
"]",
"==",
"nil",
"{",
"c",
".",
"pttls",
"[",
"fullHash",
"]",
"=",
"make",
"(",
"map",
"[",
"ThreatDescriptor",
"]",
"time",
".",
"Time",
")",
"\n",
"}",
"\n",
"var",
"dur",
"time",
".",
"Duration",
"\n",
"if",
"tmCacheDur",
":=",
"tm",
".",
"GetCacheDuration",
"(",
")",
";",
"tmCacheDur",
"!=",
"nil",
"{",
"dur",
"=",
"time",
".",
"Duration",
"(",
"tm",
".",
"GetCacheDuration",
"(",
")",
".",
"Seconds",
")",
"*",
"time",
".",
"Second",
"\n",
"}",
"else",
"{",
"dur",
"=",
"0",
"\n",
"}",
"\n",
"td",
":=",
"ThreatDescriptor",
"{",
"ThreatType",
":",
"ThreatType",
"(",
"tm",
".",
"ThreatType",
")",
",",
"PlatformType",
":",
"PlatformType",
"(",
"tm",
".",
"PlatformType",
")",
",",
"ThreatEntryType",
":",
"ThreatEntryType",
"(",
"tm",
".",
"ThreatEntryType",
")",
",",
"}",
"\n",
"c",
".",
"pttls",
"[",
"fullHash",
"]",
"[",
"td",
"]",
"=",
"now",
".",
"Add",
"(",
"dur",
")",
"\n",
"}",
"\n\n",
"// Insert negative TTLs for partial hashes.",
"if",
"resp",
".",
"GetNegativeCacheDuration",
"(",
")",
"!=",
"nil",
"{",
"dur",
":=",
"time",
".",
"Duration",
"(",
"resp",
".",
"GetNegativeCacheDuration",
"(",
")",
".",
"Seconds",
")",
"*",
"time",
".",
"Second",
"\n",
"nttl",
":=",
"now",
".",
"Add",
"(",
"dur",
")",
"\n",
"for",
"_",
",",
"te",
":=",
"range",
"req",
".",
"GetThreatInfo",
"(",
")",
".",
"GetThreatEntries",
"(",
")",
"{",
"partialHash",
":=",
"hashPrefix",
"(",
"te",
".",
"Hash",
")",
"\n",
"c",
".",
"nttls",
"[",
"partialHash",
"]",
"=",
"nttl",
"\n",
"}",
"\n",
"}",
"\n",
"}"
] |
// Update updates the cache according to the request that was made to the server
// and the response given back.
|
[
"Update",
"updates",
"the",
"cache",
"according",
"to",
"the",
"request",
"that",
"was",
"made",
"to",
"the",
"server",
"and",
"the",
"response",
"given",
"back",
"."
] |
92a16cf6d02871018d6a426fb7886e34022c5c59
|
https://github.com/google/safebrowsing/blob/92a16cf6d02871018d6a426fb7886e34022c5c59/cache.go#L64-L106
|
6,094 |
google/safebrowsing
|
cache.go
|
Lookup
|
func (c *cache) Lookup(hash hashPrefix) (map[ThreatDescriptor]bool, cacheResult) {
if !hash.IsFull() {
panic("hash is not full")
}
c.Lock()
defer c.Unlock()
now := c.now()
// Check all entries to see if there *is* a threat.
threats := make(map[ThreatDescriptor]bool)
threatTTLs := c.pttls[hash]
for td, pttl := range threatTTLs {
if pttl.After(now) {
threats[td] = true
} else {
// The PTTL has expired, we should 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 *no* threats.
for i := minHashPrefixLength; i <= maxHashPrefixLength; i++ {
if nttl, ok := c.nttls[hash[:i]]; ok {
if nttl.After(now) {
return nil, negativeCacheHit
}
}
}
// The cache has no information; it is a *possible* threat.
return nil, cacheMiss
}
|
go
|
func (c *cache) Lookup(hash hashPrefix) (map[ThreatDescriptor]bool, cacheResult) {
if !hash.IsFull() {
panic("hash is not full")
}
c.Lock()
defer c.Unlock()
now := c.now()
// Check all entries to see if there *is* a threat.
threats := make(map[ThreatDescriptor]bool)
threatTTLs := c.pttls[hash]
for td, pttl := range threatTTLs {
if pttl.After(now) {
threats[td] = true
} else {
// The PTTL has expired, we should 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 *no* threats.
for i := minHashPrefixLength; i <= maxHashPrefixLength; i++ {
if nttl, ok := c.nttls[hash[:i]]; ok {
if nttl.After(now) {
return nil, negativeCacheHit
}
}
}
// The cache has no information; it is a *possible* threat.
return nil, cacheMiss
}
|
[
"func",
"(",
"c",
"*",
"cache",
")",
"Lookup",
"(",
"hash",
"hashPrefix",
")",
"(",
"map",
"[",
"ThreatDescriptor",
"]",
"bool",
",",
"cacheResult",
")",
"{",
"if",
"!",
"hash",
".",
"IsFull",
"(",
")",
"{",
"panic",
"(",
"\"",
"\"",
")",
"\n",
"}",
"\n\n",
"c",
".",
"Lock",
"(",
")",
"\n",
"defer",
"c",
".",
"Unlock",
"(",
")",
"\n",
"now",
":=",
"c",
".",
"now",
"(",
")",
"\n\n",
"// Check all entries to see if there *is* a threat.",
"threats",
":=",
"make",
"(",
"map",
"[",
"ThreatDescriptor",
"]",
"bool",
")",
"\n",
"threatTTLs",
":=",
"c",
".",
"pttls",
"[",
"hash",
"]",
"\n",
"for",
"td",
",",
"pttl",
":=",
"range",
"threatTTLs",
"{",
"if",
"pttl",
".",
"After",
"(",
"now",
")",
"{",
"threats",
"[",
"td",
"]",
"=",
"true",
"\n",
"}",
"else",
"{",
"// The PTTL has expired, we should ask the server what's going on.",
"return",
"nil",
",",
"cacheMiss",
"\n",
"}",
"\n",
"}",
"\n",
"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",
"\n",
"}",
"\n\n",
"// Check the negative TTLs to see if there are *no* threats.",
"for",
"i",
":=",
"minHashPrefixLength",
";",
"i",
"<=",
"maxHashPrefixLength",
";",
"i",
"++",
"{",
"if",
"nttl",
",",
"ok",
":=",
"c",
".",
"nttls",
"[",
"hash",
"[",
":",
"i",
"]",
"]",
";",
"ok",
"{",
"if",
"nttl",
".",
"After",
"(",
"now",
")",
"{",
"return",
"nil",
",",
"negativeCacheHit",
"\n",
"}",
"\n",
"}",
"\n",
"}",
"\n\n",
"// The cache has no information; it is a *possible* threat.",
"return",
"nil",
",",
"cacheMiss",
"\n",
"}"
] |
// Lookup looks up a full hash and returns a set of ThreatDescriptors and the
// validity of the result.
|
[
"Lookup",
"looks",
"up",
"a",
"full",
"hash",
"and",
"returns",
"a",
"set",
"of",
"ThreatDescriptors",
"and",
"the",
"validity",
"of",
"the",
"result",
"."
] |
92a16cf6d02871018d6a426fb7886e34022c5c59
|
https://github.com/google/safebrowsing/blob/92a16cf6d02871018d6a426fb7886e34022c5c59/cache.go#L110-L147
|
6,095 |
google/safebrowsing
|
cache.go
|
Purge
|
func (c *cache) Purge() {
c.Lock()
defer c.Unlock()
now := c.now()
// Nuke all threat entries based on their positive TTL.
for fullHash, threatTTLs := range c.pttls {
for td, pttl := range threatTTLs {
if now.After(pttl) {
del := true
for i := minHashPrefixLength; i <= maxHashPrefixLength; i++ {
if nttl, ok := c.nttls[fullHash[:i]]; ok {
if nttl.After(pttl) {
del = false
break
}
}
}
if del {
delete(threatTTLs, td)
}
}
}
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)
}
}
}
|
go
|
func (c *cache) Purge() {
c.Lock()
defer c.Unlock()
now := c.now()
// Nuke all threat entries based on their positive TTL.
for fullHash, threatTTLs := range c.pttls {
for td, pttl := range threatTTLs {
if now.After(pttl) {
del := true
for i := minHashPrefixLength; i <= maxHashPrefixLength; i++ {
if nttl, ok := c.nttls[fullHash[:i]]; ok {
if nttl.After(pttl) {
del = false
break
}
}
}
if del {
delete(threatTTLs, td)
}
}
}
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)
}
}
}
|
[
"func",
"(",
"c",
"*",
"cache",
")",
"Purge",
"(",
")",
"{",
"c",
".",
"Lock",
"(",
")",
"\n",
"defer",
"c",
".",
"Unlock",
"(",
")",
"\n",
"now",
":=",
"c",
".",
"now",
"(",
")",
"\n\n",
"// Nuke all threat entries based on their positive TTL.",
"for",
"fullHash",
",",
"threatTTLs",
":=",
"range",
"c",
".",
"pttls",
"{",
"for",
"td",
",",
"pttl",
":=",
"range",
"threatTTLs",
"{",
"if",
"now",
".",
"After",
"(",
"pttl",
")",
"{",
"del",
":=",
"true",
"\n",
"for",
"i",
":=",
"minHashPrefixLength",
";",
"i",
"<=",
"maxHashPrefixLength",
";",
"i",
"++",
"{",
"if",
"nttl",
",",
"ok",
":=",
"c",
".",
"nttls",
"[",
"fullHash",
"[",
":",
"i",
"]",
"]",
";",
"ok",
"{",
"if",
"nttl",
".",
"After",
"(",
"pttl",
")",
"{",
"del",
"=",
"false",
"\n",
"break",
"\n",
"}",
"\n",
"}",
"\n",
"}",
"\n",
"if",
"del",
"{",
"delete",
"(",
"threatTTLs",
",",
"td",
")",
"\n",
"}",
"\n",
"}",
"\n",
"}",
"\n",
"if",
"len",
"(",
"threatTTLs",
")",
"==",
"0",
"{",
"delete",
"(",
"c",
".",
"pttls",
",",
"fullHash",
")",
"\n",
"}",
"\n",
"}",
"\n\n",
"// Nuke all partial hashes based on their negative TTL.",
"for",
"partialHash",
",",
"nttl",
":=",
"range",
"c",
".",
"nttls",
"{",
"if",
"now",
".",
"After",
"(",
"nttl",
")",
"{",
"delete",
"(",
"c",
".",
"nttls",
",",
"partialHash",
")",
"\n",
"}",
"\n",
"}",
"\n",
"}"
] |
// Purge purges all expired entries from the cache.
|
[
"Purge",
"purges",
"all",
"expired",
"entries",
"from",
"the",
"cache",
"."
] |
92a16cf6d02871018d6a426fb7886e34022c5c59
|
https://github.com/google/safebrowsing/blob/92a16cf6d02871018d6a426fb7886e34022c5c59/cache.go#L150-L184
|
6,096 |
google/safebrowsing
|
database.go
|
Init
|
func (db *database) Init(config *Config, logger *log.Logger) bool {
db.mu.Lock()
defer db.mu.Unlock()
db.setError(errors.New("not intialized"))
db.config = config
db.log = logger
if db.config.DBPath == "" {
db.log.Printf("no database file specified")
db.setError(errors.New("no database loaded"))
return false
}
dbf, err := loadDatabase(db.config.DBPath)
if err != nil {
db.log.Printf("load failure: %v", err)
db.setError(err)
return false
}
// Validate that the database 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 := make(threatsForUpdate)
for _, td := range db.config.ThreatLists {
if row, ok := dbf.Table[td]; ok {
tfuNew[td] = row
} else {
db.log.Printf("database configuration mismatch, missing %v", td)
db.setError(errors.New("database configuration mismatch"))
return false
}
}
db.tfu = tfuNew
db.generateThreatsForLookups(dbf.Time)
return true
}
|
go
|
func (db *database) Init(config *Config, logger *log.Logger) bool {
db.mu.Lock()
defer db.mu.Unlock()
db.setError(errors.New("not intialized"))
db.config = config
db.log = logger
if db.config.DBPath == "" {
db.log.Printf("no database file specified")
db.setError(errors.New("no database loaded"))
return false
}
dbf, err := loadDatabase(db.config.DBPath)
if err != nil {
db.log.Printf("load failure: %v", err)
db.setError(err)
return false
}
// Validate that the database 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 := make(threatsForUpdate)
for _, td := range db.config.ThreatLists {
if row, ok := dbf.Table[td]; ok {
tfuNew[td] = row
} else {
db.log.Printf("database configuration mismatch, missing %v", td)
db.setError(errors.New("database configuration mismatch"))
return false
}
}
db.tfu = tfuNew
db.generateThreatsForLookups(dbf.Time)
return true
}
|
[
"func",
"(",
"db",
"*",
"database",
")",
"Init",
"(",
"config",
"*",
"Config",
",",
"logger",
"*",
"log",
".",
"Logger",
")",
"bool",
"{",
"db",
".",
"mu",
".",
"Lock",
"(",
")",
"\n",
"defer",
"db",
".",
"mu",
".",
"Unlock",
"(",
")",
"\n",
"db",
".",
"setError",
"(",
"errors",
".",
"New",
"(",
"\"",
"\"",
")",
")",
"\n",
"db",
".",
"config",
"=",
"config",
"\n",
"db",
".",
"log",
"=",
"logger",
"\n",
"if",
"db",
".",
"config",
".",
"DBPath",
"==",
"\"",
"\"",
"{",
"db",
".",
"log",
".",
"Printf",
"(",
"\"",
"\"",
")",
"\n",
"db",
".",
"setError",
"(",
"errors",
".",
"New",
"(",
"\"",
"\"",
")",
")",
"\n",
"return",
"false",
"\n",
"}",
"\n",
"dbf",
",",
"err",
":=",
"loadDatabase",
"(",
"db",
".",
"config",
".",
"DBPath",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"db",
".",
"log",
".",
"Printf",
"(",
"\"",
"\"",
",",
"err",
")",
"\n",
"db",
".",
"setError",
"(",
"err",
")",
"\n",
"return",
"false",
"\n",
"}",
"\n",
"// Validate that the database threat list stored on disk is not too stale.",
"if",
"db",
".",
"isStale",
"(",
"dbf",
".",
"Time",
")",
"{",
"db",
".",
"log",
".",
"Printf",
"(",
"\"",
"\"",
")",
"\n",
"db",
".",
"ml",
".",
"Lock",
"(",
")",
"\n",
"defer",
"db",
".",
"ml",
".",
"Unlock",
"(",
")",
"\n",
"db",
".",
"setStale",
"(",
")",
"\n",
"return",
"false",
"\n",
"}",
"\n",
"// Validate that the database threat list stored on disk is at least a",
"// superset of the specified configuration.",
"tfuNew",
":=",
"make",
"(",
"threatsForUpdate",
")",
"\n",
"for",
"_",
",",
"td",
":=",
"range",
"db",
".",
"config",
".",
"ThreatLists",
"{",
"if",
"row",
",",
"ok",
":=",
"dbf",
".",
"Table",
"[",
"td",
"]",
";",
"ok",
"{",
"tfuNew",
"[",
"td",
"]",
"=",
"row",
"\n",
"}",
"else",
"{",
"db",
".",
"log",
".",
"Printf",
"(",
"\"",
"\"",
",",
"td",
")",
"\n",
"db",
".",
"setError",
"(",
"errors",
".",
"New",
"(",
"\"",
"\"",
")",
")",
"\n",
"return",
"false",
"\n",
"}",
"\n",
"}",
"\n",
"db",
".",
"tfu",
"=",
"tfuNew",
"\n",
"db",
".",
"generateThreatsForLookups",
"(",
"dbf",
".",
"Time",
")",
"\n",
"return",
"true",
"\n",
"}"
] |
// Init initializes the database from the specified file in config.DBPath.
// It reports true if the database was successfully loaded.
|
[
"Init",
"initializes",
"the",
"database",
"from",
"the",
"specified",
"file",
"in",
"config",
".",
"DBPath",
".",
"It",
"reports",
"true",
"if",
"the",
"database",
"was",
"successfully",
"loaded",
"."
] |
92a16cf6d02871018d6a426fb7886e34022c5c59
|
https://github.com/google/safebrowsing/blob/92a16cf6d02871018d6a426fb7886e34022c5c59/database.go#L104-L144
|
6,097 |
google/safebrowsing
|
database.go
|
Status
|
func (db *database) Status() error {
db.ml.RLock()
defer db.ml.RUnlock()
if db.err != nil {
return db.err
}
if db.isStale(db.last) {
db.setStale()
return db.err
}
return nil
}
|
go
|
func (db *database) Status() error {
db.ml.RLock()
defer db.ml.RUnlock()
if db.err != nil {
return db.err
}
if db.isStale(db.last) {
db.setStale()
return db.err
}
return nil
}
|
[
"func",
"(",
"db",
"*",
"database",
")",
"Status",
"(",
")",
"error",
"{",
"db",
".",
"ml",
".",
"RLock",
"(",
")",
"\n",
"defer",
"db",
".",
"ml",
".",
"RUnlock",
"(",
")",
"\n\n",
"if",
"db",
".",
"err",
"!=",
"nil",
"{",
"return",
"db",
".",
"err",
"\n",
"}",
"\n",
"if",
"db",
".",
"isStale",
"(",
"db",
".",
"last",
")",
"{",
"db",
".",
"setStale",
"(",
")",
"\n",
"return",
"db",
".",
"err",
"\n",
"}",
"\n",
"return",
"nil",
"\n",
"}"
] |
// Status reports the health of the database. The database is considered faulted
// if there was an error during update or if the last update has gone stale. If
// in a faulted state, the db may repair itself on the next Update.
|
[
"Status",
"reports",
"the",
"health",
"of",
"the",
"database",
".",
"The",
"database",
"is",
"considered",
"faulted",
"if",
"there",
"was",
"an",
"error",
"during",
"update",
"or",
"if",
"the",
"last",
"update",
"has",
"gone",
"stale",
".",
"If",
"in",
"a",
"faulted",
"state",
"the",
"db",
"may",
"repair",
"itself",
"on",
"the",
"next",
"Update",
"."
] |
92a16cf6d02871018d6a426fb7886e34022c5c59
|
https://github.com/google/safebrowsing/blob/92a16cf6d02871018d6a426fb7886e34022c5c59/database.go#L149-L161
|
6,098 |
google/safebrowsing
|
database.go
|
UpdateLag
|
func (db *database) UpdateLag() time.Duration {
lag := db.SinceLastUpdate()
if lag < db.config.UpdatePeriod {
return 0
}
return lag - db.config.UpdatePeriod
}
|
go
|
func (db *database) UpdateLag() time.Duration {
lag := db.SinceLastUpdate()
if lag < db.config.UpdatePeriod {
return 0
}
return lag - db.config.UpdatePeriod
}
|
[
"func",
"(",
"db",
"*",
"database",
")",
"UpdateLag",
"(",
")",
"time",
".",
"Duration",
"{",
"lag",
":=",
"db",
".",
"SinceLastUpdate",
"(",
")",
"\n",
"if",
"lag",
"<",
"db",
".",
"config",
".",
"UpdatePeriod",
"{",
"return",
"0",
"\n",
"}",
"\n",
"return",
"lag",
"-",
"db",
".",
"config",
".",
"UpdatePeriod",
"\n",
"}"
] |
// UpdateLag reports the amount of time in between when we expected to run
// a database update and the current time
|
[
"UpdateLag",
"reports",
"the",
"amount",
"of",
"time",
"in",
"between",
"when",
"we",
"expected",
"to",
"run",
"a",
"database",
"update",
"and",
"the",
"current",
"time"
] |
92a16cf6d02871018d6a426fb7886e34022c5c59
|
https://github.com/google/safebrowsing/blob/92a16cf6d02871018d6a426fb7886e34022c5c59/database.go#L165-L171
|
6,099 |
google/safebrowsing
|
database.go
|
SinceLastUpdate
|
func (db *database) SinceLastUpdate() time.Duration {
db.ml.RLock()
defer db.ml.RUnlock()
return db.config.now().Sub(db.last)
}
|
go
|
func (db *database) SinceLastUpdate() time.Duration {
db.ml.RLock()
defer db.ml.RUnlock()
return db.config.now().Sub(db.last)
}
|
[
"func",
"(",
"db",
"*",
"database",
")",
"SinceLastUpdate",
"(",
")",
"time",
".",
"Duration",
"{",
"db",
".",
"ml",
".",
"RLock",
"(",
")",
"\n",
"defer",
"db",
".",
"ml",
".",
"RUnlock",
"(",
")",
"\n\n",
"return",
"db",
".",
"config",
".",
"now",
"(",
")",
".",
"Sub",
"(",
"db",
".",
"last",
")",
"\n",
"}"
] |
// SinceLastUpdate gives the duration since the last database update
|
[
"SinceLastUpdate",
"gives",
"the",
"duration",
"since",
"the",
"last",
"database",
"update"
] |
92a16cf6d02871018d6a426fb7886e34022c5c59
|
https://github.com/google/safebrowsing/blob/92a16cf6d02871018d6a426fb7886e34022c5c59/database.go#L174-L179
|
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.