Examples of org.eclipse.jdt.internal.compiler.parser.Scanner$VanguardScanner

Package org.eclipse.jdt.internal.compiler.parser

Examples of org.eclipse.jdt.internal.compiler.parser.Scanner$VanguardScanner

org.eclipse.jdt.internal.compiler.parser.Scanner
IMPORTANT NOTE: Internal Scanner implementation. It is mirrored in org.eclipse.jdt.core.compiler public package where it is API. The mirror implementation is using the backward compatible ITerminalSymbols constant definitions (stable with 2.0), whereas the internal implementation uses TerminalTokens which constant values reflect the latest parser generation state.

}


private static SearchPattern createFieldPattern(String patternString, int limitTo, int matchRule) {
  // use 1.7 as the source level as there are more valid tokens in 1.7 mode
  // https://bugs.eclipse.org/bugs/show_bug.cgi?id=376673
  Scanner scanner = new Scanner(false /*comment*/, true /*whitespace*/, false /*nls*/, ClassFileConstants.JDK1_7/*sourceLevel*/, null /*taskTags*/, null/*taskPriorities*/, true/*taskCaseSensitive*/);
  scanner.setSource(patternString.toCharArray());
  final int InsideDeclaringPart = 1;
  final int InsideType = 2;
  int lastToken = -1;


  String declaringType = null, fieldName = null;
  String type = null;
  int mode = InsideDeclaringPart;
  int token;
  try {
    token = scanner.getNextToken();
  } catch (InvalidInputException e) {
    return null;
  }
  while (token != TerminalTokens.TokenNameEOF) {
    switch(mode) {
      // read declaring type and fieldName
      case InsideDeclaringPart :
        switch (token) {
          case TerminalTokens.TokenNameDOT:
            if (declaringType == null) {
              if (fieldName == null) return null;
              declaringType = fieldName;
            } else {
              String tokenSource = scanner.getCurrentTokenString();
              declaringType += tokenSource + fieldName;
            }
            fieldName = null;
            break;
          case TerminalTokens.TokenNameWHITESPACE:
            if (!(TerminalTokens.TokenNameWHITESPACE == lastToken || TerminalTokens.TokenNameDOT == lastToken))
              mode = InsideType;
            break;
          default: // all other tokens are considered identifiers (see bug 21763 Problem in Java search [search])
            if (fieldName == null)
              fieldName = scanner.getCurrentTokenString();
            else
              fieldName += scanner.getCurrentTokenString();
        }
        break;
      // read type
      case InsideType:
        switch (token) {
          case TerminalTokens.TokenNameWHITESPACE:
            break;
          default: // all other tokens are considered identifiers (see bug 21763 Problem in Java search [search])
            if (type == null)
              type = scanner.getCurrentTokenString();
            else
              type += scanner.getCurrentTokenString();
        }
        break;
    }
    lastToken = token;
    try {
      token = scanner.getNextToken();
    } catch (InvalidInputException e) {
      return null;
    }
  }
  if (fieldName == null) return null;

View Full Code Here

}


private static SearchPattern createMethodOrConstructorPattern(String patternString, int limitTo, int matchRule, boolean isConstructor) {
  // use 1.7 as the source level as there are more valid tokens in 1.7 mode
  // https://bugs.eclipse.org/bugs/show_bug.cgi?id=376673
  Scanner scanner = new Scanner(false /*comment*/, true /*whitespace*/, false /*nls*/, ClassFileConstants.JDK1_7/*sourceLevel*/, null /*taskTags*/, null/*taskPriorities*/, true/*taskCaseSensitive*/);
  scanner.setSource(patternString.toCharArray());
  final int InsideSelector = 1;
  final int InsideTypeArguments = 2;
  final int InsideParameter = 3;
  final int InsideReturnType = 4;
  int lastToken = -1;


  String declaringType = null, selector = null, parameterType = null;
  String[] parameterTypes = null;
  char[][] typeArguments = null;
  String typeArgumentsString = null;
  int parameterCount = -1;
  String returnType = null;
  boolean foundClosingParenthesis = false;
  int mode = InsideSelector;
  int token, argCount = 0;
  try {
    token = scanner.getNextToken();
  } catch (InvalidInputException e) {
    return null;
  }
  while (token != TerminalTokens.TokenNameEOF) {
    switch(mode) {
      // read declaring type and selector
      case InsideSelector :
        if (argCount == 0) {
          switch (token) {
            case TerminalTokens.TokenNameLESS:
              argCount++;
              if (selector == null || lastToken == TerminalTokens.TokenNameDOT) {
                typeArgumentsString = scanner.getCurrentTokenString();
                mode = InsideTypeArguments;
                break;
              }
              if (declaringType == null) {
                declaringType = selector;
              } else {
                declaringType += '.' + selector;
              }
              declaringType += scanner.getCurrentTokenString();
              selector = null;
              break;
            case TerminalTokens.TokenNameDOT:
              if (!isConstructor && typeArgumentsString != null) return null; // invalid syntax
              if (declaringType == null) {
                if (selector == null) return null; // invalid syntax
                declaringType = selector;
              } else if (selector != null) {
                declaringType += scanner.getCurrentTokenString() + selector;
              }
              selector = null;
              break;
            case TerminalTokens.TokenNameLPAREN:
              parameterTypes = new String[5];
              parameterCount = 0;
              mode = InsideParameter;
              break;
            case TerminalTokens.TokenNameWHITESPACE:
              switch (lastToken) {
                case TerminalTokens.TokenNameWHITESPACE:
                case TerminalTokens.TokenNameDOT:
                case TerminalTokens.TokenNameGREATER:
                case TerminalTokens.TokenNameRIGHT_SHIFT:
                case TerminalTokens.TokenNameUNSIGNED_RIGHT_SHIFT:
                  break;
                default:
                  mode = InsideReturnType;
                  break;
              }
              break;
            default: // all other tokens are considered identifiers (see bug 21763 Problem in Java search [search])
              if (selector == null)
                selector = scanner.getCurrentTokenString();
              else
                selector += scanner.getCurrentTokenString();
              break;
          }
        } else {
          if (declaringType == null) return null; // invalid syntax
          switch (token) {
            case TerminalTokens.TokenNameGREATER:
            case TerminalTokens.TokenNameRIGHT_SHIFT:
            case TerminalTokens.TokenNameUNSIGNED_RIGHT_SHIFT:
              argCount--;
              break;
            case TerminalTokens.TokenNameLESS:
              argCount++;
              break;
          }
          declaringType += scanner.getCurrentTokenString();
        }
        break;
      // read type arguments
      case InsideTypeArguments:
        if (typeArgumentsString == null) return null; // invalid syntax
        typeArgumentsString += scanner.getCurrentTokenString();
        switch (token) {
          case TerminalTokens.TokenNameGREATER:
          case TerminalTokens.TokenNameRIGHT_SHIFT:
          case TerminalTokens.TokenNameUNSIGNED_RIGHT_SHIFT:
            argCount--;
            if (argCount == 0) {
              String pseudoType = "Type"+typeArgumentsString; //$NON-NLS-1$
              typeArguments = Signature.getTypeArguments(Signature.createTypeSignature(pseudoType, false).toCharArray());
              mode = InsideSelector;
            }
            break;
          case TerminalTokens.TokenNameLESS:
            argCount++;
            break;
        }
        break;
      // read parameter types
      case InsideParameter :
        if (argCount == 0) {
          switch (token) {
            case TerminalTokens.TokenNameWHITESPACE:
              break;
            case TerminalTokens.TokenNameCOMMA:
              if (parameterType == null) return null;
              if (parameterTypes != null) {
                if (parameterTypes.length == parameterCount)
                  System.arraycopy(parameterTypes, 0, parameterTypes = new String[parameterCount*2], 0, parameterCount);
                parameterTypes[parameterCount++] = parameterType;
              }
              parameterType = null;
              break;
            case TerminalTokens.TokenNameRPAREN:
              foundClosingParenthesis = true;
              if (parameterType != null && parameterTypes != null) {
                if (parameterTypes.length == parameterCount)
                  System.arraycopy(parameterTypes, 0, parameterTypes = new String[parameterCount*2], 0, parameterCount);
                parameterTypes[parameterCount++] = parameterType;
              }
              mode = isConstructor ? InsideTypeArguments : InsideReturnType;
              break;
            case TerminalTokens.TokenNameLESS:
              argCount++;
              if (parameterType == null) return null; // invalid syntax
              // $FALL-THROUGH$ - fall through next case to add token
            default: // all other tokens are considered identifiers (see bug 21763 Problem in Java search [search])
              if (parameterType == null)
                parameterType = scanner.getCurrentTokenString();
              else
                parameterType += scanner.getCurrentTokenString();
          }
        } else {
          if (parameterType == null) return null; // invalid syntax
          switch (token) {
            case TerminalTokens.TokenNameGREATER:
            case TerminalTokens.TokenNameRIGHT_SHIFT:
            case TerminalTokens.TokenNameUNSIGNED_RIGHT_SHIFT:
              argCount--;
              break;
            case TerminalTokens.TokenNameLESS:
              argCount++;
              break;
          }
          parameterType += scanner.getCurrentTokenString();
        }
        break;
      // read return type
      case InsideReturnType:
        if (argCount == 0) {
          switch (token) {
            case TerminalTokens.TokenNameWHITESPACE:
              break;
            case TerminalTokens.TokenNameLPAREN:
              parameterTypes = new String[5];
              parameterCount = 0;
              mode = InsideParameter;
              break;
            case TerminalTokens.TokenNameLESS:
              argCount++;
              if (returnType == null) return null; // invalid syntax
              // $FALL-THROUGH$ - fall through next case to add token
            default: // all other tokens are considered identifiers (see bug 21763 Problem in Java search [search])
              if (returnType == null)
                returnType = scanner.getCurrentTokenString();
              else
                returnType += scanner.getCurrentTokenString();
          }
        } else {
          if (returnType == null) return null; // invalid syntax
          switch (token) {
            case TerminalTokens.TokenNameGREATER:
            case TerminalTokens.TokenNameRIGHT_SHIFT:
            case TerminalTokens.TokenNameUNSIGNED_RIGHT_SHIFT:
              argCount--;
              break;
            case TerminalTokens.TokenNameLESS:
              argCount++;
              break;
          }
          returnType += scanner.getCurrentTokenString();
        }
        break;
    }
    lastToken = token;
    try {
      token = scanner.getNextToken();
    } catch (InvalidInputException e) {
      return null;
    }
  }
  // parenthesis mismatch

View Full Code Here

}


private static SearchPattern createTypePattern(String patternString, int limitTo, int matchRule, char indexSuffix) {
  // use 1.7 as the source level as there are more valid tokens in 1.7 mode
  // https://bugs.eclipse.org/bugs/show_bug.cgi?id=376673
  Scanner scanner = new Scanner(false /*comment*/, true /*whitespace*/, false /*nls*/, ClassFileConstants.JDK1_7/*sourceLevel*/, null /*taskTags*/, null/*taskPriorities*/, true/*taskCaseSensitive*/);
  scanner.setSource(patternString.toCharArray());
  String type = null;
  int token;
  try {
    token = scanner.getNextToken();
  } catch (InvalidInputException e) {
    return null;
  }
  int argCount = 0;
  while (token != TerminalTokens.TokenNameEOF) {
    if (argCount == 0) {
      switch (token) {
        case TerminalTokens.TokenNameWHITESPACE:
          break;
        case TerminalTokens.TokenNameLESS:
          argCount++;
          // $FALL-THROUGH$ - fall through default case to add token to type
        default: // all other tokens are considered identifiers (see bug 21763 Problem in Java search [search])
          if (type == null)
            type = scanner.getCurrentTokenString();
          else
            type += scanner.getCurrentTokenString();
      }
    } else {
      switch (token) {
        case TerminalTokens.TokenNameGREATER:
        case TerminalTokens.TokenNameRIGHT_SHIFT:
        case TerminalTokens.TokenNameUNSIGNED_RIGHT_SHIFT:
          argCount--;
          break;
        case TerminalTokens.TokenNameLESS:
          argCount++;
          break;
      }
      if (type == null) return null; // invalid syntax
      type += scanner.getCurrentTokenString();
    }
    try {
      token = scanner.getNextToken();
    } catch (InvalidInputException e) {
      return null;
    }
  }
  if (type == null) return null;

View Full Code Here

      supportedOnlyIn2();
    if (docComment == null) {
      throw new IllegalArgumentException();
    }
    char[] source = docComment.toCharArray();
    Scanner scanner = this.ast.scanner;
    scanner.resetTo(0, source.length);
    scanner.setSource(source);
    try {
      int token;
      boolean onlyOneComment = false;
      while ((token = scanner.getNextToken()) != TerminalTokens.TokenNameEOF) {
        switch(token) {
          case TerminalTokens.TokenNameCOMMENT_JAVADOC :
            if (onlyOneComment) {
              throw new IllegalArgumentException();
            }

View Full Code Here

  public void setEscapedValue(String value) {
    // check setInternalEscapedValue(String) if this method is changed
    if (value == null) {
      throw new IllegalArgumentException();
    }
    Scanner scanner = this.ast.scanner;
    char[] source = value.toCharArray();
    scanner.setSource(source);
    scanner.resetTo(0, source.length);
    try {
      int tokenType = scanner.getNextToken();
      switch(tokenType) {
        case TerminalTokens.TokenNameCharacterLiteral:
          break;
        default:
          throw new IllegalArgumentException();

View Full Code Here

   * @return the character value without enclosing quotes and embedded
   *    escapes
   * @exception IllegalArgumentException if the literal value cannot be converted
   */
  public char charValue() {
    Scanner scanner = this.ast.scanner;
    char[] source = this.escapedValue.toCharArray();
    scanner.setSource(source);
    scanner.resetTo(0, source.length);
    int firstChar = scanner.getNextChar();
    int secondChar = scanner.getNextChar();


    if (firstChar == -1 || firstChar != '\'') {
      throw new IllegalArgumentException("illegal character literal");//$NON-NLS-1$
    }
    char value = (char) secondChar;
    int nextChar = scanner.getNextChar();
    if (secondChar == '\\') {
      if (nextChar == -1) {
        throw new IllegalArgumentException("illegal character literal");//$NON-NLS-1$
      }
      switch(nextChar) {
        case 'b' :
          value = '\b';
          break;
        case 't' :
          value = '\t';
          break;
        case 'n' :
          value = '\n';
          break;
        case 'f' :
          value = '\f';
          break;
        case 'r' :
          value = '\r';
          break;
        case '\"':
          value = '\"';
          break;
        case '\'':
          value = '\'';
          break;
        case '\\':
          value = '\\';
          break;
        default : //octal (well-formed: ended by a ' )
          try {
            if (ScannerHelper.isDigit((char) nextChar)) {
              int number = ScannerHelper.getNumericValue((char) nextChar);
              nextChar = scanner.getNextChar();
              if (nextChar == -1) {
                throw new IllegalArgumentException("illegal character literal");//$NON-NLS-1$
              }
              if (nextChar != '\'') {
                if (!ScannerHelper.isDigit((char) nextChar)) {
                  throw new IllegalArgumentException("illegal character literal");//$NON-NLS-1$
                }
                number = (number * 8) + ScannerHelper.getNumericValue((char) nextChar);
                nextChar = scanner.getNextChar();
                if (nextChar == -1) {
                  throw new IllegalArgumentException("illegal character literal");//$NON-NLS-1$
                }
                if (nextChar != '\'') {
                  if (!ScannerHelper.isDigit((char) nextChar)) {
                    throw new IllegalArgumentException("illegal character literal");//$NON-NLS-1$
                  }
                  number = (number * 8) + ScannerHelper.getNumericValue((char) nextChar);
                }
              }
              return (char) number;
            } else {
              throw new IllegalArgumentException("illegal character literal");//$NON-NLS-1$
            }
          } catch (InvalidInputException e) {
            throw new IllegalArgumentException("illegal character literal");//$NON-NLS-1$
          }
      }
      nextChar = scanner.getNextChar();
      if (nextChar == -1) {
        throw new IllegalArgumentException("illegal character literal");//$NON-NLS-1$
      }
    }
    if (nextChar == -1 || nextChar != '\'') {

View Full Code Here

public class InternalNamingConventions {
  private static final char[] DEFAULT_NAME = "name".toCharArray(); //$NON-NLS-1$


  private static Scanner getNameScanner(CompilerOptions compilerOptions) {
    return
      new Scanner(
        false /*comment*/,
        false /*whitespace*/,
        false /*nls*/,
        compilerOptions.sourceLevel /*sourceLevel*/,
        null /*taskTags*/,

View Full Code Here

      internalPrefix = removePrefix(internalPrefix, prefixes);
    }


    char[][] tempNames = null;
    
    Scanner nameScanner = getNameScanner(compilerOptions);
    if (baseNameKind == BK_SIMPLE_TYPE_NAME) {
      boolean isBaseType = false;
      
      try{
        nameScanner.setSource(baseName);
        switch (nameScanner.getNextToken()) {
          case TerminalTokens.TokenNameint :
          case TerminalTokens.TokenNamebyte :
          case TerminalTokens.TokenNameshort :
          case TerminalTokens.TokenNamechar :
          case TerminalTokens.TokenNamelong :
          case TerminalTokens.TokenNamefloat :
          case TerminalTokens.TokenNamedouble :
          case TerminalTokens.TokenNameboolean :
            isBaseType = true;
            break;
        }
      } catch(InvalidInputException e){
        // ignore
      }
      if (isBaseType) {
        // compute variable name from base type
        if (internalPrefix.length > 0) return;
  
        tempNames = computeBaseTypeNames(baseName, isConstantField, excluded);
      } else {
        // compute variable name for non base type
        tempNames = computeNonBaseTypeNames(baseName, isConstantField, false);
      }
    } else {
      tempNames = computeNonBaseTypeNames(baseName, isConstantField, true);
    }


    boolean acceptDefaultName = true;
    SimpleSetOfCharArray foundNames = new SimpleSetOfCharArray();


    for (int i = 0; i < tempNames.length; i++) {
      char[] tempName = tempNames[i];
      
      // add English plural form is necessary
      if(dim > 0) {
        int length = tempName.length;
        
        if (isConstantField) {
          if (tempName[length-1] == 'S'){
            if(tempName.length > 1 && tempName[length-2] == 'S') {
              System.arraycopy(tempName, 0, tempName = new char[length + 2], 0, length);
              tempName[length] = 'E';
              tempName[length+1] = 'S';
            }
          } else if(tempName[length-1] == 'Y') {
            boolean precededByAVowel = false;
            if(tempName.length > 1) {
              switch (tempName[length-2]) {
                case 'A':
                case 'E':
                case 'I':
                case 'O':
                case 'U':
                  precededByAVowel = true;
                  break;
              }
            }
            if (precededByAVowel) {
              System.arraycopy(tempName, 0, tempName = new char[length + 1], 0, length);
              tempName[length] = 'S';
            } else {
              System.arraycopy(tempName, 0, tempName = new char[length + 2], 0, length);
              tempName[length-1] = 'I';
              tempName[length] = 'E';
              tempName[length+1] = 'S';
            }
          } else {
            System.arraycopy(tempName, 0, tempName = new char[length + 1], 0, length);
            tempName[length] = 'S';
          }
        } else {
          if (tempName[length-1] == 's'){
            if(tempName.length > 1 && tempName[length-2] == 's') {
              System.arraycopy(tempName, 0, tempName = new char[length + 2], 0, length);
              tempName[length] = 'e';
              tempName[length+1] = 's';
            }
          } else if(tempName[length-1] == 'y') {
            boolean precededByAVowel = false;
            if(tempName.length > 1) {
              switch (tempName[length-2]) {
                case 'a':
                case 'e':
                case 'i':
                case 'o':
                case 'u':
                  precededByAVowel = true;
                  break;
              }
            }
            if (precededByAVowel) {
              System.arraycopy(tempName, 0, tempName = new char[length + 1], 0, length);
              tempName[length] = 's';
            } else {
              System.arraycopy(tempName, 0, tempName = new char[length + 2], 0, length);
              tempName[length-1] = 'i';
              tempName[length] = 'e';
              tempName[length+1] = 's';
            }
          } else {
            System.arraycopy(tempName, 0, tempName = new char[length + 1], 0, length);
            tempName[length] = 's';
          }
        }
      }
      
      char[] unprefixedName = tempName;
      
      int matchingIndex = -1;
      if (!isConstantField) {
        unprefixedName[0] = ScannerHelper.toUpperCase(unprefixedName[0]);
        
        done : for (int j = 0; j <= internalPrefix.length; j++) {
          if(j == internalPrefix.length ||
              CharOperation.prefixEquals(CharOperation.subarray(internalPrefix, j, -1), unprefixedName, j != 0 /*do not check case when there is no prefix*/)) {
            matchingIndex = j;
            break done;
          }
        }
      } else {
        done : for (int j = 0; j <= internalPrefix.length; j++) {
          if(j == internalPrefix.length) {
            matchingIndex = j;
            break done;
          } else if(CharOperation.prefixEquals(CharOperation.subarray(internalPrefix, j, -1), unprefixedName, j != 0 /*do not check case when there is no prefix*/)) {
            if (j == 0 || internalPrefix[j - 1] == '_') {
              matchingIndex = j;
              break done;
            }
            
          }
        }
      }


      if(matchingIndex > -1) {
        if (!isConstantField) {
          tempName = CharOperation.concat(CharOperation.subarray(internalPrefix, 0, matchingIndex), unprefixedName);
          if(matchingIndex == 0) tempName[0] = ScannerHelper.toLowerCase(tempName[0]);
        } else {
          if(matchingIndex != 0 && tempName[0] != '_' && internalPrefix[matchingIndex - 1] != '_') {
            tempName = CharOperation.concat(CharOperation.subarray(CharOperation.toUpperCase(internalPrefix), 0, matchingIndex), unprefixedName, '_');
          } else {
            tempName = CharOperation.concat(CharOperation.subarray(CharOperation.toUpperCase(internalPrefix), 0, matchingIndex), unprefixedName);
          }
        }
        
        for (int k = 0; k < prefixes.length; k++) {
          if (!isConstantField) {
            if(prefixes[k].length > 0
              && ScannerHelper.isLetterOrDigit(prefixes[k][prefixes[k].length - 1])) {
              tempName[0] = ScannerHelper.toUpperCase(tempName[0]);
            } else {
              tempName[0] = ScannerHelper.toLowerCase(tempName[0]);
            }
          }
          char[] prefixName = CharOperation.concat(prefixes[k], tempName);
          for (int l = 0; l < suffixes.length; l++) {
            char[] suffixName = CharOperation.concat(prefixName, suffixes[l]);
            suffixName =
              excludeNames(
                suffixName,
                prefixName,
                suffixes[l],
                excluded);
            try{
              nameScanner.setSource(suffixName);
              switch (nameScanner.getNextToken()) {
                case TerminalTokens.TokenNameIdentifier :
                  int token = nameScanner.getNextToken();
                  if (token == TerminalTokens.TokenNameEOF && nameScanner.startPosition == suffixName.length) {
                    if (!foundNames.includes(suffixName)) {
                      acceptName(suffixName, prefixes[k], suffixes[l],  k == 0, l == 0, internalPrefix.length - matchingIndex, requestor);
                      foundNames.add(suffixName);
                      acceptDefaultName = false;
                    }
                  }
                  break;
                default:
                  suffixName = CharOperation.concat(
                    prefixName,
                    String.valueOf(1).toCharArray(),
                    suffixes[l]
                  );
                  suffixName =
                    excludeNames(
                      suffixName,
                      prefixName,
                      suffixes[l],
                      excluded);
                  nameScanner.setSource(suffixName);
                  switch (nameScanner.getNextToken()) {
                    case TerminalTokens.TokenNameIdentifier :
                      token = nameScanner.getNextToken();
                      if (token == TerminalTokens.TokenNameEOF && nameScanner.startPosition == suffixName.length) {
                        if (!foundNames.includes(suffixName)) {
                          acceptName(suffixName, prefixes[k], suffixes[l], k == 0, l == 0, internalPrefix.length - matchingIndex, requestor);
                          foundNames.add(suffixName);
                          acceptDefaultName = false;

View Full Code Here

  /* (non-Javadoc)
   * Create and store a specific comment recorder scanner.
   * @see org.eclipse.jdt.internal.compiler.parser.Parser#initializeScanner()
   */
  public void initializeScanner() {
    this.scanner = new Scanner(
        false /*comment*/,
        false /*whitespace*/,
        this.options.getSeverity(CompilerOptions.NonExternalizedString) != ProblemSeverities.Ignore /*nls*/,
        this.options.sourceLevel /*sourceLevel*/,
        this.options.taskTags/*taskTags*/,

View Full Code Here

  ICompilationUnit compilationUnit = compilationResult.getCompilationUnit();
  if (compilationUnit == null) return start;
  char[] contents = compilationUnit.getContents();
  if (contents.length == 0) return start;
  if (this.positionScanner == null) {
    this.positionScanner = new Scanner(false, false, false, this.options.sourceLevel, this.options.complianceLevel, null, null, false);
    this.positionScanner.returnOnlyGreater = true;
  }
  this.positionScanner.setSource(contents);
  this.positionScanner.resetTo(start, contents.length);
  int end = start;

View Full Code Here

0 1 2 3 4 5 6 7 8

TOP

Related Classes of org.eclipse.jdt.internal.compiler.parser.Scanner$VanguardScanner

org.eclipse.jdt.core.dom.AST

org.eclipse.jdt.core.dom.ASTConverter

org.eclipse.jdt.core.dom.ASTParser

org.eclipse.jdt.core.dom.CharacterLiteral

org.eclipse.jdt.core.dom.Javadoc

org.eclipse.jdt.core.dom.NumberLiteral

org.eclipse.jdt.core.dom.SimpleName

org.eclipse.jdt.core.dom.Statement

org.eclipse.jdt.core.dom.StringLiteral

org.eclipse.jdt.core.search.SearchPattern

All source code are property of their respective owners. Java is a trademark of Sun Microsystems, Inc and owned by ORACLE Inc. Contact coftware#gmail.com.