mirror of
https://github.com/ddidderr/wuffs.git
synced 2026-11-18 00:32:11 +01:00
Add some ast.Expr.IsEtc methods
This commit is contained in:
1 parent
b645180357
commit
41e407a774
7 files changed
+58
-48
No files matched your search
@@ -728,16 +728,16 @@ func (g *gen) writeBuiltinCPUArchX86(b *buffer, recv *a.Expr, method t.ID, args
|
||||
}
|
||||
|
||||
func (g *gen) writeExprDotPtr(b *buffer, n *a.Expr, sideEffectsOnly bool, depth uint32) error {
|
||||
if n.Operator() == t.IDDotDot {
|
||||
if err := g.writeExpr(b, n.LHS().AsExpr(), sideEffectsOnly, depth); err != nil {
|
||||
if arrayOrSlice, lo, _, ok := n.IsSlice(); ok {
|
||||
if err := g.writeExpr(b, arrayOrSlice, sideEffectsOnly, depth); err != nil {
|
||||
return err
|
||||
}
|
||||
if n.LHS().AsExpr().MType().IsSliceType() {
|
||||
if arrayOrSlice.MType().IsSliceType() {
|
||||
b.writes(".ptr")
|
||||
}
|
||||
if n.MHS() != nil {
|
||||
if lo != nil {
|
||||
b.writes(" + ")
|
||||
if err := g.writeExpr(b, n.MHS().AsExpr(), sideEffectsOnly, depth); err != nil {
|
||||
if err := g.writeExpr(b, lo, sideEffectsOnly, depth); err != nil {
|
||||
return err
|
||||
}
|
||||
}
|
||||
@@ -969,13 +969,8 @@ func (g *gen) writeBuiltinSliceCopyFromSlice8(b *buffer, recv *a.Expr, method t.
|
||||
// matchFooIndexIndexPlus8 matches n with "foo[index .. index + 8]" or "foo[..
|
||||
// 8]". It returns a nil foo if there isn't a match.
|
||||
func matchFooIndexIndexPlus8(n *a.Expr) (foo *a.Expr, index *a.Expr) {
|
||||
if n.Operator() != t.IDDotDot {
|
||||
return nil, nil
|
||||
}
|
||||
foo = n.LHS().AsExpr()
|
||||
index = n.MHS().AsExpr()
|
||||
rhs := n.RHS().AsExpr()
|
||||
if rhs == nil {
|
||||
foo, index, rhs, ok := n.IsSlice()
|
||||
if !ok || (rhs == nil) {
|
||||
return nil, nil
|
||||
}
|
||||
|
||||
|
||||
@@ -1035,9 +1035,9 @@ func (g *gen) writeConst(b *buffer, n *a.Const) error {
|
||||
}
|
||||
|
||||
func (g *gen) writeConstList(b *buffer, n *a.Expr) error {
|
||||
if n.Operator() == t.IDComma {
|
||||
if args, ok := n.IsList(); ok {
|
||||
b.writeb('{')
|
||||
for i, o := range n.Args() {
|
||||
for i, o := range args {
|
||||
if i&7 == 0 {
|
||||
b.writeb('\n')
|
||||
}
|
||||
|
||||
@@ -45,8 +45,8 @@ func (g *gen) needDerivedVar(name t.ID) bool {
|
||||
switch p.Kind() {
|
||||
case a.KExpr:
|
||||
// Look for p matching "args.name.etc(etc)".
|
||||
recv, meth, args := p.AsExpr().IsMethodCall()
|
||||
if recv == nil {
|
||||
recv, meth, args, ok := p.AsExpr().IsMethodCall()
|
||||
if !ok {
|
||||
return nil
|
||||
}
|
||||
if recv.IsArgsDotFoo() == name {
|
||||
|
||||
+31
-3
@@ -386,13 +386,41 @@ func (n *Expr) IsArgsDotFoo() (foo t.ID) {
|
||||
return 0
|
||||
}
|
||||
|
||||
func (n *Expr) IsMethodCall() (recv *Expr, meth t.ID, args []*Node) {
|
||||
func (n *Expr) IsIndex() (arrayOrSlice *Expr, index *Expr, ok bool) {
|
||||
if n.id0 == t.IDOpenBracket {
|
||||
return n.lhs.AsExpr(), n.rhs.AsExpr(), true
|
||||
}
|
||||
return nil, nil, false
|
||||
}
|
||||
|
||||
func (n *Expr) IsList() (args []*Node, ok bool) {
|
||||
if n.id0 == t.IDComma {
|
||||
return n.list0, true
|
||||
}
|
||||
return nil, false
|
||||
}
|
||||
|
||||
func (n *Expr) IsMethodCall() (recv *Expr, meth t.ID, args []*Node, ok bool) {
|
||||
if n.id0 == t.IDOpenParen {
|
||||
if o := n.lhs; o.id0 == t.IDDot {
|
||||
return o.lhs.AsExpr(), o.id2, n.list0
|
||||
return o.lhs.AsExpr(), o.id2, n.list0, true
|
||||
}
|
||||
}
|
||||
return nil, 0, nil
|
||||
return nil, 0, nil, false
|
||||
}
|
||||
|
||||
func (n *Expr) IsSelector() (lhs *Expr, field t.ID, ok bool) {
|
||||
if n.id0 == t.IDDot {
|
||||
return n.lhs.AsExpr(), n.id2, true
|
||||
}
|
||||
return nil, 0, false
|
||||
}
|
||||
|
||||
func (n *Expr) IsSlice() (arrayOrSlice *Expr, lo *Expr, hi *Expr, ok bool) {
|
||||
if n.id0 == t.IDDotDot {
|
||||
return n.lhs.AsExpr(), n.mhs.AsExpr(), n.rhs.AsExpr(), true
|
||||
}
|
||||
return nil, nil, nil, false
|
||||
}
|
||||
|
||||
func NewExpr(flags Flags, operator t.ID, ident t.ID, lhs *Node, mhs *Node, rhs *Node, args []*Node) *Expr {
|
||||
|
||||
+7
-21
@@ -356,15 +356,8 @@ func (q *checker) bcheckStatement(n *a.Node) error {
|
||||
|
||||
func (q *checker) hasIsErrorFact(id t.ID) bool {
|
||||
for _, x := range q.facts {
|
||||
if (x.Operator() != t.IDOpenParen) || (len(x.Args()) != 0) {
|
||||
continue
|
||||
}
|
||||
x = x.LHS().AsExpr()
|
||||
if (x.Operator() != t.IDDot) || (x.Ident() != t.IDIsError) {
|
||||
continue
|
||||
}
|
||||
x = x.LHS().AsExpr()
|
||||
if (x.Operator() != 0) || (x.Ident() != id) {
|
||||
if lhs, meth, args, _ := x.IsMethodCall(); (meth != t.IDIsError) || (len(args) != 0) ||
|
||||
(lhs.Operator() != 0) || (lhs.Ident() != id) {
|
||||
continue
|
||||
}
|
||||
return true
|
||||
@@ -525,16 +518,16 @@ func (q *checker) bcheckAssignment(lhs *a.Expr, op t.ID, rhs *a.Expr) error {
|
||||
}
|
||||
|
||||
// Look for "lhs = x[i .. j]" where i and j are constants.
|
||||
if rhs.Operator() == t.IDDotDot {
|
||||
if _, i, j, ok := rhs.IsSlice(); ok {
|
||||
icv := (*big.Int)(nil)
|
||||
if i := rhs.MHS().AsExpr(); i == nil {
|
||||
if i == nil {
|
||||
icv = zero
|
||||
} else if i.ConstValue() != nil {
|
||||
icv = i.ConstValue()
|
||||
}
|
||||
|
||||
jcv := (*big.Int)(nil)
|
||||
if j := rhs.RHS().AsExpr(); (j != nil) && (j.ConstValue() != nil) {
|
||||
if (j != nil) && (j.ConstValue() != nil) {
|
||||
jcv = j.ConstValue()
|
||||
}
|
||||
|
||||
@@ -1265,15 +1258,8 @@ func (q *checker) bcheckExprCallSpecialCases(n *a.Expr, depth uint32) (bounds, e
|
||||
|
||||
func (q *checker) canUndoByte(recv *a.Expr) error {
|
||||
for _, x := range q.facts {
|
||||
if x.Operator() != t.IDOpenParen || len(x.Args()) != 0 {
|
||||
continue
|
||||
}
|
||||
x = x.LHS().AsExpr()
|
||||
if x.Operator() != t.IDDot || x.Ident() != t.IDCanUndoByte {
|
||||
continue
|
||||
}
|
||||
x = x.LHS().AsExpr()
|
||||
if !x.Eq(recv) {
|
||||
if lhs, meth, args, _ := x.IsMethodCall(); (meth != t.IDCanUndoByte) || (len(args) != 0) ||
|
||||
!lhs.Eq(recv) {
|
||||
continue
|
||||
}
|
||||
return q.facts.update(func(o *a.Expr) (*a.Expr, error) {
|
||||
|
||||
+6
-5
@@ -391,12 +391,13 @@ func (c *Checker) checkConst(node *a.Node) error {
|
||||
func (c *Checker) checkConstElement(n *a.Expr, nb bounds, nLists int) error {
|
||||
if nLists > 0 {
|
||||
nLists--
|
||||
if n.Operator() != t.IDComma {
|
||||
if args, ok := n.IsList(); !ok {
|
||||
return fmt.Errorf("invalid const value %q", n.Str(c.tm))
|
||||
}
|
||||
for _, o := range n.Args() {
|
||||
if err := c.checkConstElement(o.AsExpr(), nb, nLists); err != nil {
|
||||
return err
|
||||
} else {
|
||||
for _, o := range args {
|
||||
if err := c.checkConstElement(o.AsExpr(), nb, nLists); err != nil {
|
||||
return err
|
||||
}
|
||||
}
|
||||
}
|
||||
return nil
|
||||
|
||||
@@ -55,16 +55,16 @@ func (q *checker) optimizeIOMethodAdvance(receiver *a.Expr, advance *big.Int, ad
|
||||
|
||||
// Check if receiver looks like "a[i .. j]" where i and j are constants and
|
||||
// ((j - i) >= advance).
|
||||
if receiver.Operator() == t.IDDotDot {
|
||||
if _, i, j, ok := receiver.IsSlice(); ok {
|
||||
icv := (*big.Int)(nil)
|
||||
if i := receiver.MHS().AsExpr(); i == nil {
|
||||
if i == nil {
|
||||
icv = zero
|
||||
} else if i.ConstValue() != nil {
|
||||
icv = i.ConstValue()
|
||||
}
|
||||
|
||||
jcv := (*big.Int)(nil)
|
||||
if j := receiver.RHS().AsExpr(); (j != nil) && (j.ConstValue() != nil) {
|
||||
if (j != nil) && (j.ConstValue() != nil) {
|
||||
jcv = j.ConstValue()
|
||||
}
|
||||
|
||||
|
||||
Reference in new issue
Block a user