备案控制台
探索云世界
开发者社区 开发与运维 文章 正文

Java 编译器代码定义的 Token 保留字

2017-06-03 960
版权
版权声明：
本文内容由阿里云实名注册用户自发贡献，版权归原作者所有，阿里云开发者社区不拥有其著作权，亦不承担相应法律责任。具体规则请查看《 阿里云开发者社区用户服务协议》和 《阿里云开发者社区知识产权保护指引》。如果您发现本社区中有涉嫌抄袭的内容，填写 侵权投诉表单进行举报，一经查实，本社区将立刻删除涉嫌侵权内容。
简介： Java 编译器代码定义的 Token 保留字注释类型public static enum CommentStyle { LINE, BLOCK, JAVADOC; ...

Java 编译器代码定义的 Token 保留字

注释类型

public static enum CommentStyle {
            LINE,
            BLOCK,
            JAVADOC;

            private CommentStyle() {
            }
        }

Java语言保留字：

public static enum TokenKind implements Formattable, Filter<Tokens.TokenKind> {
        EOF,
        ERROR,
        IDENTIFIER(Tokens.Token.Tag.NAMED),
        ABSTRACT("abstract"),
        ASSERT("assert", Tokens.Token.Tag.NAMED),
        BOOLEAN("boolean", Tokens.Token.Tag.NAMED),
        BREAK("break"),
        BYTE("byte", Tokens.Token.Tag.NAMED),
        CASE("case"),
        CATCH("catch"),
        CHAR("char", Tokens.Token.Tag.NAMED),
        CLASS("class"),
        CONST("const"),
        CONTINUE("continue"),
        DEFAULT("default"),
        DO("do"),
        DOUBLE("double", Tokens.Token.Tag.NAMED),
        ELSE("else"),
        ENUM("enum", Tokens.Token.Tag.NAMED),
        EXTENDS("extends"),
        FINAL("final"),
        FINALLY("finally"),
        FLOAT("float", Tokens.Token.Tag.NAMED),
        FOR("for"),
        GOTO("goto"),
        IF("if"),
        IMPLEMENTS("implements"),
        IMPORT("import"),
        INSTANCEOF("instanceof"),
        INT("int", Tokens.Token.Tag.NAMED),
        INTERFACE("interface"),
        LONG("long", Tokens.Token.Tag.NAMED),
        NATIVE("native"),
        NEW("new"),
        PACKAGE("package"),
        PRIVATE("private"),
        PROTECTED("protected"),
        PUBLIC("public"),
        RETURN("return"),
        SHORT("short", Tokens.Token.Tag.NAMED),
        STATIC("static"),
        STRICTFP("strictfp"),
        SUPER("super", Tokens.Token.Tag.NAMED),
        SWITCH("switch"),
        SYNCHRONIZED("synchronized"),
        THIS("this", Tokens.Token.Tag.NAMED),
        THROW("throw"),
        THROWS("throws"),
        TRANSIENT("transient"),
        TRY("try"),
        VOID("void", Tokens.Token.Tag.NAMED),
        VOLATILE("volatile"),
        WHILE("while"),
        INTLITERAL(Tokens.Token.Tag.NUMERIC),
        LONGLITERAL(Tokens.Token.Tag.NUMERIC),
        FLOATLITERAL(Tokens.Token.Tag.NUMERIC),
        DOUBLELITERAL(Tokens.Token.Tag.NUMERIC),
        CHARLITERAL(Tokens.Token.Tag.NUMERIC),
        STRINGLITERAL(Tokens.Token.Tag.STRING),
        TRUE("true", Tokens.Token.Tag.NAMED),
        FALSE("false", Tokens.Token.Tag.NAMED),
        NULL("null", Tokens.Token.Tag.NAMED),
        UNDERSCORE("_", Tokens.Token.Tag.NAMED),
        ARROW("->"),
        COLCOL("::"),
        LPAREN("("),
        RPAREN(")"),
        LBRACE("{"),
        RBRACE("}"),
        LBRACKET("["),
        RBRACKET("]"),
        SEMI(";"),
        COMMA(","),
        DOT("."),
        ELLIPSIS("..."),
        EQ("="),
        GT(">"),
        LT("<"),
        BANG("!"),
        TILDE("~"),
        QUES("?"),
        COLON(":"),
        EQEQ("=="),
        LTEQ("<="),
        GTEQ(">="),
        BANGEQ("!="),
        AMPAMP("&&"),
        BARBAR("||"),
        PLUSPLUS("++"),
        SUBSUB("--"),
        PLUS("+"),
        SUB("-"),
        STAR("*"),
        SLASH("/"),
        AMP("&"),
        BAR("|"),
        CARET("^"),
        PERCENT("%"),
        LTLT("<<"),
        GTGT(">>"),
        GTGTGT(">>>"),
        PLUSEQ("+="),
        SUBEQ("-="),
        STAREQ("*="),
        SLASHEQ("/="),
        AMPEQ("&="),
        BAREQ("|="),
        CARETEQ("^="),
        PERCENTEQ("%="),
        LTLTEQ("<<="),
        GTGTEQ(">>="),
        GTGTGTEQ(">>>="),
        MONKEYS_AT("@"),
        CUSTOM;

....

}

源码：

//
// Source code recreated from a .class file by IntelliJ IDEA
// (powered by Fernflower decompiler)
//

package com.sun.tools.javac.parser;

import com.sun.tools.javac.api.Formattable;
import com.sun.tools.javac.api.Messages;
import com.sun.tools.javac.util.Context;
import com.sun.tools.javac.util.Filter;
import com.sun.tools.javac.util.List;
import com.sun.tools.javac.util.ListBuffer;
import com.sun.tools.javac.util.Name;
import com.sun.tools.javac.util.Names;
import com.sun.tools.javac.util.Context.Key;
import java.util.Iterator;
import java.util.Locale;

public class Tokens {
    private final Names names;
    private final Tokens.TokenKind[] key;
    private int maxKey = 0;
    private Name[] tokenName = new Name[Tokens.TokenKind.values().length];
    public static final Key<Tokens> tokensKey = new Key();
    public static final Tokens.Token DUMMY;

    public static Tokens instance(Context var0) {
        Tokens var1 = (Tokens)var0.get(tokensKey);
        if(var1 == null) {
            var1 = new Tokens(var0);
        }

        return var1;
    }

    protected Tokens(Context var1) {
        var1.put(tokensKey, this);
        this.names = Names.instance(var1);
        Tokens.TokenKind[] var2 = Tokens.TokenKind.values();
        int var3 = var2.length;

        int var4;
        Tokens.TokenKind var5;
        for(var4 = 0; var4 < var3; ++var4) {
            var5 = var2[var4];
            if(var5.name != null) {
                this.enterKeyword(var5.name, var5);
            } else {
                this.tokenName[var5.ordinal()] = null;
            }
        }

        this.key = new Tokens.TokenKind[this.maxKey + 1];

        for(int var6 = 0; var6 <= this.maxKey; ++var6) {
            this.key[var6] = Tokens.TokenKind.IDENTIFIER;
        }

        var2 = Tokens.TokenKind.values();
        var3 = var2.length;

        for(var4 = 0; var4 < var3; ++var4) {
            var5 = var2[var4];
            if(var5.name != null) {
                this.key[this.tokenName[var5.ordinal()].getIndex()] = var5;
            }
        }

    }

    private void enterKeyword(String var1, Tokens.TokenKind var2) {
        Name var3 = this.names.fromString(var1);
        this.tokenName[var2.ordinal()] = var3;
        if(var3.getIndex() > this.maxKey) {
            this.maxKey = var3.getIndex();
        }

    }

    Tokens.TokenKind lookupKind(Name var1) {
        return var1.getIndex() > this.maxKey?Tokens.TokenKind.IDENTIFIER:this.key[var1.getIndex()];
    }

    Tokens.TokenKind lookupKind(String var1) {
        return this.lookupKind(this.names.fromString(var1));
    }

    static {
        DUMMY = new Tokens.Token(Tokens.TokenKind.ERROR, 0, 0, (List)null);
    }

    static final class NumericToken extends Tokens.StringToken {
        public final int radix;

        public NumericToken(Tokens.TokenKind var1, int var2, int var3, String var4, int var5, List<Tokens.Comment> var6) {
            super(var1, var2, var3, var4, var6);
            this.radix = var5;
        }

        protected void checkKind() {
            if(this.kind.tag != Tokens.Token.Tag.NUMERIC) {
                throw new AssertionError("Bad token kind - expected " + Tokens.Token.Tag.NUMERIC);
            }
        }

        public int radix() {
            return this.radix;
        }
    }

    static class StringToken extends Tokens.Token {
        public final String stringVal;

        public StringToken(Tokens.TokenKind var1, int var2, int var3, String var4, List<Tokens.Comment> var5) {
            super(var1, var2, var3, var5);
            this.stringVal = var4;
        }

        protected void checkKind() {
            if(this.kind.tag != Tokens.Token.Tag.STRING) {
                throw new AssertionError("Bad token kind - expected " + Tokens.Token.Tag.STRING);
            }
        }

        public String stringVal() {
            return this.stringVal;
        }
    }

    static final class NamedToken extends Tokens.Token {
        public final Name name;

        public NamedToken(Tokens.TokenKind var1, int var2, int var3, Name var4, List<Tokens.Comment> var5) {
            super(var1, var2, var3, var5);
            this.name = var4;
        }

        protected void checkKind() {
            if(this.kind.tag != Tokens.Token.Tag.NAMED) {
                throw new AssertionError("Bad token kind - expected " + Tokens.Token.Tag.NAMED);
            }
        }

        public Name name() {
            return this.name;
        }
    }

    public static class Token {
        public final Tokens.TokenKind kind;
        public final int pos;
        public final int endPos;
        public final List<Tokens.Comment> comments;

        Token(Tokens.TokenKind var1, int var2, int var3, List<Tokens.Comment> var4) {
            this.kind = var1;
            this.pos = var2;
            this.endPos = var3;
            this.comments = var4;
            this.checkKind();
        }

        Tokens.Token[] split(Tokens var1) {
            if(this.kind.name.length() >= 2 && this.kind.tag == Tokens.Token.Tag.DEFAULT) {
                Tokens.TokenKind var2 = var1.lookupKind(this.kind.name.substring(0, 1));
                Tokens.TokenKind var3 = var1.lookupKind(this.kind.name.substring(1));
                if(var2 != null && var3 != null) {
                    return new Tokens.Token[]{new Tokens.Token(var2, this.pos, this.pos + var2.name.length(), this.comments), new Tokens.Token(var3, this.pos + var2.name.length(), this.endPos, (List)null)};
                } else {
                    throw new AssertionError("Cant split - bad subtokens");
                }
            } else {
                throw new AssertionError("Cant split" + this.kind);
            }
        }

        protected void checkKind() {
            if(this.kind.tag != Tokens.Token.Tag.DEFAULT) {
                throw new AssertionError("Bad token kind - expected " + Tokens.Token.Tag.STRING);
            }
        }

        public Name name() {
            throw new UnsupportedOperationException();
        }

        public String stringVal() {
            throw new UnsupportedOperationException();
        }

        public int radix() {
            throw new UnsupportedOperationException();
        }

        public Tokens.Comment comment(Tokens.Comment.CommentStyle var1) {
            List var2 = this.getComments(Tokens.Comment.CommentStyle.JAVADOC);
            return var2.isEmpty()?null:(Tokens.Comment)var2.head;
        }

        public boolean deprecatedFlag() {
            Iterator var1 = this.getComments(Tokens.Comment.CommentStyle.JAVADOC).iterator();

            Tokens.Comment var2;
            do {
                if(!var1.hasNext()) {
                    return false;
                }

                var2 = (Tokens.Comment)var1.next();
            } while(!var2.isDeprecated());

            return true;
        }

        private List<Tokens.Comment> getComments(Tokens.Comment.CommentStyle var1) {
            if(this.comments == null) {
                return List.nil();
            } else {
                ListBuffer var2 = new ListBuffer();
                Iterator var3 = this.comments.iterator();

                while(var3.hasNext()) {
                    Tokens.Comment var4 = (Tokens.Comment)var3.next();
                    if(var4.getStyle() == var1) {
                        var2.add(var4);
                    }
                }

                return var2.toList();
            }
        }

        static enum Tag {
            DEFAULT,
            NAMED,
            STRING,
            NUMERIC;

            private Tag() {
            }
        }
    }

    public interface Comment {
        String getText();

        int getSourcePos(int var1);

        Tokens.Comment.CommentStyle getStyle();

        boolean isDeprecated();

        public static enum CommentStyle {
            LINE,
            BLOCK,
            JAVADOC;

            private CommentStyle() {
            }
        }
    }

    public static enum TokenKind implements Formattable, Filter<Tokens.TokenKind> {
        EOF,
        ERROR,
        IDENTIFIER(Tokens.Token.Tag.NAMED),
        ABSTRACT("abstract"),
        ASSERT("assert", Tokens.Token.Tag.NAMED),
        BOOLEAN("boolean", Tokens.Token.Tag.NAMED),
        BREAK("break"),
        BYTE("byte", Tokens.Token.Tag.NAMED),
        CASE("case"),
        CATCH("catch"),
        CHAR("char", Tokens.Token.Tag.NAMED),
        CLASS("class"),
        CONST("const"),
        CONTINUE("continue"),
        DEFAULT("default"),
        DO("do"),
        DOUBLE("double", Tokens.Token.Tag.NAMED),
        ELSE("else"),
        ENUM("enum", Tokens.Token.Tag.NAMED),
        EXTENDS("extends"),
        FINAL("final"),
        FINALLY("finally"),
        FLOAT("float", Tokens.Token.Tag.NAMED),
        FOR("for"),
        GOTO("goto"),
        IF("if"),
        IMPLEMENTS("implements"),
        IMPORT("import"),
        INSTANCEOF("instanceof"),
        INT("int", Tokens.Token.Tag.NAMED),
        INTERFACE("interface"),
        LONG("long", Tokens.Token.Tag.NAMED),
        NATIVE("native"),
        NEW("new"),
        PACKAGE("package"),
        PRIVATE("private"),
        PROTECTED("protected"),
        PUBLIC("public"),
        RETURN("return"),
        SHORT("short", Tokens.Token.Tag.NAMED),
        STATIC("static"),
        STRICTFP("strictfp"),
        SUPER("super", Tokens.Token.Tag.NAMED),
        SWITCH("switch"),
        SYNCHRONIZED("synchronized"),
        THIS("this", Tokens.Token.Tag.NAMED),
        THROW("throw"),
        THROWS("throws"),
        TRANSIENT("transient"),
        TRY("try"),
        VOID("void", Tokens.Token.Tag.NAMED),
        VOLATILE("volatile"),
        WHILE("while"),
        INTLITERAL(Tokens.Token.Tag.NUMERIC),
        LONGLITERAL(Tokens.Token.Tag.NUMERIC),
        FLOATLITERAL(Tokens.Token.Tag.NUMERIC),
        DOUBLELITERAL(Tokens.Token.Tag.NUMERIC),
        CHARLITERAL(Tokens.Token.Tag.NUMERIC),
        STRINGLITERAL(Tokens.Token.Tag.STRING),
        TRUE("true", Tokens.Token.Tag.NAMED),
        FALSE("false", Tokens.Token.Tag.NAMED),
        NULL("null", Tokens.Token.Tag.NAMED),
        UNDERSCORE("_", Tokens.Token.Tag.NAMED),
        ARROW("->"),
        COLCOL("::"),
        LPAREN("("),
        RPAREN(")"),
        LBRACE("{"),
        RBRACE("}"),
        LBRACKET("["),
        RBRACKET("]"),
        SEMI(";"),
        COMMA(","),
        DOT("."),
        ELLIPSIS("..."),
        EQ("="),
        GT(">"),
        LT("<"),
        BANG("!"),
        TILDE("~"),
        QUES("?"),
        COLON(":"),
        EQEQ("=="),
        LTEQ("<="),
        GTEQ(">="),
        BANGEQ("!="),
        AMPAMP("&&"),
        BARBAR("||"),
        PLUSPLUS("++"),
        SUBSUB("--"),
        PLUS("+"),
        SUB("-"),
        STAR("*"),
        SLASH("/"),
        AMP("&"),
        BAR("|"),
        CARET("^"),
        PERCENT("%"),
        LTLT("<<"),
        GTGT(">>"),
        GTGTGT(">>>"),
        PLUSEQ("+="),
        SUBEQ("-="),
        STAREQ("*="),
        SLASHEQ("/="),
        AMPEQ("&="),
        BAREQ("|="),
        CARETEQ("^="),
        PERCENTEQ("%="),
        LTLTEQ("<<="),
        GTGTEQ(">>="),
        GTGTGTEQ(">>>="),
        MONKEYS_AT("@"),
        CUSTOM;

        public final String name;
        public final Tokens.Token.Tag tag;

        private TokenKind() {
            this((String)null, Tokens.Token.Tag.DEFAULT);
        }

        private TokenKind(String var3) {
            this(var3, Tokens.Token.Tag.DEFAULT);
        }

        private TokenKind(Tokens.Token.Tag var3) {
            this((String)null, var3);
        }

        private TokenKind(String var3, Tokens.Token.Tag var4) {
            this.name = var3;
            this.tag = var4;
        }

        public String toString() {
            switch(null.$SwitchMap$com$sun$tools$javac$parser$Tokens$TokenKind[this.ordinal()]) {
            case 1:
                return "token.identifier";
            case 2:
                return "token.character";
            case 3:
                return "token.string";
            case 4:
                return "token.integer";
            case 5:
                return "token.long-integer";
            case 6:
                return "token.float";
            case 7:
                return "token.double";
            case 8:
                return "token.bad-symbol";
            case 9:
                return "token.end-of-input";
            case 10:
            case 11:
            case 12:
            case 13:
            case 14:
            case 15:
            case 16:
            case 17:
            case 18:
                return "'" + this.name + "'";
            default:
                return this.name;
            }
        }

        public String getKind() {
            return "Token";
        }

        public String toString(Locale var1, Messages var2) {
            return this.name != null?this.toString():var2.getLocalizedString(var1, "compiler.misc." + this.toString(), new Object[0]);
        }

        public boolean accepts(Tokens.TokenKind var1) {
            return this == var1;
        }
    }
}
文章标签：
Java
编译器
关键词：
Java编译器
Java定义
Java代码
Java保留字
Java token
程序员诗人
目录
相关文章
技术君
|
11天前
|
Java 测试技术 应用服务中间件
常见 Java 代码缺陷及规避方式（下）
常见 Java 代码缺陷及规避方式（下）
技术君
34 0
舒一笑
|
13天前
|
Java
Java中ReentrantLock释放锁代码解析
Java中ReentrantLock释放锁代码解析
舒一笑
25 8
Y2000104
|
16天前
|
前端开发 小程序 Java
uniapp上传图片 前端以及java后端代码实现
uniapp上传图片 前端以及java后端代码实现
Y2000104
30 0
喜欢猪猪
|
18天前
|
设计模式 存储 Java
23种设计模式，享元模式的概念优缺点以及JAVA代码举例
【4月更文挑战第6天】享元模式（Flyweight Pattern）是一种结构型设计模式，旨在通过共享技术有效地支持大量细粒度对象的重用。这个模式在处理大量对象时非常有用，特别是当这些对象中的许多实例实际上可以共享相同的状态时，从而可以减少内存占用，提高程序效率
喜欢猪猪
31 4
wljslmz
|
5天前
|
Java
Java接口中可以定义哪些方法？
【4月更文挑战第13天】
wljslmz
7 0
Java接口中可以定义哪些方法？
薛伟同学
|
11天前
|
Java
代码的魔法师：Java反射工厂模式详解
代码的魔法师：Java反射工厂模式详解
薛伟同学
25 0
技术君
|
11天前
|
监控 安全 Java
常见 Java 代码缺陷及规避方式（中）
常见 Java 代码缺陷及规避方式（中）
技术君
23 1
喜欢猪猪
|
14天前
|
设计模式 算法 Java
23种设计模式，模板方法模式的概念优缺点以及JAVA代码举例
【4月更文挑战第10天】模板方法模式是一种行为设计模式，它定义了一个操作中的算法的骨架，而将一些步骤延迟到子类中。模板方法使得子类可以在不改变算法结构的情况下，重新定义算法中的某些特定步骤。
喜欢猪猪
14 0
喜欢猪猪
|
15天前
|
设计模式 Java
23种设计模式，状态模式的概念优缺点以及JAVA代码举例
【4月更文挑战第9天】状态模式是一种行为设计模式，允许一个对象在其内部状态改变时改变它的行为，这个对象看起来似乎修改了它的类。
喜欢猪猪
27 4
当家滴喵啊
|
15天前
|
算法 安全 Java
java代码 实现AES_CMAC 算法测试
该代码实现了一个AES-CMAC算法的简单测试，使用Bouncy Castle作为安全提供者。静态变量K定义了固定密钥。`Aes_Cmac`函数接受密钥和消息，返回AES-CMAC生成的MAC值。在`main`方法中，程序对给定的消息进行AES-CMAC加密，然后模拟接收ECU的加密结果并进行比较。如果两者匹配，输出&quot;验证成功&quot;，否则输出&quot;验证失败&quot;。辅助方法包括将字节转为16进制字符串和将16进制字符串转为字节。
当家滴喵啊
13 0

热门文章

最新文章

  • 1
    Java中的多线程编程：概念、实现与性能优化
  • 2
    java智慧城管源码 AI视频智能分析 可直接上项目
  • 3
    基于 java + Springboot + vue +mysql 大学生实习管理系统（含源码）
  • 4
    使用Java代码打印log日志
  • 5
    Java数据结构与算法-java数据结构与算法（二）
  • 6
    【JVM故障问题排查心得】「Java技术体系方向」Java虚拟机内存优化之虚拟机参数调优原理介绍（一）
  • 7
    深入理解Java并发编程：线程安全与性能优化
  • 8
    Java入门高频考查基础知识4（字节跳动面试题18题2.5万字参考答案）
  • 9
    开发语言详解（python、java、Go(Golong)。。。。）
  • 10
    《理解 WebSocket：Java Web 开发的实时通信技术》
  • 1
    Java作业
    7
  • 2
    Java 中文官方教程 2022 版（四十九）(4)
    20
  • 3
    Java 中文官方教程 2022 版（四十九）(3)
    12
  • 4
    Java 中文官方教程 2022 版（四十九）(2)
    14
  • 5
    Java 中文官方教程 2022 版（四十八）(3)
    7
  • 6
    Java 中文官方教程 2022 版（四十七）(3)
    8
  • 7
    Java基础之对象的引用
    5
  • 8
    Java 中文官方教程 2022 版（四十六）(2)
    12
  • 9
    Java 中文官方教程 2022 版（四十五）(4)
    11
  • 10
    Java 中文官方教程 2022 版（四十四）(4)
    6

    • 相关课程

    更多
  • Java面试疑难点解析 - 面试技巧及语言基础
  • Java编程入门
  • Java面向对象编程
  • Java高级编程

    • 相关电子书

    更多
  • Spring Cloud Alibaba - 重新定义 Java Cloud-Native
  • The Reactive Cloud Native Arch
  • JAVA开发手册1.5.0

    • 相关实验场景

    更多
  • 基于ECS搭建Java Web开发环境
  • 使用Aliyun Java Intializr进行项目开发
  • 搭建Java Web开发环境
  • 部署基于Dragonwell的Java运行环境
  • 阿里云平台上进行Java程序的编译与运行
    • 下一篇
    部署LAMP环境（Alibaba Cloud Linux 3）