-
Notifications
You must be signed in to change notification settings - Fork 620
/
kotlin.peg
479 lines (442 loc) · 32 KB
/
kotlin.peg
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
184
185
186
187
188
189
190
191
192
193
194
195
196
197
198
199
200
201
202
203
204
205
206
207
208
209
210
211
212
213
214
215
216
217
218
219
220
221
222
223
224
225
226
227
228
229
230
231
232
233
234
235
236
237
238
239
240
241
242
243
244
245
246
247
248
249
250
251
252
253
254
255
256
257
258
259
260
261
262
263
264
265
266
267
268
269
270
271
272
273
274
275
276
277
278
279
280
281
282
283
284
285
286
287
288
289
290
291
292
293
294
295
296
297
298
299
300
301
302
303
304
305
306
307
308
309
310
311
312
313
314
315
316
317
318
319
320
321
322
323
324
325
326
327
328
329
330
331
332
333
334
335
336
337
338
339
340
341
342
343
344
345
346
347
348
349
350
351
352
353
354
355
356
357
358
359
360
361
362
363
364
365
366
367
368
369
370
371
372
373
374
375
376
377
378
379
380
381
382
383
384
385
386
387
388
389
390
391
392
393
394
395
396
397
398
399
400
401
402
403
404
405
406
407
408
409
410
411
412
413
414
415
416
417
418
419
420
421
422
423
424
425
426
427
428
429
430
431
432
433
434
435
436
437
438
439
440
441
442
443
444
445
446
447
448
449
450
451
452
453
454
455
456
457
458
459
460
461
462
463
464
465
466
467
468
469
470
471
472
473
474
475
476
477
478
479
# Copyright (c) 2021 Jan Dolinár
#
# This source code is released for free distribution under the terms of the
# GNU General Public License version 2.
#
# This file contains description of Kotlin grammar based on the ANTLR grammar
# from https://github.com/Kotlin/kotlin-grammar-gpl2.
#
# Notes:
# 1. This file was originally derived from files (reference grammar files) in https://github.com/Kotlin/kotlin-spec
# 2. Kotlin/kotlin-spec is distributed under Apache2 license
# 3. I have requested the original developers to "re-license or dual-license" (see https://github.com/Kotlin/kotlin-spec/issues/70)
# 4. The request was accepted and the original developer made a new repository https://github.com/Kotlin/kotlin-grammar-gpl2
# for redistributing the reference grammar files under GPLv2 license.
# 5. This file is now derived from Kotlin/kotlin-grammar-gpl2 repository.
# 6. Unlike many other files in Universal Ctags, this source code is released strictly under GPLv2
# and should not be relicensed to later versions of GPL.
%prefix "pkotlin"
%auxil "struct parserCtx *"
%earlysource {
#include "general.h"
}
%header {
struct parserCtx;
}
%source {
#include "kotlin_pre.h"
}
file <- shebangLine? NL* fileAnnotation* _* packageHeader* _* importList* _* (filePart / _ / unparsable)* EOF
filePart <- (topLevelObject / (statement _* semi)) {resetFailure(auxil, $0s);}
unparsable <- [^\n]+ NL* {reportFailure(auxil, $0s);}
### Converted from peg/kotlin/KotlinParser.g4
# options
# // SECTION: general
#kotlinFile <- shebangLine? NL* fileAnnotation* _* packageHeader _* importList _* topLevelObject* EOF
#script <- shebangLine? NL* fileAnnotation* _* packageHeader _* importList _* (statement _* semi)* EOF
shebangLine <- ShebangLine _* NL+
fileAnnotation <- (AT_NO_WS / AT_PRE_WS) FILE NL* COLON _* NL* (LSQUARE _* unescapedAnnotation+ _* RSQUARE / unescapedAnnotation) _* NL*
packageHeader <- PACKAGE {PUSH_KIND(auxil, K_PACKAGE);} _ <identifier> {makeKotlinTag(auxil, $1, $1s, true);} _* semi?
importList <- importHeader+
importHeader <- IMPORT _ identifier (DOT MULT / importAlias)? _* semi? _*
importAlias <- _ AS _ simpleIdentifier
topLevelObject <- declaration _* semis?
typeAlias <- modifiers? _* TYPE_ALIAS {PUSH_KIND(auxil, K_TYPEALIAS);} (_ / NL)* <simpleIdentifier> {makeKotlinTag(auxil, $1, $1s, false);} _* (__* typeParameters)? __* ASSIGNMENT __* type
declaration <- classDeclaration / objectDeclaration / functionDeclaration / propertyDeclaration / typeAlias
# // SECTION: classes
classDeclaration <- modifiers? (CLASS {PUSH_KIND(auxil, K_CLASS);} / (FUN __*)? INTERFACE {PUSH_KIND(auxil, K_INTERFACE);}) _ NL* <simpleIdentifier> {makeKotlinTag(auxil, $1, $1s, true);} (__* typeParameters)? (__* primaryConstructor)? (__* COLON __* delegationSpecifiers)? (__* typeConstraints)? (__* classBody / __* enumClassBody)? {POP_SCOPE(auxil);}
primaryConstructor <- (modifiers? CONSTRUCTOR __*)? classParameters
classBody <- LCURL __* classMemberDeclarations __* RCURL
classParameters <- LPAREN __* (classParameter (__* COMMA __* classParameter)* (__* COMMA)?)? __* RPAREN
classParameter <- (modifiers? _* VAL {PUSH_KIND(auxil, K_CONSTANT);} / modifiers? _* VAR {PUSH_KIND(auxil, K_VARIABLE);} / modifiers? {PUSH_KIND(auxil, K_IGNORE);} _*)? __* <simpleIdentifier> {makeKotlinTag(auxil, $1, $1s, true);} _* COLON __* type (__* ASSIGNMENT __* expression)? {POP_SCOPE(auxil);}
delegationSpecifiers <- annotatedDelegationSpecifier (__* COMMA __* annotatedDelegationSpecifier)*
delegationSpecifier <- constructorInvocation / explicitDelegation / userType / functionType
constructorInvocation <- userType __* valueArguments
annotatedDelegationSpecifier <- annotation* __* delegationSpecifier
explicitDelegation <- (userType / functionType) __* BY __* expression
typeParameters <- LANGLE __* typeParameter (__* COMMA __* typeParameter)* (__* COMMA)? __* RANGLE
typeParameter <- typeParameterModifiers? __* simpleIdentifier (__* COLON __* type)?
typeConstraints <- WHERE __* typeConstraint (__* COMMA __* typeConstraint)*
typeConstraint <- annotation* simpleIdentifier __* COLON __* type
# // SECTION: classMembers
classMemberDeclarations <- (classMemberDeclaration semis?)*
classMemberDeclaration <- secondaryConstructor / anonymousInitializer / companionObject / declaration
anonymousInitializer <- INIT __* block
companionObject <- modifiers? COMPANION __* (DATA __*)? OBJECT {PUSH_KIND(auxil, K_OBJECT);} <(__* simpleIdentifier)?> {makeKotlinTag(auxil, $1e-$1s != 0 ? $1 : "Companion", $1s, true);} (__* COLON __* delegationSpecifiers)? (__* classBody)? {POP_SCOPE(auxil);}
functionValueParameters <- LPAREN __* (functionValueParameter (__* COMMA __* functionValueParameter)* (__* COMMA)?)? __* RPAREN
functionValueParameter <- parameterModifiers? _* parameter (__* ASSIGNMENT __* expression)?
functionDeclaration <- modifiers? _* FUN {PUSH_KIND(auxil, K_METHOD);} _* (__* typeParameters)? _* (__* receiverTypeAndDot)? __* <simpleIdentifier> {makeKotlinTag(auxil, $1, $1s, true);} __* functionValueParameters _* (__* COLON __* type)? _* (__* typeConstraints)? _* (__* functionBody)? {POP_SCOPE(auxil);}
functionBody <- block / ASSIGNMENT __* expression
variableDeclaration <- annotation* __* <simpleIdentifier> {makeKotlinTag(auxil, $1, $1s, false);} (__* COLON __* type)?
multiVariableDeclaration <- LPAREN __* variableDeclaration _* (__* COMMA __* variableDeclaration)* _* (__* COMMA)? __* RPAREN
propertyDeclaration <- modifiers? _* (VAL {PUSH_KIND(auxil, K_CONSTANT);} / VAR {PUSH_KIND(auxil, K_VARIABLE);}) _ (__* typeParameters)? (__* receiverTypeAndDot)? (__* (multiVariableDeclaration / variableDeclaration)) (__* typeConstraints)? (__* (ASSIGNMENT __* expression / propertyDelegate))? (semi? _* setter (NL* semi? _* getter)? / semi? _* getter (NL* semi? _* setter)?)?
propertyDelegate <- BY __* expression
# TODO: better handling of empty getters and setters?
getter <- (modifiers _*)? GET __* LPAREN __* RPAREN (__* COLON __* type)? __* functionBody / (modifiers _*)? GET !(_* [^;\r\n])
setter <- (modifiers _*)? SET __* LPAREN __* parameterWithOptionalType (__* COMMA)? __* RPAREN (__* COLON __* type)? __* functionBody / (modifiers _*)? SET !(_* [^;\r\n])
parametersWithOptionalType <- LPAREN __* (parameterWithOptionalType (__* COMMA __* parameterWithOptionalType)* (__* COMMA)?)? __* RPAREN
parameterWithOptionalType <- parameterModifiers? simpleIdentifier __* (COLON __* type)?
parameter <- simpleIdentifier __* COLON __* type
objectDeclaration <- modifiers? _* OBJECT {PUSH_KIND(auxil, K_OBJECT);} __* <simpleIdentifier> {makeKotlinTag(auxil, $1, $1s, true);} (__* COLON __* delegationSpecifiers)? (__* classBody)? {POP_SCOPE(auxil);}
secondaryConstructor <- modifiers? CONSTRUCTOR __* functionValueParameters (__* COLON __* constructorDelegationCall)? __* block?
constructorDelegationCall <- THIS __* valueArguments / SUPER __* valueArguments
# // SECTION: enumClasses
enumClassBody <- LCURL __* enumEntries? (__* SEMICOLON __* classMemberDeclarations)? __* RCURL
enumEntries <- enumEntry (__* COMMA __* enumEntry)* __* COMMA?
enumEntry <- (modifiers __*)? simpleIdentifier (__* valueArguments)? (__* classBody)?
# // SECTION: types
type <- typeModifiers? ( functionType / nullableType / parenthesizedType / typeReference)
typeReference <- userType / DYNAMIC
nullableType <- (typeReference / parenthesizedType) __* quest+
quest <- !elvis (QUEST_WS / QUEST_NO_WS)
userType <- simpleUserType (__* DOT __* simpleUserType)*
simpleUserType <- simpleIdentifier (__* typeArguments)?
typeProjection <- typeProjectionModifiers? type / MULT
typeProjectionModifiers <- typeProjectionModifier+
typeProjectionModifier <- varianceModifier __* / annotation
functionType <- (receiverType __* DOT __*)? functionTypeParameters __* ARROW __* type
functionTypeParameters <- LPAREN __* (parameter / type)? _* (__* COMMA __* (parameter / type))* _* (__* COMMA)? __* RPAREN
parenthesizedType <- LPAREN __* type __* RPAREN
receiverType <- (typeModifiers _*)? (nullableType / parenthesizedType / typeReference)
# parenthesizedUserType <- LPAREN __* userType __* RPAREN / LPAREN __* parenthesizedUserType __* RPAREN
receiverTypeAndDot <- (typeModifiers _*)? (nullableType __* DOT __* / parenthesizedType __* DOT __* / (simpleUserType __* DOT __*)+)
# // SECTION: statements
#statements <- (statement (semis statement)*)? semis?
statements <- (statement _* (semis _* statement _*)*)? _* semis?
statement <- (label / annotation)* ( declaration / assignment / loopStatement / expression)
label <- simpleIdentifier (AT_POST_WS / AT_NO_WS) __*
controlStructureBody <- block / statement
block <- LCURL __* statements __* RCURL
loopStatement <- forStatement / whileStatement / doWhileStatement
forStatement <- FOR __* LPAREN _* annotation* _* (variableDeclaration / multiVariableDeclaration) _ IN _ inside_expression _* RPAREN __* (controlStructureBody)?
whileStatement <- WHILE __* LPAREN _* inside_expression _* RPAREN __* controlStructureBody / WHILE __* LPAREN _* expression _* RPAREN __* SEMICOLON
doWhileStatement <- DO __* controlStructureBody? __* WHILE __* LPAREN _* expression _* RPAREN
assignment <- directlyAssignableExpression _* ASSIGNMENT __* expression / assignableExpression _* assignmentAndOperator __* expression
semi <- (_* (SEMICOLON / NL) _*) NL*
semis <- (_* (SEMICOLON / NL) _*)+
# // SECTION: expressions
expression <- disjunction
disjunction <- conjunction (__* DISJ __* conjunction)*
conjunction <- equality (__* CONJ __* equality)*
equality <- comparison (_* equalityOperator __* comparison _*)*
comparison <- genericCallLikeComparison (_* comparisonOperator __* genericCallLikeComparison _*)*
genericCallLikeComparison <- infixOperation (_* callSuffix)*
infixOperation <- elvisExpression (_* inOperator __* elvisExpression / _* isOperator __* type)*
elvisExpression <- infixFunctionCall (__* elvis __* infixFunctionCall)*
elvis <- QUEST_NO_WS COLON
infixFunctionCall <- rangeExpression (_* simpleIdentifier __* rangeExpression)*
rangeExpression <- additiveExpression (_* (RANGE_UNTIL / RANGE) __* additiveExpression)*
additiveExpression <- multiplicativeExpression (_* additiveOperator __* multiplicativeExpression)*
multiplicativeExpression <- asExpression (_* multiplicativeOperator __* asExpression)*
asExpression <- prefixUnaryExpression (__* asOperator __* type)*
prefixUnaryExpression <- (unaryPrefix _*)* postfixUnaryExpression
unaryPrefix <- annotation / label / prefixUnaryOperator __*
postfixUnaryExpression <- primaryExpression (_* postfixUnarySuffix)+ / primaryExpression
postfixUnarySuffix <- postfixUnaryOperator / typeArguments / callSuffix / indexingSuffix / navigationSuffix
directlyAssignableExpression <- postfixUnaryExpression _* assignableSuffix / postfixUnaryExpression / simpleIdentifier / parenthesizedDirectlyAssignableExpression
parenthesizedDirectlyAssignableExpression <- LPAREN __* inside_directlyAssignableExpression __* RPAREN
assignableExpression <- prefixUnaryExpression / parenthesizedAssignableExpression
parenthesizedAssignableExpression <- LPAREN __* inside_assignableExpression __* RPAREN
assignableSuffix <- navigationSuffix / typeArguments / indexingSuffix
indexingSuffix <- LSQUARE __* inside_expression (__* COMMA __* inside_expression)* (__* COMMA)? __* RSQUARE
navigationSuffix <- __* memberAccessOperator __* (simpleIdentifier / parenthesizedExpression / CLASS)
callSuffix <- typeArguments? _* valueArguments? _* annotatedLambda / typeArguments? _* valueArguments
annotatedLambda <- annotation* _* label? __* lambdaLiteral
typeArguments <- LANGLE __* typeProjection (__* COMMA __* typeProjection)* (__* COMMA)? __* RANGLE
valueArguments <- LPAREN __* RPAREN / LPAREN __* inside_valueArgument (__* COMMA __* inside_valueArgument)* (__* COMMA)? __* RPAREN
#valueArgument <- annotation? __* (simpleIdentifier __* ASSIGNMENT __*)? MULT? __* expression
primaryExpression <- thisExpression / superExpression / ifExpression / whenExpression / tryExpression / jumpExpression / parenthesizedExpression/ callableReference / stringLiteral / functionLiteral / objectLiteral / collectionLiteral / simpleIdentifier / literalConstant
parenthesizedExpression <- LPAREN __* inside_expression __* RPAREN
collectionLiteral <- LSQUARE __* inside_expression (__* COMMA __* inside_expression)* (__* COMMA)? __* RSQUARE / LSQUARE __* RSQUARE
literalConstant <- BooleanLiteral / CharacterLiteral / NullLiteral / RealLiteral / UnsignedLiteral / LongLiteral / HexLiteral / BinLiteral / IntegerLiteral
stringLiteral <- multiLineStringLiteral / lineStringLiteral
lineStringLiteral <- QUOTE_OPEN (lineStringExpression / lineStringContent)* QUOTE_CLOSE
#lineStringLiteral <- QUOTE_OPEN (lineStringExpression / EscapedIdentifier / UniCharacterLiteral / stringChar)* QUOTE_CLOSE
multiLineStringLiteral <- TRIPLE_QUOTE_OPEN (multiLineStringExpression / multiLineStringContent / MultiLineStringQuote)* TRIPLE_QUOTE_CLOSE
#multiLineStringLiteral <- TRIPLE_QUOTE_OPEN (multiLineStringExpression / MultiLineStringQuote / EscapedIdentifier / UniChracterLiteral / stringChar)* TRIPLE_QUOTE_CLOSE
lineStringContent <- LineStrText / LineStrEscapedChar / LineStrRef
lineStringExpression <- LineStrExprStart __* expression __* RCURL
multiLineStringContent <- MultiLineStrRef / MultiLineStrText / MultiLineStringQuote
multiLineStringExpression <- MultiLineStrExprStart __* expression __* RCURL
inside_expression <- inside_disjunction
inside_disjunction <- inside_conjunction (__* DISJ __* inside_conjunction)*
inside_conjunction <- inside_equality (__* CONJ __* inside_equality)*
inside_equality <- inside_comparison ((_ / NL)* equalityOperator __* inside_comparison (_ / NL)*)*
inside_comparison <- inside_genericCallLikeComparison ((_ / NL)* comparisonOperator __* inside_genericCallLikeComparison (_ / NL)*)*
inside_genericCallLikeComparison <- inside_infixOperation ((_ / NL)* callSuffix)*
inside_infixOperation <- inside_elvisExpression ((_ / NL)* inOperator __* inside_elvisExpression / (_ / NL)* isOperator __* type)*
inside_elvisExpression <- inside_infixFunctionCall (__* elvis __* inside_infixFunctionCall)*
inside_infixFunctionCall <- inside_rangeExpression ((_ / NL)* simpleIdentifier __* inside_rangeExpression)*
inside_rangeExpression <- inside_additiveExpression ((_ / NL)* RANGE __* inside_additiveExpression)*
inside_additiveExpression <- inside_multiplicativeExpression ((_ / NL)* additiveOperator __* inside_multiplicativeExpression)*
inside_multiplicativeExpression <- inside_asExpression ((_ / NL)* multiplicativeOperator __* inside_asExpression)*
inside_asExpression <- inside_prefixUnaryExpression (__* asOperator __* type)*
inside_prefixUnaryExpression <- (inside_unaryPrefix (_ / NL)*)* inside_postfixUnaryExpression
inside_unaryPrefix <- annotation / label / prefixUnaryOperator __*
inside_postfixUnaryExpression <- primaryExpression ((_ / NL)* inside_postfixUnarySuffix)+ / primaryExpression
inside_postfixUnarySuffix <- postfixUnaryOperator / typeArguments / callSuffix / indexingSuffix / navigationSuffix
inside_directlyAssignableExpression <- inside_postfixUnaryExpression (_ / NL)* assignableSuffix / inside_postfixUnaryExpression / simpleIdentifier / parenthesizedDirectlyAssignableExpression
inside_assignableExpression <- inside_prefixUnaryExpression / parenthesizedAssignableExpression
inside_valueArgument <- annotation? __* (simpleIdentifier __* ASSIGNMENT __*)? MULT? __* inside_expression
#characterLiteral <- "'" (UniCharacterLiteral / EscapedIdentifier / [^\n\r'\\]) "'"
#stringChar <- [^"]
lambdaLiteral <- LCURL {PUSH_KIND(auxil, K_METHOD); makeKotlinTag(auxil, "<lambda>", $0s, true);} __* statements __* RCURL {POP_SCOPE(auxil);} / LCURL {PUSH_KIND(auxil, K_METHOD); makeKotlinTag(auxil, "<lambda>", 8, true);} __* lambdaParameters? __* ARROW __* statements __* RCURL {POP_SCOPE(auxil);}
lambdaParameters <- lambdaParameter (__* COMMA __* lambdaParameter)* (__* COMMA)?
lambdaParameter <- variableDeclaration / multiVariableDeclaration (__* COLON __* type)?
anonymousFunction <- (SUSPEND __*)? FUN {PUSH_KIND(auxil, K_METHOD); makeKotlinTag(auxil, "<anonymous>", $0s, true);} (__* type __* DOT)? __* parametersWithOptionalType (__* COLON __* type)? (__* typeConstraints)? (__* functionBody)? {POP_SCOPE(auxil);}
functionLiteral <- lambdaLiteral / anonymousFunction
objectLiteral <- (DATA __*)? OBJECT __* COLON __* delegationSpecifiers __* classBody / OBJECT __* classBody
thisExpression <- THIS_AT / THIS !(Letter / UnicodeDigit)
superExpression <- SUPER_AT / SUPER (LANGLE __* type __* RANGLE)? (AT_NO_WS simpleIdentifier)?
ifExpression <- IF __* LPAREN __* expression __* RPAREN __* controlStructureBody? __* SEMICOLON? __* ELSE __* (controlStructureBody / SEMICOLON) / IF __* LPAREN __* expression __* RPAREN __* (controlStructureBody / SEMICOLON)
whenSubject <- LPAREN (annotation* __* VAL __* variableDeclaration __* ASSIGNMENT __*)? expression RPAREN
whenExpression <- WHEN __* whenSubject? __* LCURL __* (whenEntry __*)* __* RCURL
whenEntry <- whenCondition (__* COMMA __* whenCondition)* (__* COMMA)? __* ARROW __* controlStructureBody semi? / ELSE __* ARROW __* controlStructureBody semi?
whenCondition <- expression / rangeTest / typeTest
rangeTest <- inOperator __* expression
typeTest <- isOperator __* type
tryExpression <- TRY __* block ((__* catchBlock)+ (__* finallyBlock)? / __* finallyBlock)
catchBlock <- CATCH __* LPAREN _* (annotation _*)* simpleIdentifier _* COLON _* type (__* COMMA)? _* RPAREN __* block
finallyBlock <- FINALLY __* block
jumpExpression <- THROW __* expression / (RETURN_AT / RETURN) _* expression? / CONTINUE_AT / CONTINUE / BREAK_AT / BREAK
callableReference <- (receiverType? __* COLONCOLON __* (simpleIdentifier / CLASS))
assignmentAndOperator <- ADD_ASSIGNMENT / SUB_ASSIGNMENT / MULT_ASSIGNMENT / DIV_ASSIGNMENT / MOD_ASSIGNMENT
equalityOperator <- EQEQEQ / EQEQ / EXCL_EQEQ / EXCL_EQ
comparisonOperator <- LE / GE / LANGLE / RANGLE
inOperator <- IN / NOT_IN
isOperator <- IS / NOT_IS
additiveOperator <- ADD / SUB
multiplicativeOperator <- MULT / DIV / MOD
asOperator <- AS_SAFE / AS
prefixUnaryOperator <- INCR / DECR / SUB / ADD / excl
postfixUnaryOperator <- INCR / DECR / EXCL_NO_WS excl
excl <- EXCL_WS / EXCL_NO_WS
memberAccessOperator <- DOT / safeNav / COLONCOLON
safeNav <- QUEST_NO_WS DOT
# // SECTION: modifiers
modifiers <- (annotation / modifier)+
parameterModifiers <- (annotation / parameterModifier)+
modifier <- (classModifier / memberModifier / visibilityModifier / functionModifier / propertyModifier / inheritanceModifier / parameterModifier / platformModifier) __*
typeModifiers <- typeModifier+
typeModifier <- annotation / SUSPEND __*
classModifier <- ENUM / SEALED / ANNOTATION / DATA / INNER
memberModifier <- OVERRIDE / LATEINIT
visibilityModifier <- PUBLIC / PRIVATE / INTERNAL / PROTECTED
varianceModifier <- IN / OUT
typeParameterModifiers <- typeParameterModifier+
typeParameterModifier <- reificationModifier __* / varianceModifier __* / annotation
functionModifier <- TAILREC / OPERATOR / INFIX / INLINE / EXTERNAL / SUSPEND
propertyModifier <- CONST
inheritanceModifier <- ABSTRACT / FINAL / OPEN
parameterModifier <- VARARG / NOINLINE / CROSSINLINE
reificationModifier <- REIFIED
platformModifier <- EXPECT / ACTUAL
# // SECTION: annotations
annotation <- (singleAnnotation / multiAnnotation) __*
singleAnnotation <- annotationUseSiteTarget __* unescapedAnnotation / (AT_NO_WS / AT_PRE_WS) unescapedAnnotation
multiAnnotation <- annotationUseSiteTarget __* LSQUARE unescapedAnnotation+ RSQUARE / (AT_NO_WS / AT_PRE_WS) LSQUARE unescapedAnnotation+ RSQUARE
annotationUseSiteTarget <- (AT_NO_WS / AT_PRE_WS) (FIELD / PROPERTY / GET / SET / RECEIVER / PARAM / SETPARAM / DELEGATE) __* COLON
unescapedAnnotation <- constructorInvocation / userType
# // SECTION: identifiers
simpleIdentifier <- !(hardKeyword !(Letter / '_' / UnicodeDigit)) Identifier / ABSTRACT / ANNOTATION / BY / CATCH / COMPANION / CONSTRUCTOR / CROSSINLINE / DATA / DYNAMIC / ENUM / EXTERNAL / FINAL / FINALLY / GET / IMPORT / INFIX / INIT / INLINE / INNER / INTERNAL / LATEINIT / NOINLINE / OPEN / OPERATOR / OUT / OVERRIDE / PRIVATE / PROTECTED / PUBLIC / REIFIED / SEALED / TAILREC / SET / VARARG / WHERE / FIELD / PROPERTY / RECEIVER / PARAM / SETPARAM / DELEGATE / FILE / EXPECT / ACTUAL / CONST / SUSPEND
identifier <- simpleIdentifier (__* DOT simpleIdentifier)*
hardKeyword <- AS / BREAK / CLASS / CONTINUE / DO / ELSE / FOR / FUN / IF / IN / INTERFACE / IS / NullLiteral / OBJECT / PACKAGE / RETURN / SUPER / THIS / THROW / TRY / TYPE_ALIAS / TYPEOF / VAL / VAR / WHEN / WHILE / BooleanLiteral
### Converted from peg/kotlin/KotlinLexer.g4
# // SECTION: lexicalGeneral
ShebangLine <- '#!' [^\r\n]*
DelimitedComment <- '/*' (DelimitedComment / !'*/' .)* '*/'
LineComment <- '//' [^\r\n]*
#WS <- [\u0020\u0009\u000C]
#NL <- '\n' / '\r' '\n'?
Hidden <- DelimitedComment / LineComment / WS
# // SECTION: separatorsAndOperations
#RESERVED <- '...'
DOT <- '.'
COMMA <- ','
LPAREN <- '('
RPAREN <- ')'
LSQUARE <- '['
RSQUARE <- ']'
LCURL <- '{'
# /*
# * When using another programming language (not Java) to generate a parser,
# * please replace this code with the corresponding code of a programming language you are using.
# */
RCURL <- '}'
MULT <- '*'
MOD <- '%'
DIV <- '/'
ADD <- '+'
SUB <- '-'
INCR <- '++'
DECR <- '--'
CONJ <- '&&'
DISJ <- '||'
EXCL_WS <- '!' Hidden
EXCL_NO_WS <- '!'
COLON <- ':'
SEMICOLON <- ';'
ASSIGNMENT <- '=' !'='
ADD_ASSIGNMENT <- '+='
SUB_ASSIGNMENT <- '-='
MULT_ASSIGNMENT <- '*='
DIV_ASSIGNMENT <- '/='
MOD_ASSIGNMENT <- '%='
ARROW <- '->'
#DOUBLE_ARROW <- '=>'
RANGE <- '..'
RANGE_UNTIL <- '..<'
COLONCOLON <- '::'
#DOUBLE_SEMICOLON <- ';;'
#HASH <- '#'
AT_NO_WS <- '@'
AT_POST_WS <- '@' (Hidden / NL)
AT_PRE_WS <- (Hidden / NL) '@'
#AT_BOTH_WS <- (Hidden / NL) '@' (Hidden / NL)
QUEST_WS <- '?' Hidden
QUEST_NO_WS <- '?'
LANGLE <- '<'
RANGLE <- '>'
LE <- '<='
GE <- '>='
EXCL_EQ <- '!='
EXCL_EQEQ <- '!=='
AS_SAFE <- 'as?'
EQEQ <- '=='
EQEQEQ <- '==='
#SINGLE_QUOTE <- '\''
# // SECTION: keywords
RETURN_AT <- 'return@' Identifier
CONTINUE_AT <- 'continue@' Identifier
BREAK_AT <- 'break@' Identifier
THIS_AT <- 'this@' Identifier
SUPER_AT <- 'super@' Identifier
FILE <- 'file' !(Letter / UnicodeDigit)
FIELD <- 'field' !(Letter / UnicodeDigit)
PROPERTY <- 'property' !(Letter / UnicodeDigit)
GET <- 'get' !(Letter / UnicodeDigit)
SET <- 'set' !(Letter / UnicodeDigit)
RECEIVER <- 'receiver' !(Letter / UnicodeDigit)
PARAM <- 'param' !(Letter / UnicodeDigit)
SETPARAM <- 'setparam' !(Letter / UnicodeDigit)
DELEGATE <- 'delegate' !(Letter / UnicodeDigit)
PACKAGE <- 'package' !(Letter / UnicodeDigit)
IMPORT <- 'import' !(Letter / UnicodeDigit)
CLASS <- 'class' !(Letter / UnicodeDigit)
INTERFACE <- 'interface' !(Letter / UnicodeDigit)
FUN <- 'fun' !(Letter / UnicodeDigit)
OBJECT <- 'object' !(Letter / UnicodeDigit)
VAL <- 'val' !(Letter / UnicodeDigit)
VAR <- 'var' !(Letter / UnicodeDigit)
TYPE_ALIAS <- 'typealias' !(Letter / UnicodeDigit)
CONSTRUCTOR <- 'constructor' !(Letter / UnicodeDigit)
BY <- 'by' !(Letter / UnicodeDigit)
COMPANION <- 'companion' !(Letter / UnicodeDigit)
INIT <- 'init' !(Letter / UnicodeDigit)
THIS <- 'this' !(Letter / UnicodeDigit)
SUPER <- 'super' !(Letter / UnicodeDigit)
TYPEOF <- 'typeof' !(Letter / UnicodeDigit)
WHERE <- 'where' !(Letter / UnicodeDigit)
IF <- 'if' !(Letter / UnicodeDigit)
ELSE <- 'else' !(Letter / UnicodeDigit)
WHEN <- 'when' !(Letter / UnicodeDigit)
TRY <- 'try' !(Letter / UnicodeDigit)
CATCH <- 'catch' !(Letter / UnicodeDigit)
FINALLY <- 'finally' !(Letter / UnicodeDigit)
FOR <- 'for' !(Letter / UnicodeDigit)
DO <- 'do' !(Letter / UnicodeDigit)
WHILE <- 'while' !(Letter / UnicodeDigit)
THROW <- 'throw' !(Letter / UnicodeDigit)
RETURN <- 'return' !(Letter / UnicodeDigit)
CONTINUE <- 'continue' !(Letter / UnicodeDigit)
BREAK <- 'break' !(Letter / UnicodeDigit)
AS <- 'as' !(Letter / UnicodeDigit)
IS <- 'is' !(Letter / UnicodeDigit)
IN <- 'in' !(Letter / UnicodeDigit)
NOT_IS <- '!is' !(Letter / UnicodeDigit)
NOT_IN <- '!in' !(Letter / UnicodeDigit)
OUT <- 'out' !(Letter / UnicodeDigit)
DYNAMIC <- 'dynamic' !(Letter / UnicodeDigit)
# // SECTION: lexicalModifiers
PUBLIC <- 'public' !(Letter / UnicodeDigit)
PRIVATE <- 'private' !(Letter / UnicodeDigit)
PROTECTED <- 'protected' !(Letter / UnicodeDigit)
INTERNAL <- 'internal' !(Letter / UnicodeDigit)
ENUM <- 'enum' !(Letter / UnicodeDigit)
SEALED <- 'sealed' !(Letter / UnicodeDigit)
ANNOTATION <- 'annotation' !(Letter / UnicodeDigit)
DATA <- 'data' !(Letter / UnicodeDigit)
INNER <- 'inner' !(Letter / UnicodeDigit)
TAILREC <- 'tailrec' !(Letter / UnicodeDigit)
OPERATOR <- 'operator' !(Letter / UnicodeDigit)
INLINE <- 'inline' !(Letter / UnicodeDigit)
INFIX <- 'infix' !(Letter / UnicodeDigit)
EXTERNAL <- 'external' !(Letter / UnicodeDigit)
SUSPEND <- 'suspend' !(Letter / UnicodeDigit)
OVERRIDE <- 'override' !(Letter / UnicodeDigit)
ABSTRACT <- 'abstract' !(Letter / UnicodeDigit)
FINAL <- 'final' !(Letter / UnicodeDigit)
OPEN <- 'open' !(Letter / UnicodeDigit)
CONST <- 'const' !(Letter / UnicodeDigit)
LATEINIT <- 'lateinit' !(Letter / UnicodeDigit)
VARARG <- 'vararg' !(Letter / UnicodeDigit)
NOINLINE <- 'noinline' !(Letter / UnicodeDigit)
CROSSINLINE <- 'crossinline' !(Letter / UnicodeDigit)
REIFIED <- 'reified' !(Letter / UnicodeDigit)
EXPECT <- 'expect' !(Letter / UnicodeDigit)
ACTUAL <- 'actual' !(Letter / UnicodeDigit)
# // SECTION: literals
DecDigit <- [0-9]
DecDigitNoZero <- [1-9]
DecDigitOrSeparator <- DecDigit / '_'
DecDigits <- DecDigit DecDigitOrSeparator* / DecDigit
DoubleExponent <- [eE] [-+]? DecDigits
RealLiteral <- FloatLiteral / DoubleLiteral
FloatLiteral <- DoubleLiteral [fF] / DecDigits [fF]
DoubleLiteral <- DecDigits? '.' DecDigits DoubleExponent? / DecDigits DoubleExponent
IntegerLiteral <- DecDigitNoZero DecDigitOrSeparator* / DecDigit
#IntegerLiteral <- DecDigitNoZero DecDigitOrSeparator* DecDigit / DecDigit
HexDigit <- [0-9a-fA-F]
HexDigitOrSeparator <- HexDigit / '_'
HexLiteral <- '0' [xX] HexDigit HexDigitOrSeparator* / '0' [xX] HexDigit
BinDigit <- [01]
BinDigitOrSeparator <- BinDigit / '_'
BinLiteral <- '0' [bB] BinDigit BinDigitOrSeparator* / '0' [bB] BinDigit
UnsignedLiteral <- (HexLiteral / BinLiteral / IntegerLiteral) [uU] [lL]?
LongLiteral <- (HexLiteral / BinLiteral / IntegerLiteral) [lL]
BooleanLiteral <- 'true'/ 'false'
NullLiteral <- 'null'
CharacterLiteral <- '\'' (EscapeSeq / [^\n\r'\\]) '\''
# // SECTION: lexicalIdentifiers
#UnicodeDigit <- UNICODE_CLASS_ND
Identifier <- '`' [^`\r\n]+ '`' / (Letter / '_') (Letter / '_' / UnicodeDigit)*
IdentifierOrSoftKey <- Identifier / ABSTRACT / ANNOTATION / BY / CATCH / COMPANION / CONSTRUCTOR / CROSSINLINE / DATA / DYNAMIC / ENUM / EXTERNAL / FINAL / FINALLY / IMPORT / INFIX / INIT / INLINE / INNER / INTERNAL / LATEINIT / NOINLINE / OPEN / OPERATOR / OUT / OVERRIDE / PRIVATE / PROTECTED / PUBLIC / REIFIED / SEALED / TAILREC / VARARG / WHERE / GET / SET / FIELD / PROPERTY / RECEIVER / PARAM / SETPARAM / DELEGATE / FILE / EXPECT / ACTUAL / CONST / SUSPEND
FieldIdentifier <- '$' IdentifierOrSoftKey
UniCharacterLiteral <- '\\' 'u' HexDigit HexDigit HexDigit HexDigit
EscapedIdentifier <- '\\' ('t' / 'b' / 'r' / 'n' / '\'' / '"' / '\\' / '$')
EscapeSeq <- UniCharacterLiteral / EscapedIdentifier
# // SECTION: characters
Letter <- [\u0041-\u005A\u0061-\u007A\u00AA\u00B5\u00BA\u00C0-\u00D6\u00D8-\u00F6\u00F8-\u02C1\u02C6-\u02D1\u02E0-\u02E4\u02EC\u02EE\u0370-\u0374\u0376-\u0377\u037A-\u037D\u0386\u0388-\u038A\u038C\u038E-\u03A1\u03A3-\u03F5\u03F7-\u0481\u048A-\u0527\u0531-\u0556\u0559\u0561-\u0587\u05D0-\u05EA\u05F0-\u05F2\u0620-\u064A\u066E-\u066F\u0671-\u06D3\u06D5\u06E5-\u06E6\u06EE-\u06EF\u06FA-\u06FC\u06FF\u0710\u0712-\u072F\u074D-\u07A5\u07B1\u07CA-\u07EA\u07F4-\u07F5\u07FA\u0800-\u0815\u081A\u0824\u0828\u0840-\u0858\u08A0\u08A2-\u08AC\u0904-\u0939\u093D\u0950\u0958-\u0961\u0971-\u0977\u0979-\u097F\u0985-\u098C\u098F-\u0990\u0993-\u09A8\u09AA-\u09B0\u09B2\u09B6-\u09B9\u09BD\u09CE\u09DC-\u09DD\u09DF-\u09E1\u09F0-\u09F1\u0A05-\u0A0A\u0A0F-\u0A10\u0A13-\u0A28\u0A2A-\u0A30\u0A32-\u0A33\u0A35-\u0A36\u0A38-\u0A39\u0A59-\u0A5C\u0A5E\u0A72-\u0A74\u0A85-\u0A8D\u0A8F-\u0A91\u0A93-\u0AA8\u0AAA-\u0AB0\u0AB2-\u0AB3\u0AB5-\u0AB9\u0ABD\u0AD0\u0AE0-\u0AE1\u0B05-\u0B0C\u0B0F-\u0B10\u0B13-\u0B28\u0B2A-\u0B30\u0B32-\u0B33\u0B35-\u0B39\u0B3D\u0B5C-\u0B5D\u0B5F-\u0B61\u0B71\u0B83\u0B85-\u0B8A\u0B8E-\u0B90\u0B92-\u0B95\u0B99-\u0B9A\u0B9C\u0B9E-\u0B9F\u0BA3-\u0BA4\u0BA8-\u0BAA\u0BAE-\u0BB9\u0BD0\u0C05-\u0C0C\u0C0E-\u0C10\u0C12-\u0C28\u0C2A-\u0C33\u0C35-\u0C39\u0C3D\u0C58-\u0C59\u0C60-\u0C61\u0C85-\u0C8C\u0C8E-\u0C90\u0C92-\u0CA8\u0CAA-\u0CB3\u0CB5-\u0CB9\u0CBD\u0CDE\u0CE0-\u0CE1\u0CF1-\u0CF2\u0D05-\u0D0C\u0D0E-\u0D10\u0D12-\u0D3A\u0D3D\u0D4E\u0D60-\u0D61\u0D7A-\u0D7F\u0D85-\u0D96\u0D9A-\u0DB1\u0DB3-\u0DBB\u0DBD\u0DC0-\u0DC6\u0E01-\u0E30\u0E32-\u0E33\u0E40-\u0E46\u0E81-\u0E82\u0E84\u0E87-\u0E88\u0E8A\u0E8D\u0E94-\u0E97\u0E99-\u0E9F\u0EA1-\u0EA3\u0EA5\u0EA7\u0EAA-\u0EAB\u0EAD-\u0EB0\u0EB2-\u0EB3\u0EBD\u0EC0-\u0EC4\u0EC6\u0EDC-\u0EDF\u0F00\u0F40-\u0F47\u0F49-\u0F6C\u0F88-\u0F8C\u1000-\u102A\u103F\u1050-\u1055\u105A-\u105D\u1061\u1065-\u1066\u106E-\u1070\u1075-\u1081\u108E\u10A0-\u10C5\u10C7\u10CD\u10D0-\u10FA\u10FC-\u1248\u124A-\u124D\u1250-\u1256\u1258\u125A-\u125D\u1260-\u1288\u128A-\u128D\u1290-\u12B0\u12B2-\u12B5\u12B8-\u12BE\u12C0\u12C2-\u12C5\u12C8-\u12D6\u12D8-\u1310\u1312-\u1315\u1318-\u135A\u1380-\u138F\u13A0-\u13F4\u1401-\u166C\u166F-\u167F\u1681-\u169A\u16A0-\u16EA\u16EE-\u16F0\u1700-\u170C\u170E-\u1711\u1720-\u1731\u1740-\u1751\u1760-\u176C\u176E-\u1770\u1780-\u17B3\u17D7\u17DC\u1820-\u1877\u1880-\u18A8\u18AA\u18B0-\u18F5\u1900-\u191C\u1950-\u196D\u1970-\u1974\u1980-\u19AB\u19C1-\u19C7\u1A00-\u1A16\u1A20-\u1A54\u1AA7\u1B05-\u1B33\u1B45-\u1B4B\u1B83-\u1BA0\u1BAE-\u1BAF\u1BBA-\u1BE5\u1C00-\u1C23\u1C4D-\u1C4F\u1C5A-\u1C7D\u1CE9-\u1CEC\u1CEE-\u1CF1\u1CF5-\u1CF6\u1D00-\u1DBF\u1E00-\u1F15\u1F18-\u1F1D\u1F20-\u1F45\u1F48-\u1F4D\u1F50-\u1F57\u1F59\u1F5B\u1F5D\u1F5F-\u1F7D\u1F80-\u1FB4\u1FB6-\u1FBC\u1FBE\u1FC2-\u1FC4\u1FC6-\u1FCC\u1FD0-\u1FD3\u1FD6-\u1FDB\u1FE0-\u1FEC\u1FF2-\u1FF4\u1FF6-\u1FFC\u2071\u207F\u2090-\u209C\u2102\u2107\u210A-\u2113\u2115\u2119-\u211D\u2124\u2126\u2128\u212A-\u212D\u212F-\u2139\u213C-\u213F\u2145-\u2149\u214E\u2160-\u2188\u2C00-\u2C2E\u2C30-\u2C5E\u2C60-\u2CE4\u2CEB-\u2CEE\u2CF2-\u2CF3\u2D00-\u2D25\u2D27\u2D2D\u2D30-\u2D67\u2D6F\u2D80-\u2D96\u2DA0-\u2DA6\u2DA8-\u2DAE\u2DB0-\u2DB6\u2DB8-\u2DBE\u2DC0-\u2DC6\u2DC8-\u2DCE\u2DD0-\u2DD6\u2DD8-\u2DDE\u2E2F\u3005-\u3007\u3021-\u3029\u3031-\u3035\u3038-\u303C\u3041-\u3096\u309D-\u309F\u30A1-\u30FA\u30FC-\u30FF\u3105-\u312D\u3131-\u318E\u31A0-\u31BA\u31F0-\u31FF\u3400\u4DB5\u4E00\u9FCC\uA000-\uA48C\uA4D0-\uA4FD\uA500-\uA60C\uA610-\uA61F\uA62A-\uA62B\uA640-\uA66E\uA67F-\uA697\uA6A0-\uA6EF\uA717-\uA71F\uA722-\uA788\uA78B-\uA78E\uA790-\uA793\uA7A0-\uA7AA\uA7F8-\uA801\uA803-\uA805\uA807-\uA80A\uA80C-\uA822\uA840-\uA873\uA882-\uA8B3\uA8F2-\uA8F7\uA8FB\uA90A-\uA925\uA930-\uA946\uA960-\uA97C\uA984-\uA9B2\uA9CF\uAA00-\uAA28\uAA40-\uAA42\uAA44-\uAA4B\uAA60-\uAA76\uAA7A\uAA80-\uAAAF\uAAB1\uAAB5-\uAAB6\uAAB9-\uAABD\uAAC0\uAAC2\uAADB-\uAADD\uAAE0-\uAAEA\uAAF2-\uAAF4\uAB01-\uAB06\uAB09-\uAB0E\uAB11-\uAB16\uAB20-\uAB26\uAB28-\uAB2E\uABC0-\uABE2\uAC00\uD7A3\uD7B0-\uD7C6\uD7CB-\uD7FB\uF900-\uFA6D\uFA70-\uFAD9\uFB00-\uFB06\uFB13-\uFB17\uFB1D\uFB1F-\uFB28\uFB2A-\uFB36\uFB38-\uFB3C\uFB3E\uFB40-\uFB41\uFB43-\uFB44\uFB46-\uFBB1\uFBD3-\uFD3D\uFD50-\uFD8F\uFD92-\uFDC7\uFDF0-\uFDFB\uFE70-\uFE74\uFE76-\uFEFC\uFF21-\uFF3A\uFF41-\uFF5A\uFF66-\uFFBE\uFFC2-\uFFC7\uFFCA-\uFFCF\uFFD2-\uFFD7\uFFDA-\uFFDC]
UnicodeDigit <- [\u0030-\u0039\u0660-\u0669\u06F0-\u06F9\u07C0-\u07C9\u0966-\u096F\u09E6-\u09EF\u0A66-\u0A6F\u0AE6-\u0AEF\u0B66-\u0B6F\u0BE6-\u0BEF\u0C66-\u0C6F\u0CE6-\u0CEF\u0D66-\u0D6F\u0E50-\u0E59\u0ED0-\u0ED9\u0F20-\u0F29\u1040-\u1049\u1090-\u1099\u17E0-\u17E9\u1810-\u1819\u1946-\u194F\u19D0-\u19D9\u1A80-\u1A89\u1A90-\u1A99\u1B50-\u1B59\u1BB0-\u1BB9\u1C40-\u1C49\u1C50-\u1C59\uA620-\uA629\uA8D0-\uA8D9\uA900-\uA909\uA9D0-\uA9D9\uAA50-\uAA59\uABF0-\uABF9\uFF10-\uFF19]
# // SECTION: strings
QUOTE_OPEN <- '"' !'""'
TRIPLE_QUOTE_OPEN <- '"""'
QUOTE_CLOSE <- '"'
LineStrRef <- FieldIdentifier
#LineStrText <- [^\\"$]+ / '$'
LineStrText <- [^\\"$]+ / '$'
LineStrEscapedChar <- EscapedIdentifier / UniCharacterLiteral
LineStrExprStart <- '${'
TRIPLE_QUOTE_CLOSE <- '"""""'/ '""""' / '"""'
MultiLineStringQuote <- '""' !'"' / '"' !'""'
MultiLineStrRef <- FieldIdentifier
#MultiLineStrText <- !('"' / '$')+ / '$'
MultiLineStrText <- [^"$]+ / '$'
MultiLineStrExprStart <- '${'
_ <- (WS / DelimitedComment / LineComment)+
__ <- ([ \t\f\r\n] / DelimitedComment / LineComment)+
WS <- [ \t\f]
NL <- _* ('\n' / '\r' '\n'?) _*
EOF <- !.
%%
#include "kotlin_post.h"