@Override
  protected final IASTNode doResolveAmbiguity(ASTVisitor visitor) {
    final IASTAmbiguityParent owner = (IASTAmbiguityParent) getParent();
    IASTNode nodeToReplace = this;

    // handle nested ambiguities first
    owner.replace(nodeToReplace, fCastExpression);
    nodeToReplace = fCastExpression;
    fCastExpression.getTypeId().accept(visitor);

    owner.replace(nodeToReplace, fBinaryExpression);
    nodeToReplace = fBinaryExpression;
    fBinaryExpression.accept(visitor);

    // find nested names
    final NameCollector nameCollector = new NameCollector();
    fCastExpression.getTypeId().accept(nameCollector);
    final IASTName[] names = nameCollector.getNames();

    // resolve names
    boolean hasIssue = false;
    for (IASTName name : names) {
      try {
        IBinding b = name.resolveBinding();
        if (b instanceof IProblemBinding) {
          hasIssue = true;
          break;
        }
      } catch (Exception t) {
        hasIssue = true;
        break;
      }
    }
    if (hasIssue) {
      return nodeToReplace;
    }

    final IASTExpression left = fBinaryExpression.getOperand1();
    final IASTExpression right = fBinaryExpression.getOperand2();
    left.setParent(null);
    right.setParent(null);
    IASTUnaryExpression primaryInParenthesis = findTrailingBracketedPrimaryExpression(left);
    IASTExpression leadingCastExpression = findLeadingCastExpression(right);
    IASTExpression castedUnary = fCastExpression.getOperand();
    if (primaryInParenthesis != null
        && leadingCastExpression != null
        && castedUnary instanceof IASTUnaryExpression) {
      IASTExpression lp = (IASTExpression) primaryInParenthesis.getParent();
      IASTBinaryExpression rp = (IASTBinaryExpression) leadingCastExpression.getParent();
      ((IASTUnaryExpression) castedUnary).setOperand(leadingCastExpression);
      setEnd(castedUnary, leadingCastExpression);
      setRange(fCastExpression, primaryInParenthesis, leadingCastExpression);
      IASTExpression root = joinExpressions(lp, fCastExpression, rp);
      if (root != null) {
        owner.replace(nodeToReplace, root);
        return root;
      }
    }
    return nodeToReplace;
  }
 private IASTUnaryExpression findTrailingBracketedPrimaryExpression(IASTExpression expr) {
   while (true) {
     if (expr instanceof IASTBinaryExpression) {
       expr = ((IASTBinaryExpression) expr).getOperand2();
     } else if (expr instanceof IASTCastExpression) {
       expr = ((IASTCastExpression) expr).getOperand();
     } else if (expr instanceof IASTUnaryExpression) {
       IASTUnaryExpression u = (IASTUnaryExpression) expr;
       if (u.getOperator() == IASTUnaryExpression.op_bracketedPrimary) return u;
       expr = u.getOperand();
     } else {
       return null;
     }
   }
 }
Exemplo n.º 3
0
 @Override
 protected int rwInUnaryExpression(IASTNode node, IASTUnaryExpression expr, int indirection) {
   switch (expr.getOperator()) {
     case ICPPASTUnaryExpression.op_typeid:
       return 0;
   }
   return super.rwInUnaryExpression(node, expr, indirection);
 }
 /**
  * @param l unary, cast or binary expression to the left, all parents are unary, cast or binary
  *     expressions.
  * @param middle initially a cast-expression, always suitable to put into l or r
  * @param r a binary expression to the right, all parents are binary expressions.
  */
 private IASTExpression joinExpressions(
     IASTExpression l, IASTExpression middle, IASTBinaryExpression r) {
   while (true) {
     if (l == null) {
       if (r == null) {
         return middle;
       }
       r.setOperand1(middle);
       setStart(r, middle);
       middle = r;
       r = (IASTBinaryExpression) r.getParent();
     } else if (l instanceof IASTCastExpression) {
       // cast binds stronger than binary operator
       ((IASTCastExpression) l).setOperand(middle);
       setEnd(l, middle);
       middle = l; // middle becomes cast-expr, can be put into r (a binary-expr)
       l = (IASTExpression) l.getParent();
     } else if (l instanceof IASTUnaryExpression) { //
       // unary operator binds stronger than binary operator
       ((IASTUnaryExpression) l).setOperand(middle);
       setEnd(l, middle);
       middle = l; // middle becomes unary-expr, can be put into r (a binary-expr)
       l = (IASTExpression) l.getParent();
     } else {
       if (r == null || getPrecendence((IASTBinaryExpression) l) >= getPrecendence(r)) {
         ((IASTBinaryExpression) l).setOperand2(middle);
         setEnd(l, middle);
         middle =
             l; // middle becomes binary, can be put into r because precedence is greater or equal.
         l = (IASTExpression) l.getParent();
       } else {
         r.setOperand1(middle);
         setStart(r, middle);
         middle = r; // middle becomes binary, can be put into r because precedence is greater.
         r = (IASTBinaryExpression) r.getParent();
       }
     }
   }
 }