|
29 | 29 | THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. |
30 | 30 | */ |
31 | 31 |
|
| 32 | +// $antlr-format alignTrailingComments true, columnLimit 150, maxEmptyLinesToKeep 1, reflowComments false, useTab false |
| 33 | +// $antlr-format allowShortRulesOnASingleLine true, allowShortBlocksOnASingleLine true, minEmptyLines 0, alignSemicolons ownLine |
| 34 | +// $antlr-format alignColons trailing, singleLineOverrulesHangingColon true, alignLexerCommands true, alignLabels true, alignTrailers true |
| 35 | + |
32 | 36 | lexer grammar JavaLexer; |
33 | 37 |
|
34 | 38 | // Keywords |
35 | 39 |
|
36 | | -ABSTRACT:'abstract'; |
37 | | -ASSERT:'assert'; |
38 | | -BOOLEAN:'boolean'; |
39 | | -BREAK:'break'; |
40 | | -BYTE:'byte'; |
41 | | -CASE:'case'; |
42 | | -CATCH:'catch'; |
43 | | -CHAR:'char'; |
44 | | -CLASS:'class'; |
45 | | -CONST:'const'; |
46 | | -CONTINUE:'continue'; |
47 | | -DEFAULT:'default'; |
48 | | -DO:'do'; |
49 | | -DOUBLE:'double'; |
50 | | -ELSE:'else'; |
51 | | -ENUM:'enum'; |
52 | | -EXTENDS:'extends'; |
53 | | -FINAL:'final'; |
54 | | -FINALLY:'finally'; |
55 | | -FLOAT:'float'; |
56 | | -FOR:'for'; |
57 | | -IF:'if'; |
58 | | -GOTO:'goto'; |
59 | | -IMPLEMENTS:'implements'; |
60 | | -IMPORT:'import'; |
61 | | -INSTANCEOF:'instanceof'; |
62 | | -INT:'int'; |
63 | | -INTERFACE:'interface'; |
64 | | -LONG:'long'; |
65 | | -NATIVE:'native'; |
66 | | -NEW:'new'; |
67 | | -PACKAGE:'package'; |
68 | | -PRIVATE:'private'; |
69 | | -PROTECTED:'protected'; |
70 | | -PUBLIC:'public'; |
71 | | -RETURN:'return'; |
72 | | -SHORT:'short'; |
73 | | -STATIC:'static'; |
74 | | -STRICTFP:'strictfp'; |
75 | | -SUPER:'super'; |
76 | | -SWITCH:'switch'; |
77 | | -SYNCHRONIZED:'synchronized'; |
78 | | -THIS:'this'; |
79 | | -THROW:'throw'; |
80 | | -THROWS:'throws'; |
81 | | -TRANSIENT:'transient'; |
82 | | -TRY:'try'; |
83 | | -VOID:'void'; |
84 | | -VOLATILE:'volatile'; |
85 | | -WHILE:'while'; |
| 40 | +ABSTRACT:'abstract'; |
| 41 | +ASSERT:'assert'; |
| 42 | +BOOLEAN:'boolean'; |
| 43 | +BREAK:'break'; |
| 44 | +BYTE:'byte'; |
| 45 | +CASE:'case'; |
| 46 | +CATCH:'catch'; |
| 47 | +CHAR:'char'; |
| 48 | +CLASS:'class'; |
| 49 | +CONST:'const'; |
| 50 | +CONTINUE:'continue'; |
| 51 | +DEFAULT:'default'; |
| 52 | +DO:'do'; |
| 53 | +DOUBLE:'double'; |
| 54 | +ELSE:'else'; |
| 55 | +ENUM:'enum'; |
| 56 | +EXTENDS:'extends'; |
| 57 | +FINAL:'final'; |
| 58 | +FINALLY:'finally'; |
| 59 | +FLOAT:'float'; |
| 60 | +FOR:'for'; |
| 61 | +IF:'if'; |
| 62 | +GOTO:'goto'; |
| 63 | +IMPLEMENTS:'implements'; |
| 64 | +IMPORT:'import'; |
| 65 | +INSTANCEOF:'instanceof'; |
| 66 | +INT:'int'; |
| 67 | +INTERFACE:'interface'; |
| 68 | +LONG:'long'; |
| 69 | +NATIVE:'native'; |
| 70 | +NEW:'new'; |
| 71 | +PACKAGE:'package'; |
| 72 | +PRIVATE:'private'; |
| 73 | +PROTECTED:'protected'; |
| 74 | +PUBLIC:'public'; |
| 75 | +RETURN:'return'; |
| 76 | +SHORT:'short'; |
| 77 | +STATIC:'static'; |
| 78 | +STRICTFP:'strictfp'; |
| 79 | +SUPER:'super'; |
| 80 | +SWITCH:'switch'; |
| 81 | +SYNCHRONIZED :'synchronized'; |
| 82 | +THIS:'this'; |
| 83 | +THROW:'throw'; |
| 84 | +THROWS:'throws'; |
| 85 | +TRANSIENT:'transient'; |
| 86 | +TRY:'try'; |
| 87 | +VOID:'void'; |
| 88 | +VOLATILE:'volatile'; |
| 89 | +WHILE:'while'; |
86 | 90 |
|
87 | 91 | // Module related keywords |
88 | | -MODULE:'module'; |
89 | | -OPEN:'open'; |
90 | | -REQUIRES:'requires'; |
91 | | -EXPORTS:'exports'; |
92 | | -OPENS:'opens'; |
93 | | -TO:'to'; |
94 | | -USES:'uses'; |
95 | | -PROVIDES:'provides'; |
96 | | -WITH:'with'; |
97 | | -TRANSITIVE:'transitive'; |
| 92 | +MODULE:'module'; |
| 93 | +OPEN:'open'; |
| 94 | +REQUIRES:'requires'; |
| 95 | +EXPORTS:'exports'; |
| 96 | +OPENS:'opens'; |
| 97 | +TO:'to'; |
| 98 | +USES:'uses'; |
| 99 | +PROVIDES:'provides'; |
| 100 | +WITH:'with'; |
| 101 | +TRANSITIVE :'transitive'; |
98 | 102 |
|
99 | 103 | // Local Variable Type Inference |
100 | | -VAR:'var';// reserved type name |
| 104 | +VAR:'var';// reserved type name |
101 | 105 |
|
102 | 106 | // Switch Expressions |
103 | | -YIELD:'yield'; |
| 107 | +YIELD:'yield';// reserved type name from Java 14 |
104 | 108 |
|
105 | 109 | // Records |
106 | | -RECORD:'record'; |
| 110 | +RECORD:'record'; |
107 | 111 |
|
108 | 112 | // Sealed Classes |
109 | | -SEALED:'sealed'; |
110 | | -PERMITS:'permits'; |
111 | | -NON_SEALED:'non-sealed'; |
| 113 | +SEALED:'sealed'; |
| 114 | +PERMITS:'permits'; |
| 115 | +NON_SEALED :'non-sealed'; |
112 | 116 |
|
113 | 117 | // Literals |
114 | 118 |
|
115 | | -DECIMAL_LITERAL: ('0' | [1-9] (Digits? |'_'+ Digits)) [lL]?; |
116 | | -HEX_LITERAL:'0' [xX] [0-9a-fA-F] ([0-9a-fA-F_]* [0-9a-fA-F])? [lL]?; |
117 | | -OCT_LITERAL:'0''_'* [0-7] ([0-7_]* [0-7])? [lL]?; |
118 | | -BINARY_LITERAL:'0' [bB] [01] ([01_]* [01])? [lL]?; |
| 119 | +DECIMAL_LITERAL : ('0' | [1-9] (Digits? |'_'+ Digits)) [lL]?; |
| 120 | +HEX_LITERAL:'0' [xX] [0-9a-fA-F] ([0-9a-fA-F_]* [0-9a-fA-F])? [lL]?; |
| 121 | +OCT_LITERAL:'0''_'* [0-7] ([0-7_]* [0-7])? [lL]?; |
| 122 | +BINARY_LITERAL :'0' [bB] [01] ([01_]* [01])? [lL]?; |
119 | 123 |
|
120 | | -FLOAT_LITERAL: (Digits'.' Digits? |'.' Digits) ExponentPart? [fFdD]? |
121 | | - | Digits (ExponentPart [fFdD]? | [fFdD]) |
122 | | - ; |
| 124 | +FLOAT_LITERAL: |
| 125 | + (Digits'.' Digits? |'.' Digits) ExponentPart? [fFdD]? |
| 126 | + | Digits (ExponentPart [fFdD]? | [fFdD]) |
| 127 | +; |
123 | 128 |
|
124 | | -HEX_FLOAT_LITERAL:'0' [xX] (HexDigits'.'? | HexDigits?'.' HexDigits) [pP] [+-]? Digits [fFdD]?; |
| 129 | +HEX_FLOAT_LITERAL:'0' [xX] (HexDigits'.'? | HexDigits?'.' HexDigits) [pP] [+-]? Digits [fFdD]?; |
125 | 130 |
|
126 | | -BOOL_LITERAL:'true' |
127 | | - |'false' |
128 | | - ; |
| 131 | +BOOL_LITERAL:'true' |'false'; |
129 | 132 |
|
130 | | -CHAR_LITERAL:'\'' (~['\\\r\n] | EscapeSequence)'\''; |
| 133 | +CHAR_LITERAL:'\'' (~['\\\r\n] | EscapeSequence)'\''; |
131 | 134 |
|
132 | | -STRING_LITERAL:'"' (~["\\\r\n] | EscapeSequence)* '"'; |
| 135 | +STRING_LITERAL:'"' (~["\\\r\n] | EscapeSequence)* '"'; |
133 | 136 |
|
134 | | -TEXT_BLOCK:'"""' [\t]* [\r\n] (. | EscapeSequence)*? '"""'; |
| 137 | +TEXT_BLOCK:'"""' [\t]* [\r\n] (. | EscapeSequence)*? '"""'; |
135 | 138 |
|
136 | | -NULL_LITERAL:'null'; |
| 139 | +NULL_LITERAL:'null'; |
137 | 140 |
|
138 | 141 | // Separators |
139 | 142 |
|
140 | | -LPAREN:'('; |
141 | | -RPAREN:')'; |
142 | | -LBRACE:'{'; |
143 | | -RBRACE:'}'; |
144 | | -LBRACK:'['; |
145 | | -RBRACK:']'; |
146 | | -SEMI:';'; |
147 | | -COMMA:','; |
148 | | -DOT:'.'; |
| 143 | +LPAREN :'('; |
| 144 | +RPAREN :')'; |
| 145 | +LBRACE :'{'; |
| 146 | +RBRACE :'}'; |
| 147 | +LBRACK :'['; |
| 148 | +RBRACK :']'; |
| 149 | +SEMI:';'; |
| 150 | +COMMA :','; |
| 151 | +DOT:'.'; |
149 | 152 |
|
150 | 153 | // Operators |
151 | 154 |
|
152 | | -ASSIGN:'='; |
153 | | -GT:'>'; |
154 | | -LT:'<'; |
155 | | -BANG:'!'; |
156 | | -TILDE:'~'; |
157 | | -QUESTION:'?'; |
158 | | -COLON:':'; |
159 | | -EQUAL:'=='; |
160 | | -LE:'<='; |
161 | | -GE:'>='; |
162 | | -NOTEQUAL:'!='; |
163 | | -AND:'&&'; |
164 | | -OR:'||'; |
165 | | -INC:'++'; |
166 | | -DEC:'--'; |
167 | | -ADD:'+'; |
168 | | -SUB:'-'; |
169 | | -MUL:'*'; |
170 | | -DIV:'/'; |
171 | | -BITAND:'&'; |
172 | | -BITOR:'|'; |
173 | | -CARET:'^'; |
174 | | -MOD:'%'; |
175 | | -
|
176 | | -ADD_ASSIGN:'+='; |
177 | | -SUB_ASSIGN:'-='; |
178 | | -MUL_ASSIGN:'*='; |
179 | | -DIV_ASSIGN:'/='; |
180 | | -AND_ASSIGN:'&='; |
181 | | -OR_ASSIGN:'|='; |
182 | | -XOR_ASSIGN:'^='; |
183 | | -MOD_ASSIGN:'%='; |
184 | | -LSHIFT_ASSIGN:'<<='; |
185 | | -RSHIFT_ASSIGN:'>>='; |
186 | | -URSHIFT_ASSIGN:'>>>='; |
| 155 | +ASSIGN:'='; |
| 156 | +GT:'>'; |
| 157 | +LT:'<'; |
| 158 | +BANG:'!'; |
| 159 | +TILDE:'~'; |
| 160 | +QUESTION :'?'; |
| 161 | +COLON:':'; |
| 162 | +EQUAL:'=='; |
| 163 | +LE:'<='; |
| 164 | +GE:'>='; |
| 165 | +NOTEQUAL :'!='; |
| 166 | +AND:'&&'; |
| 167 | +OR:'||'; |
| 168 | +INC:'++'; |
| 169 | +DEC:'--'; |
| 170 | +ADD:'+'; |
| 171 | +SUB:'-'; |
| 172 | +MUL:'*'; |
| 173 | +DIV:'/'; |
| 174 | +BITAND:'&'; |
| 175 | +BITOR:'|'; |
| 176 | +CARET:'^'; |
| 177 | +MOD:'%'; |
| 178 | +
|
| 179 | +ADD_ASSIGN:'+='; |
| 180 | +SUB_ASSIGN:'-='; |
| 181 | +MUL_ASSIGN:'*='; |
| 182 | +DIV_ASSIGN:'/='; |
| 183 | +AND_ASSIGN:'&='; |
| 184 | +OR_ASSIGN:'|='; |
| 185 | +XOR_ASSIGN:'^='; |
| 186 | +MOD_ASSIGN:'%='; |
| 187 | +LSHIFT_ASSIGN :'<<='; |
| 188 | +RSHIFT_ASSIGN :'>>='; |
| 189 | +URSHIFT_ASSIGN :'>>>='; |
187 | 190 |
|
188 | 191 | // Java 8 tokens |
189 | 192 |
|
190 | | -ARROW:'->'; |
191 | | -COLONCOLON:'::'; |
| 193 | +ARROW:'->'; |
| 194 | +COLONCOLON :'::'; |
192 | 195 |
|
193 | 196 | // Additional symbols not defined in the lexical specification |
194 | 197 |
|
195 | | -AT:'@'; |
196 | | -ELLIPSIS:'...'; |
| 198 | +AT:'@'; |
| 199 | +ELLIPSIS :'...'; |
197 | 200 |
|
198 | 201 | // Whitespace and comments |
199 | 202 |
|
200 | | -WS: [\t\r\n\u000C]+ -> channel(HIDDEN); |
201 | | -COMMENT:'/*' .*? '*/' -> channel(HIDDEN); |
202 | | -LINE_COMMENT:'//' ~[\r\n]* -> channel(HIDDEN); |
| 203 | +WS: [\t\r\n\u000C]+ -> channel(HIDDEN); |
| 204 | +COMMENT:'/*' .*? '*/' -> channel(HIDDEN); |
| 205 | +LINE_COMMENT :'//' ~[\r\n]* -> channel(HIDDEN); |
203 | 206 |
|
204 | 207 | // Identifiers |
205 | 208 |
|
206 | | -IDENTIFIER:Letter LetterOrDigit*; |
| 209 | +IDENTIFIER: Letter LetterOrDigit*; |
207 | 210 |
|
208 | 211 | // Fragment rules |
209 | 212 |
|
210 | | -fragment ExponentPart |
211 | | - : [eE] [+-]? Digits |
212 | | - ; |
| 213 | +fragment ExponentPart: [eE] [+-]? Digits; |
213 | 214 |
|
214 | | -fragment EscapeSequence |
215 | | -:'\\' [btnfr"'\\] |
216 | | - | '\\' ([0-3]? [0-7])? [0-7] |
| 215 | +fragment EscapeSequence: |
| 216 | +'\\''u005c'? [btnfr"'\\] |
| 217 | + | '\\''u005c'?([0-3]? [0-7])? [0-7] |
217 | 218 | | '\\' 'u'+ HexDigit HexDigit HexDigit HexDigit |
218 | | -; |
| 219 | +; |
219 | 220 |
|
220 | | -fragment HexDigits |
221 | | - : HexDigit ((HexDigit | '_')* HexDigit)? |
222 | | - ; |
| 221 | +fragment HexDigits: HexDigit ((HexDigit | '_')* HexDigit)?; |
223 | 222 |
|
224 | | -fragment HexDigit |
225 | | - : [0-9a-fA-F] |
226 | | - ; |
| 223 | +fragment HexDigit: [0-9a-fA-F]; |
227 | 224 |
|
228 | | -fragment Digits |
229 | | - : [0-9] ([0-9_]* [0-9])? |
230 | | - ; |
| 225 | +fragment Digits: [0-9] ([0-9_]* [0-9])?; |
231 | 226 |
|
232 | | -fragment LetterOrDigit |
233 | | - : Letter |
234 | | - | [0-9] |
235 | | - ; |
| 227 | +fragment LetterOrDigit: Letter | [0-9]; |
236 | 228 |
|
237 | | -fragment Letter |
238 | | -:[a-zA-Z$_] // these are the"java letters" below 0x7F |
239 | | - | ~[\u0000-\u007F\uD800-\uDBFF] // covers all characters above 0x7F which are not a surrogate |
| 229 | +fragment Letter: |
| 230 | + [a-zA-Z$_] // these are the"java letters" below 0x7F |
| 231 | + | ~[\u0000-\u007F\uD800-\uDBFF]// covers all characters above 0x7F which are not a surrogate |
240 | 232 | | [\uD800-\uDBFF] [\uDC00-\uDFFF] // covers UTF-16 surrogate pairs encodings for U+10000 to U+10FFFF |
241 | | -; |
| 233 | +; |