本文整理汇总了Golang中code/google/com/p/rsc/cc.Expr.Left方法的典型用法代码示例。如果您正苦于以下问题:Golang Expr.Left方法的具体用法?Golang Expr.Left怎么用?Golang Expr.Left使用的例子?那么恭喜您, 这里精选的方法代码示例或许可以为您提供帮助。您也可以进一步了解该方法所在类code/google/com/p/rsc/cc.Expr
的用法示例。
在下文中一共展示了Expr.Left方法的7个代码示例,这些例子默认根据受欢迎程度排序。您可以为喜欢或者感觉有用的代码点赞,您的评价将有助于系统推荐出更棒的Golang代码示例。
示例1: negate
func negate(x *cc.Expr) *cc.Expr {
switch x.Op {
case cc.Paren:
return negate(x.Left)
case cc.OrOr:
x.Op = cc.AndAnd
x.Left = negate(x.Left)
x.Right = negate(x.Right)
case cc.AndAnd:
x.Op = cc.OrOr
x.Left = negate(x.Left)
x.Right = negate(x.Right)
case cc.EqEq:
x.Op = cc.NotEq
case cc.NotEq:
x.Op = cc.EqEq
case cc.Lt:
x.Op = cc.GtEq
case cc.GtEq:
x.Op = cc.Lt
case cc.Gt:
x.Op = cc.LtEq
case cc.LtEq:
x.Op = cc.Gt
default:
x = &cc.Expr{Op: cc.Not, Left: x}
}
return x
}
示例2: fixPrintf
func fixPrintf(curfn *cc.Decl, x *cc.Expr) bool {
if x.Op != cc.Call {
return false
}
if tryPrintf(curfn, x, "sprint", 1, "fmt.Sprintf") {
targ := x.List[0]
x.List = x.List[1:]
x.Right = copyExpr(x)
x.List = nil
x.Left = targ
x.Op = cc.Eq
// sprint(strchr(s, 0), "hello") => s += "hello"
if targ.Op == cc.Call && len(targ.List) == 2 && targ.Left.Text == "strchr" && targ.List[1].Text == "0" {
x.Left = targ.List[0]
x.Op = cc.AddEq
} else if targ.Op == cc.Add && targ.Right.Op == cc.Call && targ.Right.Left.Text == "strlen" && len(targ.Right.List) == 1 && c2go.GoString(targ.Left) == c2go.GoString(targ.Right.List[0]) {
x.Left = targ.Left
x.Op = cc.AddEq
}
return true
}
if tryPrintf(curfn, x, "snprint", 2, "fmt.Sprintf") {
targ := x.List[0]
x.List = x.List[2:]
x.Right = copyExpr(x)
x.List = nil
x.Left = targ
x.Op = cc.Eq
return true
}
if tryPrintf(curfn, x, "fmtprint", 1, "fmt.Sprintf") {
targ := x.List[0]
x.List = x.List[1:]
x.Right = copyExpr(x)
x.List = nil
x.Left = targ
x.Op = cc.AddEq
return true
}
if tryPrintf(curfn, x, "print", 0, "fmt.Printf") {
return true
}
if tryPrintf(curfn, x, "sysfatal", 0, "log.Fatalf") {
return true
}
if tryPrintf(curfn, x, "ctxt.diag", 0, "ctxt.diag") {
return true
}
if tryPrintf(curfn, x, "Bprint", 1, "fmt.Fprintf") {
return true
}
if tryPrintf(curfn, x, "smprint", 0, "fmt.Sprintf") {
return true
}
return false
}
示例3: fixSpecialCompare
func fixSpecialCompare(fn *cc.Decl, x *cc.Expr) bool {
if x.Right.Op != cc.Number || x.Right.Text != "0" || x.Left.Op != cc.Call || x.Left.Left.Op != cc.Name {
return false
}
call := x.Left
switch call.Left.Text {
case "memcmp":
if len(call.List) != 3 {
fprintf(x.Span, "unsupported %v", x)
return false
}
obj1, obj1Type := objIndir(fn, call.List[0])
obj2, obj2Type := objIndir(fn, call.List[1])
if obj1Type == nil || !sameType(obj1Type, obj2Type) {
fprintf(x.Span, "unsupported %v", call)
return true
}
if !matchSize(fn, obj1, obj1Type, call.List[2]) && !matchSize(fn, obj2, obj2Type, call.List[2]) {
fprintf(x.Span, "unsupported %v - wrong size", call)
return true
}
x.Left = obj1
x.Right = obj2
x.List = nil
x.XType = boolType
return true
case "strcmp":
if len(call.List) != 2 {
fprintf(x.Span, "unsupported %v", x)
return false
}
obj1 := call.List[0]
obj2 := call.List[1]
x.Left = obj1
x.Right = obj2
x.List = nil
x.XType = boolType
return true
}
return false
}
示例4: forceConvert
func forceConvert(fn *cc.Decl, x *cc.Expr, actual, targ *cc.Type) {
if isNumericConst(x) && targ != nil {
switch targ.Kind {
case cc.Ptr, c2go.Slice:
if x.Op == cc.Number && x.Text == "0" {
x.Op = cc.Name
x.Text = "nil"
x.XType = targ
}
case c2go.String:
if x.Op == cc.Number && x.Text == "0" {
x.Op = cc.Name
x.Text = `""`
x.XType = targ
}
}
return
}
if actual == nil || targ == nil {
return
}
if actual.Kind == c2go.Ideal && c2go.Int8 <= targ.Kind && targ.Kind <= c2go.Float64 {
return
}
if x != nil && x.Op == cc.Name && x.Text == "nil" {
if targ.Kind == cc.Func || targ.Kind == cc.Ptr || targ.Kind == c2go.Slice {
return
}
}
// Func conversions are never useful.
// If the func types are different, the conversion will fail;
// if not, the conversion is unnecessary.
// Either way the conversion is an eyesore.
if targ.Kind == cc.Func || targ.Kind == cc.Ptr && targ.Base.Kind == cc.Func {
return
}
if actual.Kind == c2go.Bool && c2go.Int8 <= targ.Kind && targ.Kind <= c2go.Float64 {
old := copyExpr(x)
if targ.Kind == c2go.Int {
x.Op = cc.Call
x.Left = &cc.Expr{Op: cc.Name, Text: "bool2int"}
x.List = []*cc.Expr{old}
x.Right = nil
} else {
x.Op = cc.Cast
x.Left = &cc.Expr{Op: cc.Call, Left: &cc.Expr{Op: cc.Name, Text: "bool2int"}, List: []*cc.Expr{old}}
x.Type = targ
}
return
}
if actual.Kind == cc.Array && targ.Kind == c2go.Slice && sameType(actual.Base, targ.Base) {
old := copyExpr(x)
x.Op = c2go.ExprSlice
x.List = []*cc.Expr{old, nil, nil}
x.Left = nil
x.Right = nil
return
}
if actual.Kind == c2go.Slice && targ.Kind == cc.Ptr && sameType(actual.Base, targ.Base) {
old := copyExpr(x)
x.Op = cc.Addr
x.Left = &cc.Expr{Op: cc.Index, Left: old, Right: &cc.Expr{Op: cc.Number, Text: "0"}}
return
}
if !sameType(actual, targ) {
old := copyExpr(x)
// for debugging:
// old = &cc.Expr{Op: cc.Cast, Left: old, Type: actual, XType: actual}
x.Op = cc.Cast
x.Left = old
x.Right = nil
x.List = nil
x.Type = targ
x.XType = targ
if actual.Kind == cc.Array && targ.Kind == c2go.Slice {
x.Op = c2go.ExprSlice
x.List = []*cc.Expr{old, nil, nil}
x.Left = nil
x.Type = nil
}
}
}
示例5: fixGoTypesExpr
func fixGoTypesExpr(fn *cc.Decl, x *cc.Expr, targ *cc.Type) (ret *cc.Type) {
if x == nil {
return nil
}
defer func() {
x.XType = ret
}()
if x.Op == cc.Paren {
return fixGoTypesExpr(fn, x.Left, targ)
}
// Make explicit C's implicit conversions from boolean to non-boolean and vice versa.
switch x.Op {
case cc.AndAnd, cc.OrOr, cc.Not, cc.EqEq, cc.Lt, cc.LtEq, cc.Gt, cc.GtEq, cc.NotEq:
if targ != nil && targ.Kind != c2go.Bool {
old := copyExpr(x)
if targ.Kind == c2go.Int {
x.Op = cc.Call
x.Left = &cc.Expr{Op: cc.Name, Text: "bool2int"}
x.List = []*cc.Expr{old}
x.Right = nil
} else {
x.Op = cc.Cast
x.Left = &cc.Expr{Op: cc.Call, Left: &cc.Expr{Op: cc.Name, Text: "bool2int"}, List: []*cc.Expr{old}}
x.Type = targ
}
fixGoTypesExpr(fn, old, boolType)
return targ
}
default:
if targ != nil && targ.Kind == c2go.Bool {
old := copyExpr(x)
left := fixGoTypesExpr(fn, old, nil)
if left != nil && left.Kind == c2go.Bool {
return targ
}
if old.Op == cc.Number {
switch old.Text {
case "1":
x.Op = cc.Name
x.Text = "true"
return targ
case "0":
x.Op = cc.Name
x.Text = "false"
return targ
}
}
x.Op = cc.NotEq
x.Left = old
x.Right = zeroFor(left)
return targ
}
}
switch x.Op {
default:
panic(fmt.Sprintf("unexpected construct %v in fixGoTypesExpr - %v - %v", c2go.GoString(x), x.Op, x.Span))
case c2go.ExprSlice:
// inserted by rewriteLen
left := fixGoTypesExpr(fn, x.List[0], targ)
fixGoTypesExpr(fn, x.List[1], nil)
fixGoTypesExpr(fn, x.List[2], nil)
return left
case cc.Comma:
for i, y := range x.List {
t := targ
if i+1 < len(x.List) {
t = nil
}
fixGoTypesExpr(fn, y, t)
}
return nil
case c2go.ExprBlock:
for _, stmt := range x.Block {
fixGoTypesStmt(nil, fn, stmt)
}
return nil
case cc.Add, cc.And, cc.Div, cc.Mod, cc.Mul, cc.Or, cc.Sub, cc.Xor:
if x.Op == cc.Sub && isPtrSliceOrArray(x.Left.XType) && isPtrSliceOrArray(x.Right.XType) {
left := fixGoTypesExpr(fn, x.Left, nil)
right := fixGoTypesExpr(fn, x.Right, nil)
if left != nil && right != nil && left.Kind != right.Kind {
if left.Kind == c2go.Slice {
forceConvert(fn, x.Right, right, left)
} else {
forceConvert(fn, x.Left, left, right)
}
}
x.Left = &cc.Expr{Op: cc.Minus, Left: &cc.Expr{Op: cc.Call, Left: &cc.Expr{Op: cc.Name, Text: "cap"}, List: []*cc.Expr{x.Left}}}
x.Right = &cc.Expr{Op: cc.Call, Left: &cc.Expr{Op: cc.Name, Text: "cap"}, List: []*cc.Expr{x.Right}}
x.Op = cc.Add
return intType
}
//.........这里部分代码省略.........
示例6: fixSpecialCall
func fixSpecialCall(fn *cc.Decl, x *cc.Expr, targ *cc.Type) bool {
if x.Left.Op != cc.Name {
return false
}
switch x.Left.Text {
case "memmove":
if len(x.List) != 3 {
fprintf(x.Span, "unsupported %v", x)
return false
}
siz := x.List[2]
if siz.Op == cc.Number && siz.Text == "4" {
obj1, obj1Type := objIndir(fn, x.List[0])
obj2, obj2Type := objIndir(fn, x.List[1])
if obj1Type == nil || obj2Type == nil {
fprintf(x.Span, "unsupported %v - missing types", x)
return true
}
if (obj1Type.Kind == c2go.Uint32 || obj1Type.Kind == c2go.Int32) && obj2Type.Kind == c2go.Float32 {
x.Op = cc.Eq
x.Left = obj1
x.Right = &cc.Expr{
Op: cc.Call,
Left: &cc.Expr{Op: cc.Name,
Text: "math.Float32bits",
},
List: []*cc.Expr{obj2},
}
x.XType = uint32Type
return true
}
fprintf(x.Span, "unsupported %v - size 4 type %v %v", x, c2go.GoString(obj1Type), c2go.GoString(obj2Type))
}
if siz.Op == cc.Number && siz.Text == "8" {
obj1, obj1Type := objIndir(fn, x.List[0])
obj2, obj2Type := objIndir(fn, x.List[1])
if obj1Type == nil || obj2Type == nil {
fprintf(x.Span, "unsupported %v - missing types", x)
return true
}
if (obj1Type.Kind == c2go.Uint64 || obj1Type.Kind == c2go.Int64) && obj2Type.Kind == c2go.Float64 {
x.Op = cc.Eq
x.Left = obj1
x.Right = &cc.Expr{
Op: cc.Call,
Left: &cc.Expr{Op: cc.Name,
Text: "math.Float64bits",
},
List: []*cc.Expr{obj2},
}
x.XType = uint64Type
return true
}
fprintf(x.Span, "unsupported %v - size 8 type %v %v", x, c2go.GoString(obj1Type), c2go.GoString(obj2Type))
}
if siz.Op == cc.SizeofExpr {
obj1Type := fixGoTypesExpr(fn, x.List[0], nil)
obj2Type := fixGoTypesExpr(fn, x.List[1], nil)
sizeType := fixGoTypesExpr(fn, siz.Left, nil)
if obj1Type == nil || obj2Type == nil {
fprintf(x.Span, "unsupported %v - bad types", x)
return true
}
if obj2Type.Kind == cc.Array && sameType(obj2Type, sizeType) || obj2Type.Kind == c2go.Slice && c2go.GoString(x.List[1]) == c2go.GoString(siz.Left) {
x.Left.Text = "copy"
x.Left.XDecl = nil
x.List = x.List[:2]
return true
}
fprintf(x.Span, "unsupported %v - not array %v %v", x, c2go.GoString(obj2Type), c2go.GoString(sizeType))
return true
}
left := fixGoTypesExpr(fn, x.List[0], nil)
right := fixGoTypesExpr(fn, x.List[1], nil)
fixGoTypesExpr(fn, siz, nil)
if isSliceOrArray(left) && isSliceOrArray(right) && left.Base.Is(c2go.Uint8) && right.Base.Is(c2go.Uint8) {
x.Left.Text = "copy"
x.Left.XDecl = nil
if x.List[1].Op == c2go.ExprSlice && x.List[1].List[1] == nil {
x.List[1].List[2] = siz
} else {
x.List[1] = &cc.Expr{Op: c2go.ExprSlice, List: []*cc.Expr{x.List[1], nil, siz}}
}
x.List = x.List[:2]
return true
}
fprintf(x.Span, "unsupported %v (%v %v)", x, c2go.GoString(left), c2go.GoString(right))
return true
case "mal", "malloc", "emallocz":
if len(x.List) != 1 {
fprintf(x.Span, "unsupported %v - too many args", x)
return false
}
siz := x.List[0]
var count *cc.Expr
if siz.Op == cc.Mul {
count = siz.Left
siz = siz.Right
}
//.........这里部分代码省略.........
示例7: doSideEffects
func doSideEffects(x *cc.Expr, before, after *[]*cc.Stmt, mode int) {
if x == nil {
return
}
// Cannot hoist side effects from conditionally evaluated expressions
// into unconditionally evaluated statement lists.
// For now, detect but do not handle.
switch x.Op {
case cc.Cond:
doSideEffects(x.List[0], before, after, mode&^sideStmt|sideNoAfter)
checkNoSideEffects(x.List[1], 0)
checkNoSideEffects(x.List[2], 0)
case cc.AndAnd, cc.OrOr:
doSideEffects(x.Left, before, after, mode&^sideStmt|sideNoAfter)
checkNoSideEffects(x.Right, 0)
case cc.Comma:
var leftover []*cc.Expr
for i, y := range x.List {
m := mode | sideNoAfter
if i+1 < len(x.List) {
m |= sideStmt
}
doSideEffects(y, before, after, m)
switch y.Op {
case cc.PostInc, cc.PostDec, cc.Eq, cc.AddEq, cc.SubEq, cc.MulEq, cc.DivEq, cc.ModEq, cc.XorEq, cc.OrEq, cc.AndEq, cc.LshEq, cc.RshEq:
*before = append(*before, &cc.Stmt{Op: cc.StmtExpr, Expr: y})
default:
leftover = append(leftover, y)
}
}
x.List = leftover
default:
doSideEffects(x.Left, before, after, mode&^sideStmt)
doSideEffects(x.Right, before, after, mode&^sideStmt)
for _, y := range x.List {
doSideEffects(y, before, after, mode&^sideStmt)
}
}
if mode&sideStmt != 0 {
// Expression as statement.
// Can leave x++ alone, can rewrite ++x to x++, can leave x [op]= y alone.
switch x.Op {
case cc.PreInc:
x.Op = cc.PostInc
return
case cc.PreDec:
x.Op = cc.PostDec
return
case cc.PostInc, cc.PostDec:
return
case cc.Eq, cc.AddEq, cc.SubEq, cc.MulEq, cc.DivEq, cc.ModEq, cc.XorEq, cc.OrEq, cc.AndEq, cc.LshEq, cc.RshEq:
return
case cc.Call:
return
}
}
switch x.Op {
case cc.Eq, cc.AddEq, cc.SubEq, cc.MulEq, cc.DivEq, cc.ModEq, cc.XorEq, cc.OrEq, cc.AndEq, cc.LshEq, cc.RshEq:
x.Left = forceCheap(before, x.Left)
old := copyExpr(x)
*before = append(*before, &cc.Stmt{Op: cc.StmtExpr, Expr: old})
fixMerge(x, x.Left)
case cc.PreInc, cc.PreDec:
x.Left = forceCheap(before, x.Left)
old := copyExpr(x)
old.SyntaxInfo = cc.SyntaxInfo{}
if old.Op == cc.PreInc {
old.Op = cc.PostInc
} else {
old.Op = cc.PostDec
}
*before = append(*before, &cc.Stmt{Op: cc.StmtExpr, Expr: old})
fixMerge(x, x.Left)
case cc.PostInc, cc.PostDec:
x.Left = forceCheap(before, x.Left)
if mode&sideNoAfter != 0 {
// Not allowed to generate fixups afterward.
d := &cc.Decl{
Name: fmt.Sprintf("tmp%d", <-tmpGen),
Type: x.Left.XType,
}
eq := &cc.Expr{
Op: c2go.ColonEq,
Left: &cc.Expr{Op: cc.Name, Text: d.Name, XDecl: d},
Right: x.Left,
}
old := copyExpr(x.Left)
old.SyntaxInfo = cc.SyntaxInfo{}
*before = append(*before,
&cc.Stmt{Op: cc.StmtExpr, Expr: eq},
&cc.Stmt{Op: cc.StmtExpr, Expr: &cc.Expr{Op: x.Op, Left: old}},
)
//.........这里部分代码省略.........