Start line:  
End line:  

Snippet Preview

Snippet HTML Code

Stack Overflow Questions
  /*
   * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS HEADER.
   *
   * Copyright 2010 Oracle and/or its affiliates. All rights reserved.
   *
   * Oracle and Java are registered trademarks of Oracle and/or its affiliates.
   * Other names may be trademarks of their respective owners.
   *
   * The contents of this file are subject to the terms of either the GNU
  * General Public License Version 2 only ("GPL") or the Common
  * Development and Distribution License("CDDL") (collectively, the
  * "License"). You may not use this file except in compliance with the
  * License. You can obtain a copy of the License at
  * http://www.netbeans.org/cddl-gplv2.html
  * or nbbuild/licenses/CDDL-GPL-2-CP. See the License for the
  * specific language governing permissions and limitations under the
  * License.  When distributing the software, include this License Header
  * Notice in each file and include the License file at
  * nbbuild/licenses/CDDL-GPL-2-CP.  Oracle designates this
  * particular file as subject to the "Classpath" exception as provided
  * by Oracle in the GPL Version 2 section of the License file that
  * accompanied this code. If applicable, add the following below the
  * License Header, with the fields enclosed by brackets [] replaced by
  * your own identifying information:
  * "Portions Copyrighted [year] [name of copyright owner]"
  * 
  * If you wish your version of this file to be governed by only the CDDL
  * or only the GPL Version 2, indicate your decision by adding
  * "[Contributor] elects to include this software in this distribution
  * under the [CDDL or GPL Version 2] license." If you do not indicate a
  * single choice of license, a recipient has the option to distribute
  * your version of this file under either the CDDL, the GPL Version 2 or
  * to extend the choice of license to its licensees as provided above.
  * However, if you add GPL Version 2 code and therefore, elected the GPL
  * Version 2 license, then the option applies only if the new code is
  * made subject to such option by the copyright holder.
  * 
  * Contributor(s):
  * 
  * Portions Copyrighted 2008 Sun Microsystems, Inc.
  */
 
 package org.netbeans.modules.cnd.editor.reformat;
 
 import static org.netbeans.cnd.api.lexer.CppTokenId.*;

Author(s):
Alexander Simon
 
 public class ContextDetector extends ExtendedTokenSequence {
     private BracesStack braces;
     /*package local*/ ContextDetector(TokenSequence<CppTokenIdtsDiffLinkedList diffsBracesStack bracesint tabSize){
         super(tsdiffstabSize);
         this. = braces;
     }
     
     /*package local*/ boolean isStatementContinuation(){
         Token<CppTokenIdprev = lookPreviousImportant();
         Token<CppTokenIdnext = lookNextImportant();
         if (token().id() ==  && next != null && next.id() == ) {
             next = lookNextImportant(2);
         }
         if (prev == null || next == null){
             return false;
         }
         if (next.id() == ) {
             if (prev.id() == ) {
                 return false;
             } else if (prev.id() == ) {
                 prev =lookPreviousStatement();
                 if (prev == null || prev.id() == ){
                     return false;
                 }
             }
         }
         return true;
     }
 
     /*package local*/ boolean isQuestionColumn(){
         int index = index();
         try {
             int depth = 0;
             while(movePrevious()) {
                 if (. >= index()){
                     return false;
                 }
                 switch (token().id()) {
                     case :
                         depth++;
                         break;
                     case :
                         depth--;
                         if (depth < 0) {
                             return false;
                         }
                        break;
                    case :
                        if (depth == 0) {
                            return true;
                        }
                        break;
                    case :
                    case :
                    case :
                        return false;
                }
            }
            return false;
        } finally {
            moveIndex(index);
            moveNext();
        }
    }
    
    /*package local*/ boolean isLikeTemplate(Token<CppTokenIdcurrent){
        int index = index();
        try {
            boolean back = current.id() == ;
            Token<CppTokenIdhead = null;
            if (!back){
                head = lookPreviousImportant();
                if (head == null || head.id() != ){
                    return false;
                }
            }
            int depth = 0;
            while(true) {
                if (back) {
                    if (!movePrevious()) {
                        return false;
                    }
                } else {
                    if (!moveNext()){
                        return false;
                    }
                }
                switch (token().id()) {
                    case :
                    case :
                    case :
                    case :
                    case :
                    case :
                    case :
                    case :
                        break;
                    case :
                        if (back) {
                            depth++;
                        } else {
                            if (depth == 0) {
                                // end of template
                                return true;
                            }
                            depth--;
                        }
                        break;
                    case :
                        if (back) {
                            if (depth == 0) {
                                // start of template
                                head = lookPreviousImportant();
                                if (head == null || head.id() != ){
                                    return false;
                                }
                                return true;
                            }
                            depth--;
                        } else {
                            depth++;
                        }
                        break;
                    case :
                    case :
                    case :
                    case :
                    case :
                    case :
                    case :
                    case :
                    case :
                    case :
                    case :
                    case :
                        //it's a template specialization
                        break;
                    case :
                    case :
                    case :
                    case :
                    case :
                    case :
                    case :
                    case :
                    case :
                    case :
                    case :
                    case :
                    case :
                    case :
                    case :
                        break;
                    default:
                        return false;
                }
            }
        } finally {
            moveIndex(index);
            moveNext();
        }
    }
    
    /*package local*/ boolean isTypeCast() {
        int index = index();
        try {
            boolean findId = false;
            boolean findModifier = false;
            if (token().id() == ) {
                while (movePrevious()) {
                    switch (token().id()) {
                        case :
                        {
                            if (findId) {
                                moveIndex(index);
                                moveNext();
                                return checknextAfterCast();
                            }
                            return false;
                        }
                        case :
                        case :
                        case :
                        case :
                        case :
                        case :
                        case :
                        case :
                        case :
                        case :
                            return true;
                        case :
                            findId = true;
                            break;
                        case :
                        case :
                        case :
                        case :
                            if (findId) {
                                return false;
                            }
                            findModifier = true;
                            break;
                        case :
                        case :
                        case :
                        case :
                        case :
                        case :
                        case :
                        case :
                            break;
                        default:
                            return false;
                    }
                }
            } else if (token().id() == ) {
                while (moveNext()) {
                    switch (token().id()) {
                        case :
                        {
                            if (findId) {
                                return checknextAfterCast();
                            }
                            return false;
                        }
                        case :
                        case :
                        case :
                        case :
                        case :
                        case :
                        case :
                        case :
                        case :
                        case :
                            return true;
                        case :
                            if (findModifier) {
                                return false;
                            }
                            findId = true;
                            break;
                        case :
                        case :
                        case :
                        case :
                            findModifier = true;
                            break;
                        case :
                        case :
                        case :
                        case :
                        case :
                        case :
                        case :
                        case :
                            break;
                        default:
                            return false;
                    }
                }
            }
            return false;
        } finally {
            moveIndex(index);
            moveNext();
        }
    }
    private boolean checknextAfterCast() {
        Token<CppTokenIdnext = lookNextImportant();
        if (next != null) {
            String prevCategory = next.id().primaryCategory();
            if (.equals(prevCategory) ||
                    .equals(prevCategory) ||
                    .equals(prevCategory) ||
                    .equals(prevCategory)) {
                return true;
            }
            switch (next.id()) {
                case :
                case :
                case :
                    return true;
            }
        }
        return false;
    }
    /*package local*/ boolean isPrefixOperator(Token<CppTokenIdcurrent){
        Token<CppTokenIdprevious = lookPreviousImportant();
        if (previous != null) {
            String prevCategory = previous.id().primaryCategory();
            if (.equals(prevCategory)) {
                return true;
            }
            switch(previous.id()){
                case :
                case :
                case :
                case :
                case :
                case :
                    return true;
                default:
                    return false;
            }
        }
        return true;
    }
    /*package local*/ boolean isPostfixOperator(Token<CppTokenIdcurrent){
        Token<CppTokenIdnext = lookNextImportant();
        if (next != null) {
            String nextCategory = next.id().primaryCategory();
            if (.equals(nextCategory)) {
                return true;
            }
            switch(next.id()){
                case :
                case :
                case :
                case :
                case :
                    return true;
                default:
                    return false;
            }
        }
        return true;
    }
    
    /*package local*/ OperatorKind getOperatorKind(Token<CppTokenIdcurrent){
        Token<CppTokenIdprevious = lookPreviousImportant();
        Token<CppTokenIdnext = lookNextImportant();
        if (previous != null && next != null) {
            String prevCategory = previous.id().primaryCategory();
            if (.equals(prevCategory) ||
                .equals(prevCategory) ||
                (.equals(prevCategory) &&
                 previous.id() !=  && previous.id() != )){
                switch(current.id()){
                    case :
                    case :
                        return .;
                    case :
                    case :
                        return .;
                    case :
                    case :
                    default:
                        return .;
                }
            }
            if (.equals(prevCategory)) {
                switch(previous.id()){
                    case //("=", "operator"),
                    case //("+=", "operator"),
                    case //("-=", "operator"),
                    case //("*=", "operator"),
                    case //("/=", "operator"),
                    case //("&=", "operator"),
                    case //("|=", "operator"),
                    case //("^=", "operator"),
                    case //("%=", "operator"),
                    case //("<<=", "operator"),
                    case //(">>=", "operator"),
                        switch(current.id()){
                            case :
                            case :
                            case :
                            case :
                                return .;
                            case :
                            case :
                            default:
                                return .;
                        }
                    case //("<", "operator"),
                    case //("==", "operator"),
                    case //("<=", "operator"),
                    case //(">=", "operator"),
                    case //("!=","operator"),
                    case //("&&", "operator"),
                    case //("||", "operator"),
                    case //("/", "operator"),
                    case //("|", "operator"),
                    case //("%", "operator"),
                    case //("<<", "operator"),
                    case //(">>", "operator"),
                        switch(current.id()){
                            case :
                            case :
                            case :
                            case :
                                return .;
                            case :
                            case :
                            default:
                                return .;
                        }
                    case //(">", "operator"),
                        switch(current.id()){
                            case :
                            case :
                                return .;
                            case :
                            case :
                                return .;
                        }
                        break;
                }
            }
            if (.equals(prevCategory) ||
                .equals(prevCategory) ||
                .equals(prevCategory) ||
                .equals(prevCategory)){
                return .;
            }
            String nextCategory = next.id().primaryCategory();
            if (.equals(nextCategory)){
                switch(current.id()){
                    case :
                    case :
                        return .;
                    case :
                    case :
                        return .;
                    case :
                    case :
                    default:
                        return .;
                }
            }
            if (.equals(nextCategory) ||
                .equals(nextCategory) ||
                .equals(nextCategory) ||
                .equals(nextCategory))  {
                if (.equals(prevCategory)||
                    .equals(prevCategory)) {
                     switch(current.id()){
                        case :
                        case :
                            return .;
                        case :
                        case :
                            return .;
                        case :
                        case :
                        default:
                            switch (previous.id()) {
                                case ://)")", "separator"),
                                case ://("]", "separator"),
                                    return .;
                            }
                            return .;
                    }
                } else {
                    return .;
                }
            }
            if (previous.id() ==  || previous.id() == ){
                if (next.id() == ) {
                    if (isPreviousStatementParen() || isPreviousTypeCastParen()) {
                        switch(current.id()){
                            case :
                            case :
                                return .;
                            case :
                            case :
                                return .;
                            case :
                            case :
                            default:
                                return .;
                        }
                    } else {
                        return .;
                    }
                }
            }
            if (previous.id() == ){
                if (next.id() == ){
                    // TODO need detect that previous ID is not type
                    if (.isDeclarationLevel()){
                        switch(current.id()){
                            case :
                            case :
                                return .;
                            case :
                            case :
                                return .;
                            case :
                            case :
                            default:
                                return .;
                        }
                    }
                    return .;
                }
                if (.equals(nextCategory) ||
                    .equals(nextCategory)){
                    switch(current.id()){
                        case :
                        case :
                            return .;
                        case :
                        case :
                            return .;
                        case :
                        case :
                        default:
                            return .;
                    }
                }
                if (next.id() == ) {
                    // TODO need detect that previous ID is not type
                    switch(current.id()){
                        case :
                        case :
                            if (.isDeclarationLevel()) {
                                return .;
                            } else if (isLikeForDeclaration()) {
                                return .;
                            } else if (isLikeExpession()) {
                                return .;
                            }
                            return .;
                        case :
                        case :
                            return .;
                        case :
                        case :
                        default:
                            if (.isDeclarationLevel()) {
                                return .;
                            } else if (isLikeTemplate(current)) {
                                return .;
                            } else if (isLikeExpession()) {
                                return .;
                            }
                            return .;
                    }
                }
            }
        }
        return .;
    }
    
    private boolean isPreviousStatementParen(){
        int index = index();
        try {
            while(movePrevious()){
                switch (token().id()) {
                    case :
                    case :
                    case :
                    case :
                    case :
                    case :
                    case :
                    case :
                        break;
                    default:
                        return isStatementParen();
                }
            }
            return true;
        } finally {
            moveIndex(index);
            moveNext();
        }
    }
    private boolean isPreviousTypeCastParen(){
        int index = index();
        try {
            while(movePrevious()){
                switch (token().id()) {
                    case :
                    case :
                    case :
                    case :
                    case :
                    case :
                    case :
                    case :
                        break;
                    default:
                        return isTypeCast();
                }
            }
            return true;
        } finally {
            moveIndex(index);
            moveNext();
        }
    }
    
    private boolean isLikeForDeclaration(){
        StackEntry entry = .peek();
        if (entry == null || entry.getKind() != ){
            return false;
        }
        int index = index();
        int level = 1;
        try {
            while (movePrevious()) {
                switch (token().id()) {
                    case :
                        level++;
                        break;
                    case :
                        level--;
                        break;
                    case :
                        if (level == 0) {
                            return true;
                        }
                        return false;
                    case :
                    case :
                        return false;
                    default:
                        break;
                }
            }
            return false;
        } finally {
            moveIndex(index);
            moveNext();
        }
    }
    
    private boolean isStatementParen(){
        if (token().id() == ){
            int level = 1;
            while(movePrevious()){
                switch (token().id()) {
                    case :
                        level++;
                        break;
                    case :
                        level--;
                        if (level == 0){
                            Token<CppTokenIdprevious = lookPreviousImportant();
                            if (previous != null) {
                                switch (previous.id()) {
                                    case :
                                    case :
                                    case :
                                    case :
                                    case :
                                        return true;
                                    default:
                                        while(movePrevious()){
                                            switch (token().id()) {
                                                case :
                                                case :
                                                case :
                                                case :
                                                case :
                                                case :
                                                case :
                                                case :
                                                    break;
                                                default:
                                                    return index() == .;
                                            }
                                        }
                                        break;
                                }
                            }
                            return false;
                        }
                        break;
                }
            }
        }
        return false;
    }
    
    private boolean isLikeExpession(){
        StackEntry entry = .peek();
        if (entry != null && 
           (entry.getKind() ==  || entry.getKind() ==  || entry.getKind() == )){
            return true;
        }
        int index = index();
        try {
            while(moveNext()){
                switch (token().id()) {
                    case :
                    case :
                    case :
                    case :
                    case :
                    case :
                    case :
                    case :
                    case :
                        break;
                    case :
                    case :
                    case :
                        return false;
                    default:
                        return true;
                }
            }
            return true;
        } finally {
            moveIndex(index);
            moveNext();
        }
    }
    
    /*package local*/ static enum OperatorKind {
        BINARY,
        UNARY,
        SEPARATOR,
        TYPE_MODIFIER
    }
New to GrepCode? Check out our FAQ X