// Here are the details of the matching. We track the current brace depth, and we artificially
 // consider that the whole file is at brace depth 1 inside a pseudo-class whose name is the
 // name of the package. When we see a class definition, we push the fully-qualified name of the
 // class on a stack so that we can associate abstract methods we find with the possibly-nested
 // class they belong to. A class definition must occur at brace depth one more than the class
 // containing it, which is equivalent to saying that the brace depth must be the same as the
 // class stack depth. This check excludes local class definitions within methods and
 // initializers. If we meet these constraints and we see the word "class" followed by an
 // identifier Foo, then we consider that we are entering the definition of class Foo. We determine
 // the fully-qualified name of Foo, which is container.Foo, where container is the current top of
 // the class stack (initially, the package name). We push this new fully-qualified name on the
 // class stack. We have not yet seen the left brace with the class definition so at this point the
 // class stack depth is one more than the brace depth. When we subsequently see a right brace that
 // takes us back to this situation then we know we have completed the definition of Foo and we can
 // pop it from the class stack.
 //
 // We check that the token after "class" is indeed an identifier to avoid confusion
 // with Foo.class. Even though the tokenizer does not distinguish between identifiers and
 // keywords, it is enough to exclude the single word "instanceof" because that is the only word
 // that can legally appear after Foo.class (though in a legal program the resultant expression
 // will always be true).
 //
 // Again, we are at the top level of a class when the brace depth is equal to the class stack
 // depth. If we then see the word "abstract" then that is the start either of an abstract class
 // definition or of an abstract method. We record that we have seen "abstract" and we cancel
 // that indication as soon as we see a left brace, to exclude the abstract class case, and also
 // the case of interfaces or @interfaces redundantly declared abstract. Now, when
 // we see an identifier that is preceded by an uncanceled "abstract" and followed by a left paren
 // then we have found an abstract method of the class on the top of the class stack. We record it
 // in the list of abstract methods of the class on the top of the class stack. We don't bother
 // checking that the method has no parameters, because an @AutoValue class will cause a compiler
 // error if there are abstract methods with parameters, since the @AutoValue processor doesn't
 // know how to implement them in the concrete subclass it generates.
 Map<String, List<String>> abstractMethods(JavaTokenizer tokenizer, String packageName) {
   Map<String, List<String>> abstractMethods = new HashMap<String, List<String>>();
   Deque<String> classStack = new ArrayDeque<String>();
   classStack.addLast(packageName);
   int braceDepth = 1;
   boolean sawAbstract = false;
   String className = null;
   for (String previousToken = "", token = tokenizer.nextToken();
       token != null;
       previousToken = token, token = tokenizer.nextToken()) {
     boolean topLevel = (braceDepth == classStack.size());
     if (className != null) {
       // get last term in fully-qualified class name (e.g. "class some.package.Bar { ...")
       if (token.equals(".")) {
         className = tokenizer.nextToken();
         continue;
       } else {
         if (Character.isJavaIdentifierStart(className.charAt(0))
             && !className.equals("instanceof")) {
           String container = classStack.getLast();
           // container might be empty in the case of a packageless class
           classStack.add(container.isEmpty() ? className : container + "." + className);
         }
         className = null;
       }
     }
     if (token.equals("{")) {
       braceDepth++;
       sawAbstract = false;
     } else if (token.equals("}")) {
       braceDepth--;
       if (topLevel) {
         classStack.removeLast();
       }
     } else if (topLevel) {
       if (token.equals("class") || token.equals("interface")) {
         className = tokenizer.nextToken();
       } else if (token.equals("abstract")) {
         sawAbstract = true;
       } else if (token.equals("(")) {
         if (sawAbstract && Character.isJavaIdentifierStart(previousToken.charAt(0))) {
           List<String> methods = abstractMethods.get(classStack.getLast());
           if (methods == null) {
             methods = new ArrayList<String>();
             abstractMethods.put(classStack.getLast(), methods);
           }
           methods.add(previousToken);
         }
         sawAbstract = false;
       }
     }
   }
   return abstractMethods;
 }
Ejemplo n.º 2
0
 /**
  * Checks that the given string is a valid Java identifier.
  * 
  * @param version
  *            the class version.
  * @param name
  *            the string to be checked.
  * @param msg
  *            a message to be used in case of error.
  */
 static void checkMethodIdentifier(int version, final String name,
         final String msg) {
     if (name == null || name.length() == 0) {
         throw new IllegalArgumentException("Invalid " + msg
                 + " (must not be null or empty)");
     }
     if ((version & 0xFFFF) >= Opcodes.V1_5) {
         for (int i = 0; i < name.length(); ++i) {
             if (".;[/<>".indexOf(name.charAt(i)) != -1) {
                 throw new IllegalArgumentException("Invalid " + msg
                         + " (must be a valid unqualified name): " + name);
             }
         }
         return;
     }
     if (!Character.isJavaIdentifierStart(name.charAt(0))) {
         throw new IllegalArgumentException(
                 "Invalid "
                         + msg
                         + " (must be a '<init>', '<clinit>' or a valid Java identifier): "
                         + name);
     }
     for (int i = 1; i < name.length(); ++i) {
         if (!Character.isJavaIdentifierPart(name.charAt(i))) {
             throw new IllegalArgumentException(
                     "Invalid "
                             + msg
                             + " (must be '<init>' or '<clinit>' or a valid Java identifier): "
                             + name);
         }
     }
 }
Ejemplo n.º 3
0
 @NotNull
 public static ContractsContext getContext(@NotNull String name) {
   ContractsContext context;
   if (name.equals(ROOT_NAME)) {
     return ROOT;
   }
   synchronized (CONTEXTS) {
     context = CONTEXTS.get(name);
     if (context != null) {
       return context;
     }
     if (!ROOT_NAME.equals(name)) {
       boolean firstChar = true;
       for (int i = 0; i < name.length(); i++) {
         char c = name.charAt(i);
         if (firstChar) {
           if (!Character.isJavaIdentifierStart(c)) {
             throw new IllegalArgumentException("Illegal policy name: '" + name + "'");
           }
           firstChar = false;
         } else {
           if (c == '.') {
             firstChar = true;
           } else if (!Character.isJavaIdentifierPart(c)) {
             throw new IllegalArgumentException("Illegal policy name: '" + name + "'");
           }
         }
       }
       if (firstChar) {
         throw new IllegalArgumentException("Illegal policy name: '" + name + "'");
       }
     }
     return getContext0(name);
   }
 }
Ejemplo n.º 4
0
 // Parse a single line from the given configuration file, adding the name
 // on the line to the names list.
 //
 private int parseLine(Class<?> service, URL u, BufferedReader r, int lc, List<String> names)
     throws IOException, ServiceConfigurationError {
   String ln = r.readLine();
   if (ln == null) {
     return -1;
   }
   int ci = ln.indexOf('#');
   if (ci >= 0) ln = ln.substring(0, ci);
   ln = ln.trim();
   int n = ln.length();
   if (n != 0) {
     if ((ln.indexOf(' ') >= 0) || (ln.indexOf('\t') >= 0))
       fail(service, u, lc, "Illegal configuration-file syntax");
     int cp = ln.codePointAt(0);
     if (!Character.isJavaIdentifierStart(cp))
       fail(service, u, lc, "Illegal provider-class name: " + ln);
     for (int i = Character.charCount(cp); i < n; i += Character.charCount(cp)) {
       cp = ln.codePointAt(i);
       if (!Character.isJavaIdentifierPart(cp) && (cp != '.'))
         fail(service, u, lc, "Illegal provider-class name: " + ln);
     }
     if (!providers.containsKey(ln) && !names.contains(ln)) names.add(ln);
   }
   return lc + 1;
 }
Ejemplo n.º 5
0
 public static boolean isIdentifier(Token token) {
   if (token.type != token.IDENTIFIER) return false;
   if (!Character.isJavaIdentifierStart(token.text[token.textOffset])) return false;
   for (int i = 1; i < token.textCount; i++)
     if (!Character.isJavaIdentifierPart(token.text[token.textOffset + i])) return false;
   return true;
 }
Ejemplo n.º 6
0
  private boolean checkForDynamicImport(String className) {
    if (packageImports == null) return false;
    if (!Character.isJavaIdentifierStart(className.charAt(0))) return false;
    if (nonValidImports != null && nonValidImports.contains(className)) return false;

    int found = 0;
    Class cls = null;
    for (String pkg : packageImports) {
      try {
        cls = Class.forName(pkg + "." + className, true, getClassLoader());
        found++;
      } catch (ClassNotFoundException e) {
        // do nothing.
      } catch (NoClassDefFoundError e) {
        if (PropertyTools.contains(e.getMessage(), "wrong name")) {
          // do nothing.  this is a weirdness in the jvm.
          // see MVEL-43
        } else {
          throw e;
        }
      }
    }

    if (found > 1) throw new RuntimeException("ambiguous class name: " + className);
    if (found == 1) {
      addImport(className, cls);
      return true;
    }

    cacheNegativeHitForDynamicImport(className);
    return false;
  }
Ejemplo n.º 7
0
  public IToken evaluate(ICharacterScanner scanner) {
    StringBuffer sb = new StringBuffer();
    int c = -1;

    int readCount = 0;
    while (true) {
      c = scanner.read();
      if (c == EOF) {
        scanner.unread();
        return Token.EOF;
      }
      sb.append((char) c);
      readCount++;
      if (!Character.isJavaIdentifierStart(c) && c != '<' && c != '>') {

        for (int j = 0; j < readCount; j++) {
          scanner.unread();
        }

        return Token.UNDEFINED;

      } else if (c == '>') {
        return fToken;
      }
    }
  }
Ejemplo n.º 8
0
 private static boolean isValidPackageName(String name) {
   if (name.length() == 0) {
     // Fast check of default pkg
     return true;
   }
   StringTokenizer tk = new StringTokenizer(name, ".", true); // NOI18N
   boolean delimExpected = false;
   while (tk.hasMoreTokens()) {
     String namePart = tk.nextToken();
     if (!delimExpected) {
       if (namePart.equals(".")) { // NOI18N
         return false;
       }
       for (int i = 0; i < namePart.length(); i++) {
         char c = namePart.charAt(i);
         if (i == 0) {
           if (!Character.isJavaIdentifierStart(c)) {
             return false;
           }
         } else {
           if (!Character.isJavaIdentifierPart(c)) {
             return false;
           }
         }
       }
     } else {
       if (!namePart.equals(".")) { // NOI18N
         return false;
       }
     }
     delimExpected = !delimExpected;
   }
   return delimExpected;
 }
Ejemplo n.º 9
0
  /**
   * Validates that the name of a processor option conforms to the grammar defined by <code>
   * javax.annotation.processing.Processor.getSupportedOptions()</code>.
   *
   * @param optionName
   * @return <code>true</code> if the name conforms to the grammar, <code>false</code> if not.
   */
  public static boolean isValidOptionName(String optionName) {
    if (optionName == null) {
      return false;
    }

    boolean startExpected = true;
    int codePoint;

    for (int i = 0; i < optionName.length(); i += Character.charCount(codePoint)) {
      codePoint = optionName.codePointAt(i);

      if (startExpected) {
        if (!Character.isJavaIdentifierStart(codePoint)) {
          return false;
        }

        startExpected = false;

      } else {
        if (codePoint == '.') {
          startExpected = true;

        } else if (!Character.isJavaIdentifierPart(codePoint)) {
          return false;
        }
      }
    }

    return !startExpected;
  }
Ejemplo n.º 10
0
  private static String[] getSuggestionsByValue(final String stringValue) {
    List<String> result = new ArrayList<String>();
    StringBuffer currentWord = new StringBuffer();

    boolean prevIsUpperCase = false;

    for (int i = 0; i < stringValue.length(); i++) {
      final char c = stringValue.charAt(i);
      if (Character.isUpperCase(c)) {
        if (currentWord.length() > 0 && !prevIsUpperCase) {
          result.add(currentWord.toString());
          currentWord = new StringBuffer();
        }
        currentWord.append(c);
      } else if (Character.isLowerCase(c)) {
        currentWord.append(Character.toUpperCase(c));
      } else if (Character.isJavaIdentifierPart(c) && c != '_') {
        if (Character.isJavaIdentifierStart(c) || currentWord.length() > 0 || !result.isEmpty()) {
          currentWord.append(c);
        }
      } else {
        if (currentWord.length() > 0) {
          result.add(currentWord.toString());
          currentWord = new StringBuffer();
        }
      }

      prevIsUpperCase = Character.isUpperCase(c);
    }

    if (currentWord.length() > 0) {
      result.add(currentWord.toString());
    }
    return ArrayUtil.toStringArray(result);
  }
 private boolean isQuotedName(final String name) {
   final int nameLength = name.length();
   final char[] namechars = new char[nameLength];
   name.getChars(0, nameLength, namechars, 0);
   return !Character.isJavaIdentifierStart(namechars[0])
       && namechars[0] == namechars[nameLength - 1];
 }
Ejemplo n.º 12
0
  private static String parse(String query, Map<String, List<Integer>> paramMap) {

    int length = query.length();
    StringBuilder parsedQuery = new StringBuilder(length);
    boolean inSingleQuote = false;
    boolean inDoubleQuote = false;
    int index = 1;

    for (int i = 0; i < length; i++) {

      char c = query.charAt(i);

      // String end
      if (inSingleQuote) {
        if (c == '\'') {
          inSingleQuote = false;
        }
      } else if (inDoubleQuote) {
        if (c == '"') {
          inDoubleQuote = false;
        }
      } else {

        // String begin
        if (c == '\'') {
          inSingleQuote = true;
        } else if (c == '"') {
          inDoubleQuote = true;
        } else if (c == ':'
            && i + 1 < length
            && Character.isJavaIdentifierStart(query.charAt(i + 1))) {

          // Identifier name
          int j = i + 2;
          while (j < length && Character.isJavaIdentifierPart(query.charAt(j))) {
            j++;
          }

          String name = query.substring(i + 1, j);
          c = '?';
          i += name.length();
          name = name.toLowerCase();

          // Add to list
          List<Integer> indexList = paramMap.get(name);
          if (indexList == null) {
            indexList = new LinkedList<>();
            paramMap.put(name, indexList);
          }
          indexList.add(index);

          index++;
        }
      }

      parsedQuery.append(c);
    }

    return parsedQuery.toString();
  }
Ejemplo n.º 13
0
    public static void main(String[] args)
    {
        char a[] = { 'a', '5', '?', 'A', ' ', '$', 'жа' };
        for (int i = 0; i < a.length; i++) {
            if (Character.isDigit(a[i]))
                System.out.println(a[i] + " is a digit.");
            if (Character.isLetter(a[i]))
                System.out.println(a[i] + " is a letter.");
            if (Character.isWhitespace(a[i]))
                System.out.println(a[i] + " is whitespace.");
            if (Character.isUpperCase(a[i]))
                System.out.println(a[i] + " is uppercase.");
            if (Character.isLowerCase(a[i]))
                System.out.println(a[i] + " is lowercase.");
            if (Character.isJavaIdentifierPart(a[i]))
                System.out.println(a[i]
                        + " may be part of java Identifier part.");
            if (Character.isJavaIdentifierStart(a[i]))
                System.out.println(a[i]
                        + " may be part of java Identifier Start.");
            if (Character.isUnicodeIdentifierPart(a[i]))
                System.out.println(a[i]
                        + " may be part of a Unicode identifier .");
            if (Character.isUnicodeIdentifierStart(a[i]))
                System.out
                        .println(a[i]
                                + " may be the first character in a Unicode identifier.");

        }
    }
Ejemplo n.º 14
0
 public void trySearch(SearchState state) throws RaiseException {
   // no library or extension found, try to load directly as a class
   Script script;
   String className = buildClassName(state.searchFile);
   int lastSlashIndex = className.lastIndexOf('/');
   if (lastSlashIndex > -1
       && lastSlashIndex < className.length() - 1
       && !Character.isJavaIdentifierStart(className.charAt(lastSlashIndex + 1))) {
     if (lastSlashIndex == -1) {
       className = "_" + className;
     } else {
       className =
           className.substring(0, lastSlashIndex + 1)
               + "_"
               + className.substring(lastSlashIndex + 1);
     }
   }
   className = className.replace('/', '.');
   try {
     Class scriptClass = Class.forName(className);
     script = (Script) scriptClass.newInstance();
   } catch (Exception cnfe) {
     throw runtime.newLoadError("no such file to load -- " + state.searchFile);
   }
   state.library = new ScriptClassLibrary(script);
 }
Ejemplo n.º 15
0
 public static void main(String args[]) {
   char c = 'è';
   if (Character.isJavaIdentifierStart(c)) System.out.println("char\'" + c + "\'is right");
   else System.out.println("char\'" + c + "\'isn\'t right");
   if (Character.isJavaIdentifierPart(c)) System.out.println("char\'" + c + "\'is right chu shou");
   else System.out.println("char\'" + c + "\'isn\'t right shou");
 }
Ejemplo n.º 16
0
    /**
     * Parses a type name token T (which can be potentially of the form Tr&ly;T1,T2,...>, or "?
     * extends/super T".)
     *
     * @return the index of the character next to T.
     */
    JClass parseTypeName() throws ClassNotFoundException {
      int start = idx;

      if (s.charAt(idx) == '?') {
        // wildcard
        idx++;
        ws();
        String head = s.substring(idx);
        if (head.startsWith("extends")) {
          idx += 7;
          ws();
          return parseTypeName().wildcard();
        } else if (head.startsWith("super")) {
          throw new UnsupportedOperationException("? super T not implemented");
        } else {
          // not supported
          throw new IllegalArgumentException(
              "only extends/super can follow ?, but found " + s.substring(idx));
        }
      }

      while (idx < s.length()) {
        char ch = s.charAt(idx);
        if (Character.isJavaIdentifierStart(ch) || Character.isJavaIdentifierPart(ch) || ch == '.')
          idx++;
        else break;
      }

      JClass clazz = ref(s.substring(start, idx));

      return parseSuffix(clazz);
    }
  @Override
  public boolean consume(CodeReader code, Lexer lexer) {
    if (!Character.isJavaIdentifierStart(code.peek())) {
      return false;
    }

    int line = code.getCursor().getLine();
    int column = code.getCursor().getColumn();
    while (Character.isJavaIdentifierPart(code.peek())) {
      tmpBuilder.append((char) code.pop());
    }

    String word = tmpBuilder.toString();

    TokenType keywordType = keywordsMap.get(word);
    Token token =
        tokenBuilder
            .setType(keywordType == null ? GenericTokenType.IDENTIFIER : keywordType)
            .setValueAndOriginalValue(word, word)
            .setURI(lexer.getURI())
            .setLine(line)
            .setColumn(column)
            .build();

    lexer.addToken(token);

    tmpBuilder.delete(0, tmpBuilder.length());

    return true;
  }
Ejemplo n.º 18
0
 public static boolean isSingleWord(final String string) {
   for (final char c : string.toCharArray()) {
     if (!Character.isJavaIdentifierStart(c)) {
       return false;
     }
   }
   return true;
 }
Ejemplo n.º 19
0
 private static String extractMemberName(String part) {
   checkArgument(Character.isJavaIdentifierStart(part.charAt(0)), "not an identifier: %s", part);
   for (int i = 1; i <= part.length(); i++) {
     if (!SourceVersion.isIdentifier(part.substring(0, i))) {
       return part.substring(0, i - 1);
     }
   }
   return part;
 }
Ejemplo n.º 20
0
 /** Checks that the given name is a valid identifier. */
 static String checkValidIdentifier(String name) {
   Check.that(
       name.length() > 0
           && Character.isJavaIdentifierStart(name.codePointAt(0))
           && name.codePoints().skip(1).allMatch(Character::isJavaIdentifierPart),
       "'%0' is not a valid identifier",
       name);
   return name;
 }
Ejemplo n.º 21
0
  private static String removeIllegalCharacters(String filename) {
    final char[] chars = filename.toCharArray();
    for (int i = 0; i < chars.length; ++i)
      if (i == 0
          ? !Character.isJavaIdentifierStart(chars[i])
          : !Character.isJavaIdentifierPart(chars[i])) chars[i] = '_';

    return new String(chars);
  }
 // Here are the details of the matching. We track the current brace depth, and we artificially
 // consider that the whole file is at brace depth 1 inside a pseudo-class whose name is the
 // name of the package. When we see a class definition, we push the fully-qualified name of the
 // class on a stack so that we can associate abstract methods we find with the possibly-nested
 // class they belong to. A class definition must occur at brace depth one more than the class
 // containing it, which is equivalent to saying that the brace depth must be the same as the
 // class stack depth. This check excludes local class definitions within methods and
 // initializers. If we meet these constraints and we see the word "class" followed by an
 // identifier Foo, then we consider that we are entering the definition of class Foo. We determine
 // the fully-qualified name of Foo, which is container.Foo, where container is the current top of
 // the class stack (initially, the package name). We push this new fully-qualified name on the
 // class stack. We have not yet seen the left brace with the class definition so at this point the
 // class stack depth is one more than the brace depth. When we subsequently see a right brace that
 // takes us back to this situation then we know we have completed the definition of Foo and we can
 // pop it from the class stack.
 //
 // We check that the token after "class" is indeed an identifier to avoid confusion
 // with Foo.class. Even though the tokenizer does not distinguish between identifiers and
 // keywords, it is enough to exclude the single word "instanceof" because that is the only word
 // that can legally appear after Foo.class (though in a legal program the resultant expression
 // will always be true).
 //
 // Again, we are at the top level of a class when the brace depth is equal to the class stack
 // depth. If we then see the word "abstract" then that is the start either of an abstract class
 // definition or of an abstract method. We record that we have seen "abstract" and we cancel
 // that indication as soon as we see a left brace, to exclude the abstract class case, and also
 // the case of interfaces or @interfaces redundantly declared abstract. Now, when
 // we see an identifier that is preceded by an uncanceled "abstract" and followed by a left paren
 // then we have found an abstract method of the class on the top of the class stack. We record it
 // in the list of abstract methods of the class on the top of the class stack. We don't bother
 // checking that the method has no parameters, because an @AutoCursor class will cause a compiler
 // error if there are abstract methods with parameters, since the @AutoCursor processor doesn't
 // know how to implement them in the concrete subclass it generates.
 ImmutableListMultimap<String, String> abstractMethods(
     JavaTokenizer tokenizer, String packageName) {
   ImmutableListMultimap.Builder<String, String> abstractMethods = ImmutableListMultimap.builder();
   Deque<String> classStack = new ArrayDeque<String>();
   classStack.addLast(packageName);
   int braceDepth = 1;
   boolean sawAbstract = false;
   String className = null;
   for (String previousToken = "", token = tokenizer.nextToken();
       token != null;
       previousToken = token, token = tokenizer.nextToken()) {
     boolean topLevel = (braceDepth == classStack.size());
     if (className != null) {
       if (Character.isJavaIdentifierStart(className.charAt(0))
           && !className.equals("instanceof")) {
         String container = classStack.getLast();
         // container might be empty in the case of a packageless class
         classStack.add(container.isEmpty() ? className : container + "." + className);
       }
       className = null;
     }
     if (token.equals("{")) {
       braceDepth++;
       sawAbstract = false;
     } else if (token.equals("}")) {
       braceDepth--;
       if (topLevel) {
         classStack.removeLast();
       }
     } else if (topLevel) {
       if (token.equals("class") || token.equals("interface")) {
         className = tokenizer.nextToken();
       } else if (token.equals("abstract")) {
         sawAbstract = true;
       } else if (token.equals("(")) {
         if (sawAbstract && Character.isJavaIdentifierStart(previousToken.charAt(0))) {
           abstractMethods.put(classStack.getLast(), previousToken);
         }
         sawAbstract = false;
       }
     }
   }
   return abstractMethods.build();
 }
Ejemplo n.º 23
0
  /**
   * Checks if the given position is start one for HTML tag.
   *
   * @param javadocText text of javadoc comments.
   * @param pos position to check.
   * @return <code>true</code> some HTML tag starts from given position.
   */
  private static boolean isTag(String[] javadocText, Point pos) {
    final int column = pos.getColumnNo() + 1;
    final String text = javadocText[pos.getLineNo()];

    // Character.isJavidentifier... may not be a valid HTML
    // identifier but is valid for generics
    return column < text.length()
            && (Character.isJavaIdentifierStart(text.charAt(column)) || text.charAt(column) == '/')
        || column >= text.length();
  }
Ejemplo n.º 24
0
 private static boolean isFunctionName(String tok) {
   final char begin = tok.charAt(0);
   final boolean isIdentifier = Character.isJavaIdentifierStart(begin) || '"' == begin;
   return isIdentifier
       && !LOGICAL.contains(tok)
       && !END_CLAUSES.contains(tok)
       && !QUANTIFIERS.contains(tok)
       && !DML.contains(tok)
       && !MISC.contains(tok);
 }
Ejemplo n.º 25
0
 /** Returns trus if str represents a valid Java identifier. */
 public static boolean isJavaIdentifier(String str) {
   if (str.length() == 0 || !Character.isJavaIdentifierStart(str.charAt(0))) {
     return false;
   }
   for (int i = 1; i < str.length(); i++) {
     if (!Character.isJavaIdentifierPart(str.charAt(i))) {
       return false;
     }
   }
   return true;
 }
Ejemplo n.º 26
0
  /**
   * Add a single object into the script context.
   *
   * @param key the name in the context this object is to stored under.
   * @param bean the object to be stored in the script context.
   */
  public void addBean(String key, Object bean) {
    boolean isValid = key.length() > 0 && Character.isJavaIdentifierStart(key.charAt(0));

    for (int i = 1; isValid && i < key.length(); i++) {
      isValid = Character.isJavaIdentifierPart(key.charAt(i));
    }

    if (isValid) {
      beans.put(key, bean);
    }
  }
 private boolean identifierComplete(String[] parts, boolean[] dots, int index) {
   /*
    * The identifier is complete if:
    *    - It's the last token or
    *    - The next token does not start as a valid Java identifier or
    *    - A dot is to be insert after identifier.
    */
   return index == parts.length - 1
       || !Character.isJavaIdentifierStart(firstChar(parts[index + 1]))
       || insertDot(parts, dots, index);
 }
 private boolean insertDot(String[] parts, boolean[] dots, int index) {
   /*
    * A dot is to be inserted if:
    *    - It's not the last token and
    *    - Indication to actually try to insert it and
    *    - The next token start as a valid Java identifier.
    */
   return index < parts.length - 1
       && dots[index]
       && Character.isJavaIdentifierStart(firstChar(parts[index + 1]));
 }
Ejemplo n.º 29
0
 public boolean hasToken(int position) {
   if (!Character.isJavaIdentifierStart(myBuffer.charAt(position))) return false;
   final int start = position;
   for (position++; position < myEndOffset; position++) {
     final char c = myBuffer.charAt(position);
     if (!isIdentifierPart(c)) break;
   }
   IElementType tokenType = CustomHighlighterTokenType.IDENTIFIER;
   myTokenInfo.updateData(start, position, tokenType);
   return true;
 }
Ejemplo n.º 30
0
 /**
  * Determines whether a string is a valid Java identifier.
  *
  * <p>A valid Java identifier may not start with a number, but may contain any combination of
  * letters, digits, underscores, or dollar signs.
  *
  * <p>See the <a href="http://java.sun.com/docs/books/jls/third_edition/html/lexical.html#3.8">
  * Java Language Specification</a>
  *
  * @param identifier The identifier to test for validity.
  * @return Whether the identifier was valid.
  */
 public static boolean isValidIdentifier(String identifier) {
   if (identifier.isEmpty() || !Character.isJavaIdentifierStart(identifier.charAt(0))) {
     return false;
   }
   for (int i = 1; i < identifier.length(); i++) {
     if (!Character.isJavaIdentifierPart(identifier.charAt(i))) {
       return false;
     }
   }
   return true;
 }