com.sun.tools.javac.parser.Tokens.TokenKind Java Examples

/**
 * The {@code Tok} constructor.
 *
 * @param index its index
 * @param originalText its original text, before removing Unicode escapes
 * @param text its text after removing Unicode escapes
 * @param position its {@code 0}-origin position in the input
 * @param columnI its {@code 0}-origin column number in the input
 * @param isToken whether the {@code Tok} is a token
 * @param kind the token kind
 */
Tok(
    int index,
    String originalText,
    String text,
    int position,
    int columnI,
    boolean isToken,
    TokenKind kind) {
  this.index = index;
  this.originalText = originalText;
  this.text = text;
  this.position = position;
  this.columnI = columnI;
  this.isToken = isToken;
  this.kind = kind;
}
 

List<JCTree> parseParams(String s) throws ParseException {
    if (s.trim().isEmpty())
        return List.nil();

    JavacParser p = fac.newParser(s.replace("...", "[]"), false, false, false);
    ListBuffer<JCTree> paramTypes = new ListBuffer<>();
    paramTypes.add(p.parseType());

    if (p.token().kind == TokenKind.IDENTIFIER)
        p.nextToken();

    while (p.token().kind == TokenKind.COMMA) {
        p.nextToken();
        paramTypes.add(p.parseType());

        if (p.token().kind == TokenKind.IDENTIFIER)
            p.nextToken();
    }

    if (p.token().kind != TokenKind.EOF)
        throw new ParseException("dc.ref.unexpected.input");

    return paramTypes.toList();
}
 

private List<JCTree> parseParams(String s) throws ParseException {
    if (s.trim().isEmpty())
        return List.nil();

    JavacParser p = fac.newParser(s.replace("...", "[]"), false, false, false);
    ListBuffer<JCTree> paramTypes = new ListBuffer<>();
    paramTypes.add(p.parseType());

    if (p.token().kind == TokenKind.IDENTIFIER)
        p.nextToken();

    while (p.token().kind == TokenKind.COMMA) {
        p.nextToken();
        paramTypes.add(p.parseType());

        if (p.token().kind == TokenKind.IDENTIFIER)
            p.nextToken();
    }

    if (p.token().kind != TokenKind.EOF)
        throw new ParseException("dc.ref.unexpected.input");

    return paramTypes.toList();
}
 

void run() throws Exception {
    Context ctx = new Context();
    Log log = Log.instance(ctx);
    String input = "0bL 0b20L 0xL ";
    log.useSource(new SimpleJavaFileObject(new URI("mem://Test.java"), JavaFileObject.Kind.SOURCE) {
        @Override
        public CharSequence getCharContent(boolean ignoreEncodingErrors) throws IOException {
            return input;
        }
    });
    char[] inputArr = input.toCharArray();
    JavaTokenizer tokenizer = new JavaTokenizer(ScannerFactory.instance(ctx), inputArr, inputArr.length) {
    };

    assertKind(input, tokenizer, TokenKind.LONGLITERAL, "0bL");
    assertKind(input, tokenizer, TokenKind.LONGLITERAL, "0b20L");
    assertKind(input, tokenizer, TokenKind.LONGLITERAL, "0xL");
}
 

List<JCTree> parseParams(String s) throws ParseException {
    if (s.trim().isEmpty())
        return List.nil();

    JavacParser p = fac.newParser(s.replace("...", "[]"), false, false, false);
    ListBuffer<JCTree> paramTypes = new ListBuffer<JCTree>();
    paramTypes.add(p.parseType());

    if (p.token().kind == TokenKind.IDENTIFIER)
        p.nextToken();

    while (p.token().kind == TokenKind.COMMA) {
        p.nextToken();
        paramTypes.add(p.parseType());

        if (p.token().kind == TokenKind.IDENTIFIER)
            p.nextToken();
    }

    if (p.token().kind != TokenKind.EOF)
        throw new ParseException("dc.ref.unexpected.input");

    return paramTypes.toList();
}
 

List<JCTree> parseParams(String s) throws ParseException {
    if (s.trim().isEmpty())
        return List.nil();

    JavacParser p = fac.newParser(s.replace("...", "[]"), false, false, false);
    ListBuffer<JCTree> paramTypes = new ListBuffer<>();
    paramTypes.add(p.parseType());

    if (p.token().kind == TokenKind.IDENTIFIER)
        p.nextToken();

    while (p.token().kind == TokenKind.COMMA) {
        p.nextToken();
        paramTypes.add(p.parseType());

        if (p.token().kind == TokenKind.IDENTIFIER)
            p.nextToken();
    }

    if (p.token().kind != TokenKind.EOF)
        throw new ParseException("dc.ref.unexpected.input");

    return paramTypes.toList();
}
 

List<JCTree> parseParams(String s) throws ParseException {
    if (s.trim().isEmpty())
        return List.nil();

    JavacParser p = fac.newParser(s.replace("...", "[]"), false, false, false);
    ListBuffer<JCTree> paramTypes = new ListBuffer<JCTree>();
    paramTypes.add(p.parseType());

    if (p.token().kind == TokenKind.IDENTIFIER)
        p.nextToken();

    while (p.token().kind == TokenKind.COMMA) {
        p.nextToken();
        paramTypes.add(p.parseType());

        if (p.token().kind == TokenKind.IDENTIFIER)
            p.nextToken();
    }

    if (p.token().kind != TokenKind.EOF)
        throw new ParseException("dc.ref.unexpected.input");

    return paramTypes.toList();
}
 

private List<JCTree> parseParams(String s) throws ParseException {
    if (s.trim().isEmpty())
        return List.nil();

    JavacParser p = fac.newParser(s.replace("...", "[]"), false, false, false);
    ListBuffer<JCTree> paramTypes = new ListBuffer<>();
    paramTypes.add(p.parseType());

    if (p.token().kind == TokenKind.IDENTIFIER)
        p.nextToken();

    while (p.token().kind == TokenKind.COMMA) {
        p.nextToken();
        paramTypes.add(p.parseType());

        if (p.token().kind == TokenKind.IDENTIFIER)
            p.nextToken();
    }

    if (p.token().kind != TokenKind.EOF)
        throw new ParseException("dc.ref.unexpected.input");

    return paramTypes.toList();
}
 

List<JCTree> parseParams(String s) throws ParseException {
    if (s.trim().isEmpty())
        return List.nil();

    JavacParser p = fac.newParser(s.replace("...", "[]"), false, false, false);
    ListBuffer<JCTree> paramTypes = new ListBuffer<JCTree>();
    paramTypes.add(p.parseType());

    if (p.token().kind == TokenKind.IDENTIFIER)
        p.nextToken();

    while (p.token().kind == TokenKind.COMMA) {
        p.nextToken();
        paramTypes.add(p.parseType());

        if (p.token().kind == TokenKind.IDENTIFIER)
            p.nextToken();
    }

    if (p.token().kind != TokenKind.EOF)
        throw new ParseException("dc.ref.unexpected.input");

    return paramTypes.toList();
}
 

List<JCTree> parseParams(String s) throws ParseException {
    if (s.trim().isEmpty())
        return List.nil();

    JavacParser p = fac.newParser(s.replace("...", "[]"), false, false, false);
    ListBuffer<JCTree> paramTypes = new ListBuffer<JCTree>();
    paramTypes.add(p.parseType());

    if (p.token().kind == TokenKind.IDENTIFIER)
        p.nextToken();

    while (p.token().kind == TokenKind.COMMA) {
        p.nextToken();
        paramTypes.add(p.parseType());

        if (p.token().kind == TokenKind.IDENTIFIER)
            p.nextToken();
    }

    if (p.token().kind != TokenKind.EOF)
        throw new ParseException("dc.ref.unexpected.input");

    return paramTypes.toList();
}
 

List<JCTree> parseParams(String s) throws ParseException {
    if (s.trim().isEmpty())
        return List.nil();

    JavacParser p = fac.newParser(s.replace("...", "[]"), false, false, false);
    ListBuffer<JCTree> paramTypes = new ListBuffer<JCTree>();
    paramTypes.add(p.parseType());

    if (p.token().kind == TokenKind.IDENTIFIER)
        p.nextToken();

    while (p.token().kind == TokenKind.COMMA) {
        p.nextToken();
        paramTypes.add(p.parseType());

        if (p.token().kind == TokenKind.IDENTIFIER)
            p.nextToken();
    }

    if (p.token().kind != TokenKind.EOF)
        throw new ParseException("dc.ref.unexpected.input");

    return paramTypes.toList();
}
 

List<JCTree> parseParams(String s) throws ParseException {
    if (s.trim().isEmpty())
        return List.nil();

    JavacParser p = fac.newParser(s.replace("...", "[]"), false, false, false);
    ListBuffer<JCTree> paramTypes = new ListBuffer<JCTree>();
    paramTypes.add(p.parseType());

    if (p.token().kind == TokenKind.IDENTIFIER)
        p.nextToken();

    while (p.token().kind == TokenKind.COMMA) {
        p.nextToken();
        paramTypes.add(p.parseType());

        if (p.token().kind == TokenKind.IDENTIFIER)
            p.nextToken();
    }

    if (p.token().kind != TokenKind.EOF)
        throw new ParseException("dc.ref.unexpected.input");

    return paramTypes.toList();
}
 

List<JCTree> parseParams(String s) throws ParseException {
    if (s.trim().isEmpty())
        return List.nil();

    JavacParser p = fac.newParser(s.replace("...", "[]"), false, false, false);
    ListBuffer<JCTree> paramTypes = new ListBuffer<JCTree>();
    paramTypes.add(p.parseType());

    if (p.token().kind == TokenKind.IDENTIFIER)
        p.nextToken();

    while (p.token().kind == TokenKind.COMMA) {
        p.nextToken();
        paramTypes.add(p.parseType());

        if (p.token().kind == TokenKind.IDENTIFIER)
            p.nextToken();
    }

    if (p.token().kind != TokenKind.EOF)
        throw new ParseException("dc.ref.unexpected.input");

    return paramTypes.toList();
}
 

Name parseMember(String s) throws ParseException {
    JavacParser p = fac.newParser(s, false, false, false);
    Name name = p.ident();
    if (p.token().kind != TokenKind.EOF)
        throw new ParseException("dc.ref.unexpected.input");
    return name;
}
 

JCTree parseType(String s) throws ParseException {
    JavacParser p = fac.newParser(s, false, false, false);
    JCTree tree = p.parseType();
    if (p.token().kind != TokenKind.EOF)
        throw new ParseException("dc.ref.unexpected.input");
    return tree;
}
 

JCTree parseType(String s) throws ParseException {
    JavacParser p = fac.newParser(s, false, false, false);
    JCTree tree = p.parseType();
    if (p.token().kind != TokenKind.EOF)
        throw new ParseException("dc.ref.unexpected.input");
    return tree;
}
 

Name parseMember(String s) throws ParseException {
    JavacParser p = fac.newParser(s, false, false, false);
    Name name = p.ident();
    if (p.token().kind != TokenKind.EOF)
        throw new ParseException("dc.ref.unexpected.input");
    return name;
}
 

Name parseMember(String s) throws ParseException {
    JavacParser p = fac.newParser(s, false, false, false);
    Name name = p.ident();
    if (p.token().kind != TokenKind.EOF)
        throw new ParseException("dc.ref.unexpected.input");
    return name;
}
 

JCTree parseType(String s) throws ParseException {
    JavacParser p = fac.newParser(s, false, false, false);
    JCTree tree = p.parseType();
    if (p.token().kind != TokenKind.EOF)
        throw new ParseException("dc.ref.unexpected.input");
    return tree;
}
 

void assertKind(String input, JavaTokenizer tokenizer, TokenKind kind, String expectedText) {
    Token token = tokenizer.readToken();

    if (token.kind != kind) {
        throw new AssertionError("Unexpected token kind: " + token.kind);
    }

    String actualText = input.substring(token.pos, token.endPos);

    if (!Objects.equals(actualText, expectedText)) {
        throw new AssertionError("Unexpected token text: " + actualText);
    }
}
 

/**
 * Returns the {@link javax.lang.model.element.Modifier} for the given token kind, or {@code
 * null}.
 */
private static Modifier getModifier(TokenKind kind) {
  if (kind == null) {
    return null;
  }
  switch (kind) {
    case PUBLIC:
      return Modifier.PUBLIC;
    case PROTECTED:
      return Modifier.PROTECTED;
    case PRIVATE:
      return Modifier.PRIVATE;
    case ABSTRACT:
      return Modifier.ABSTRACT;
    case STATIC:
      return Modifier.STATIC;
    case DEFAULT:
      return Modifier.DEFAULT;
    case FINAL:
      return Modifier.FINAL;
    case TRANSIENT:
      return Modifier.TRANSIENT;
    case VOLATILE:
      return Modifier.VOLATILE;
    case SYNCHRONIZED:
      return Modifier.SYNCHRONIZED;
    case NATIVE:
      return Modifier.NATIVE;
    case STRICTFP:
      return Modifier.STRICTFP;
    default:
      return null;
  }
}
 

private CT match(TK tk, TokenKind open) {
    Token tok = advance();
    db("match desired-tk=%s, open=%s, seen-tok=%s", tk, open, tok.kind);
    if (stack.isEmpty()) {
        return new CT(ERROR, tok, "Encountered '" + tok + "' with no opening '" + open + "'");
    }
    Token p = stack.pop();
    if (p.kind != open) {
        return new CT(ERROR, tok, "No match for '" + p + "' instead encountered '" + tok + "'");
    }
    return new CT(tk, tok);
}
 

private static TK tokenKindToTK(TK prev, TokenKind kind) {
    TK tk = tokenKindToTKMap.get(kind);
    if (tk == null) {
        System.err.printf("No corresponding %s for %s: %s\n",
                TK.class.getCanonicalName(),
                TokenKind.class.getCanonicalName(),
                kind);
        throw new InternalError("No corresponding TK for TokenKind: " + kind);
    }
    return tk.mapping != null
            ? tk.mapping.apply(prev)
            : tk;
}
 

Name parseMember(String s) throws ParseException {
    JavacParser p = fac.newParser(s, false, false, false);
    Name name = p.ident();
    if (p.token().kind != TokenKind.EOF)
        throw new ParseException("dc.ref.unexpected.input");
    return name;
}
 

Name parseMember(String s) throws ParseException {
    JavacParser p = fac.newParser(s, false, false, false);
    Name name = p.ident();
    if (p.token().kind != TokenKind.EOF)
        throw new ParseException("dc.ref.unexpected.input");
    return name;
}
 

JCTree parseType(String s) throws ParseException {
    JavacParser p = fac.newParser(s, false, false, false);
    JCTree tree = p.parseType();
    if (p.token().kind != TokenKind.EOF)
        throw new ParseException("dc.ref.unexpected.input");
    return tree;
}
 

Name parseMember(String s) throws ParseException {
    JavacParser p = fac.newParser(s, false, false, false);
    Name name = p.ident();
    if (p.token().kind != TokenKind.EOF)
        throw new ParseException("dc.ref.unexpected.input");
    return name;
}
 

JCTree parseType(String s) throws ParseException {
    JavacParser p = fac.newParser(s, false, false, false);
    JCTree tree = p.parseType();
    if (p.token().kind != TokenKind.EOF)
        throw new ParseException("dc.ref.unexpected.input");
    return tree;
}
 

Name parseMember(String s) throws ParseException {
    JavacParser p = fac.newParser(s, false, false, false);
    Name name = p.ident();
    if (p.token().kind != TokenKind.EOF)
        throw new ParseException("dc.ref.unexpected.input");
    return name;
}
 

private JCTree parseType(String s) throws ParseException {
    JavacParser p = fac.newParser(s, false, false, false);
    JCTree tree = p.parseType();
    if (p.token().kind != TokenKind.EOF)
        throw new ParseException("dc.ref.unexpected.input");
    return tree;
}