Chromium Code Reviews
chromiumcodereview-hr@appspot.gserviceaccount.com (chromiumcodereview-hr) | Please choose your nickname with Settings | Help | Chromium Project | Gerrit Changes | Sign out
(638)

Issues Search
    My Issues | Starred     Open | Closed | All

Side by Side Diff: packages/petitparser/lib/src/dart/grammar.dart

Issue 2989763002: Update charted to 0.4.8 and roll (Closed)
Patch Set: Removed Cutch from list of reviewers Created 3 years, 4 months ago
Use n/p to move between diff chunks; N/P to move between comments. Draft comments are only viewable by you.
Jump to:
View unified diff | Download patch
« no previous file with comments | « packages/petitparser/lib/smalltalk.dart ('k') | packages/petitparser/lib/src/debug/continuation.dart » ('j') | no next file with comments »
Toggle Intra-line Diffs ('i') | Expand Comments ('e') | Collapse Comments ('c') | Show Comments Hide Comments ('s')
OLDNEW
(Empty)
1 part of petitparser.dart;
2
3 /// Dart grammar.
4 class DartGrammar extends GrammarParser {
5 DartGrammar() : super(new DartGrammarDefinition());
6 }
7
8 /// Dart grammar definition.
9 class DartGrammarDefinition extends GrammarDefinition {
10
11 Parser token(input) {
12 if (input is String) {
13 input = input.length == 1 ? char(input) : string(input);
14 } else if (input is Function) {
15 input = ref(input);
16 }
17 if (input is! Parser && input is TrimmingParser) {
18 throw new StateError('Invalid token parser: $input');
19 }
20 return input.token().trim(ref(HIDDEN_STUFF));
21 }
22
23
24 // Copyright (c) 2011, the Dart project authors. Please see the AUTHORS file
25 // for details. All rights reserved. Use of this source code is governed by a
26 // BSD-style license that can be found in the LICENSE file.
27
28 // -----------------------------------------------------------------
29 // Keyword definitions.
30 // -----------------------------------------------------------------
31 BREAK() => ref(token, 'break');
32 CASE() => ref(token, 'case');
33 CATCH() => ref(token, 'catch');
34 CONST() => ref(token, 'const');
35 CONTINUE() => ref(token, 'continue');
36 DEFAULT() => ref(token, 'default');
37 DO() => ref(token, 'do');
38 ELSE() => ref(token, 'else');
39 FALSE() => ref(token, 'false');
40 FINAL() => ref(token, 'final');
41 FINALLY() => ref(token, 'finally');
42 FOR() => ref(token, 'for');
43 IF() => ref(token, 'if');
44 IN() => ref(token, 'in');
45 NEW() => ref(token, 'new');
46 NULL() => ref(token, 'null');
47 RETURN() => ref(token, 'return');
48 SUPER() => ref(token, 'super');
49 SWITCH() => ref(token, 'switch');
50 THIS() => ref(token, 'this');
51 THROW() => ref(token, 'throw');
52 TRUE() => ref(token, 'true');
53 TRY() => ref(token, 'try');
54 VAR() => ref(token, 'var');
55 VOID() => ref(token, 'void');
56 WHILE() => ref(token, 'while');
57
58 // Pseudo-keywords that should also be valid identifiers.
59 ABSTRACT() => ref(token, 'abstract');
60 ASSERT() => ref(token, 'assert');
61 CLASS() => ref(token, 'class');
62 EXTENDS() => ref(token, 'extends');
63 FACTORY() => ref(token, 'factory');
64 GET() => ref(token, 'get');
65 IMPLEMENTS() => ref(token, 'implements');
66 IMPORT() => ref(token, 'import');
67 INTERFACE() => ref(token, 'interface');
68 IS() => ref(token, 'is');
69 LIBRARY() => ref(token, 'library');
70 NATIVE() => ref(token, 'native');
71 NEGATE() => ref(token, 'negate');
72 OPERATOR() => ref(token, 'operator');
73 SET() => ref(token, 'set');
74 SOURCE() => ref(token, 'source');
75 STATIC() => ref(token, 'static');
76 TYPEDEF() => ref(token, 'typedef');
77
78 // -----------------------------------------------------------------
79 // Grammar productions.
80 // -----------------------------------------------------------------
81 start() => ref(compilationUnit).end();
82
83 compilationUnit() =>
84 ref(HASHBANG).optional()
85 & ref(directive).star()
86 & ref(topLevelDefinition).star();
87
88 directive() =>
89 ref(token, '#')
90 & ref(identifier)
91 & ref(arguments)
92 & ref(token, ';');
93
94 topLevelDefinition() =>
95 ref(classDefinition)
96 | ref(interfaceDefinition)
97 | ref(functionTypeAlias)
98 | ref(functionDeclaration) & ref(functionBodyOrNative)
99 | ref(returnType).optional() & ref(getOrSet) & ref(identifier) & ref(forma lParameterList) & ref(functionBodyOrNative)
100 | ref(FINAL) & ref(type).optional() & ref(staticFinalDeclarationList) & re f(token, ';')
101 | ref(constInitializedVariableDeclaration) & ref(token, ';');
102
103 classDefinition() =>
104 ref(CLASS) & ref(identifier) & ref(typeParameters).optional() & ref(supe rclass).optional() & ref(interfaces).optional() &
105 ref(token, '{') & ref(classMemberDefinition).star() & ref(token, '}')
106 | ref(CLASS) & ref(identifier) & ref(typeParameters).optional() & ref(inte rfaces).optional() & ref(NATIVE) & ref(token, STRING) &
107 ref(token, '{') & ref(classMemberDefinition).star() & ref(token, '}');
108
109 typeParameter() => ref(identifier) & (ref(EXTENDS) & ref(type)).optional();
110
111 typeParameters() => ref(token, '<') & ref(typeParameter) & (ref(token, ',') & ref(typeParameter)).star() & ref(token, '>');
112
113 superclass() => ref(EXTENDS) & ref(type);
114
115 interfaces() => ref(IMPLEMENTS) & ref(typeList);
116
117 superinterfaces() => ref(EXTENDS) & ref(typeList);
118
119 // This rule is organized in a way that may not be most readable, but
120 // gives the best error messages.
121 classMemberDefinition() =>
122 ref(declaration) & ref(token, ';')
123 | ref(constructorDeclaration) & ref(token, ';')
124 | ref(methodDeclaration) & ref(functionBodyOrNative)
125 | ref(CONST) & ref(factoryConstructorDeclaration) & ref(functionNative);
126
127 functionBodyOrNative() =>
128 ref(NATIVE) & ref(functionBody)
129 | ref(functionNative)
130 | ref(functionBody);
131
132 functionNative() => ref(NATIVE) & ref(token, STRING).optional() & ref(token, ' ;');
133
134 // A method, operator, or constructor (which all should be followed by
135 // a block of code).
136 methodDeclaration() =>
137 ref(factoryConstructorDeclaration)
138 | ref(STATIC) & ref(functionDeclaration)
139 | ref(specialSignatureDefinition)
140 | ref(functionDeclaration) & ref(initializers).optional()
141 | ref(namedConstructorDeclaration) & ref(initializers).optional();
142
143 // An abstract method/operator, a field, or const constructor (which
144 // all should be followed by a semicolon).
145 declaration() =>
146 ref(constantConstructorDeclaration) & (ref(redirection) | ref(initialize rs)).optional()
147 | ref(functionDeclaration) & ref(redirection)
148 | ref(namedConstructorDeclaration) & ref(redirection)
149 | ref(ABSTRACT) & ref(specialSignatureDefinition)
150 | ref(ABSTRACT) & ref(functionDeclaration)
151 | ref(STATIC) & ref(FINAL) & ref(type).optional() & ref(staticFinalDeclara tionList)
152 | ref(STATIC).optional() & ref(constInitializedVariableDeclaration);
153
154 initializers() => ref(token, ':') & ref(superCallOrFieldInitializer) & (ref(to ken, ',') & ref(superCallOrFieldInitializer)).star();
155
156 redirection() => ref(token, ':') & ref(THIS) & (ref(token, '.') & ref(identifi er)).optional() & ref(arguments);
157
158 fieldInitializer() => (ref(THIS) & ref(token, '.')).optional() & ref(identifie r) & ref(token, '=') & ref(conditionalExpression);
159
160 superCallOrFieldInitializer() =>
161 ref(SUPER) & ref(arguments)
162 | ref(SUPER) & ref(token, '.') & ref(identifier) & ref(arguments)
163 | ref(fieldInitializer);
164
165 staticFinalDeclarationList() => ref(staticFinalDeclaration) & (ref(token, ',') & ref(staticFinalDeclaration)).star();
166
167 staticFinalDeclaration() => ref(identifier) & ref(token, '=') & ref(constantEx pression);
168
169 interfaceDefinition() => ref(INTERFACE) & ref(identifier) & ref(typeParameters ).optional() &
170 ref(superinterfaces).optional() & ref(factorySpecification).optional() & r ef(token, '{') &
171 ref(interfaceMemberDefinition).star() & ref(token, '}');
172
173 factorySpecification() => ref(FACTORY) & ref(type);
174
175 functionTypeAlias() => ref(TYPEDEF) & ref(functionPrefix) & ref(typeParameters ).optional() &
176 ref(formalParameterList) & ref(token, ';');
177
178 interfaceMemberDefinition() =>
179 ref(STATIC) & ref(FINAL) & ref(type).optional() & ref(initializedIdentif ierList) & ref(token, ';')
180 | ref(functionDeclaration) & ref(token, ';')
181 | ref(constantConstructorDeclaration) & ref(token, ';')
182 | ref(namedConstructorDeclaration) & ref(token, ';')
183 | ref(specialSignatureDefinition) & ref(token, ';')
184 | ref(variableDeclaration) & ref(token, ';');
185
186 factoryConstructorDeclaration() => ref(FACTORY) & ref(qualified) & ref(typePar ameters).optional() &
187 (ref(token, '.') & ref(identifier)).optional() & ref(formalParameterList);
188
189 namedConstructorDeclaration() => ref(identifier) & ref(token, '.') & ref(ident ifier) &
190 ref(formalParameterList);
191
192 constructorDeclaration() =>
193 ref(identifier) & ref(formalParameterList) & (ref(redirection) | ref(ini tializers)).optional()
194 | ref(namedConstructorDeclaration) & (ref(redirection) | ref(initializers) ).optional();
195
196 constantConstructorDeclaration() => ref(CONST) & ref(qualified) & ref(formalPa rameterList);
197
198 specialSignatureDefinition() =>
199 ref(STATIC).optional() & ref(returnType).optional() & ref(getOrSet) & re f(identifier) & ref(formalParameterList)
200 | ref(returnType).optional() & ref(OPERATOR) & ref(userDefinableOperator) & ref(formalParameterList);
201
202 getOrSet() => ref(GET) | ref(SET);
203
204 userDefinableOperator() =>
205 ref(multiplicativeOperator)
206 | ref(additiveOperator)
207 | ref(shiftOperator)
208 | ref(relationalOperator)
209 | ref(bitwiseOperator)
210 | ref(token, '==') // Disallow negative and === equality checks.
211 | ref(token, '~') // Disallow ! operator.
212 | ref(NEGATE)
213 | ref(token, '[') & ref(token, ']')
214 | ref(token, '[') & ref(token, ']') & ref(token, '=');
215
216 prefixOperator() =>
217 ref(additiveOperator)
218 | ref(negateOperator);
219
220 postfixOperator() =>
221 ref(incrementOperator);
222
223 negateOperator() =>
224 ref(token, '!')
225 | ref(token, '~');
226
227 multiplicativeOperator() =>
228 ref(token, '*')
229 | ref(token, '/')
230 | ref(token, '%')
231 | ref(token, '~/');
232
233 assignmentOperator() =>
234 ref(token, '=')
235 | ref(token, '*=')
236 | ref(token, '/=')
237 | ref(token, '~/=')
238 | ref(token, '%=')
239 | ref(token, '+=')
240 | ref(token, '-=')
241 | ref(token, '<<=')
242 | ref(token, '>>>=')
243 | ref(token, '>>=')
244 | ref(token, '&=')
245 | ref(token, '^=')
246 | ref(token, '|=');
247
248 additiveOperator() =>
249 ref(token, '+')
250 | ref(token, '-');
251
252 incrementOperator() =>
253 ref(token, '++')
254 | ref(token, '--');
255
256 shiftOperator() =>
257 ref(token, '<<')
258 | ref(token, '>>>')
259 | ref(token, '>>');
260
261 relationalOperator() =>
262 ref(token, '>=')
263 | ref(token, '>')
264 | ref(token, '<=')
265 | ref(token, '<');
266
267 equalityOperator() =>
268 ref(token, '===')
269 | ref(token, '!==')
270 | ref(token, '==')
271 | ref(token, '!=');
272
273 bitwiseOperator() =>
274 ref(token, '&')
275 | ref(token, '^')
276 | ref(token, '|');
277
278 formalParameterList() =>
279 ref(token, '(') & ref(namedFormalParameters).optional() & ref(token, ')' )
280 | ref(token, '(') & ref(normalFormalParameter) & ref(normalFormalParameter Tail).optional() & ref(token, ')');
281
282 normalFormalParameterTail() =>
283 ref(token, ',') & ref(namedFormalParameters)
284 | ref(token, ',') & ref(normalFormalParameter) & ref(normalFormalParameter Tail).optional();
285
286 normalFormalParameter() =>
287 ref(functionDeclaration)
288 | ref(fieldFormalParameter)
289 | ref(simpleFormalParameter);
290
291 simpleFormalParameter() =>
292 ref(declaredIdentifier)
293 | ref(identifier);
294
295 fieldFormalParameter() =>
296 ref(finalVarOrType).optional() & ref(THIS) & ref(token, '.') & ref(ident ifier);
297
298 namedFormalParameters() =>
299 ref(token, '[') & ref(defaultFormalParameter) & (ref(token, ',') & ref(d efaultFormalParameter)).star() & ref(token, ']');
300
301 defaultFormalParameter() =>
302 ref(normalFormalParameter) & (ref(token, '=') & ref(constantExpression)) .optional();
303
304 returnType() =>
305 ref(VOID)
306 | ref(type);
307
308 finalVarOrType() =>
309 ref(FINAL) & ref(type).optional()
310 | ref(VAR)
311 | ref(type)
312 ;
313
314 // We have to introduce a separate rule for 'declared' identifiers to
315 // allow ANTLR to decide if the first identifier we encounter after
316 // final is a type or an identifier. Before this change, we used the
317 // production 'finalVarOrType identifier' in numerous places.
318 declaredIdentifier() =>
319 ref(FINAL) & ref(type).optional() & ref(identifier)
320 | ref(VAR) & ref(identifier)
321 | ref(type) & ref(identifier)
322 ;
323
324 identifier() => ref(token, ref(IDENTIFIER));
325
326 qualified() =>
327 ref(identifier) & (ref(token, '.') & ref(identifier)).optional()
328 ;
329
330 type() =>
331 ref(qualified) & ref(typeArguments).optional()
332 ;
333
334 typeArguments() =>
335 ref(token, '<') & ref(typeList) & ref(token, '>')
336 ;
337
338 typeList() =>
339 ref(type) & (ref(token, ',') & ref(type)).star()
340 ;
341
342 block() =>
343 ref(token, '{') & ref(statements) & ref(token, '}')
344 ;
345
346 statements() =>
347 ref(statement).star()
348 ;
349
350 statement() =>
351 ref(label).star() & ref(nonLabelledStatement)
352 ;
353
354 nonLabelledStatement() =>
355 ref(block)
356 | ref(initializedVariableDeclaration) & ref(token, ';')
357 | ref(iterationStatement)
358 | ref(selectionStatement)
359 | ref(tryStatement)
360 | ref(BREAK) & ref(identifier).optional() & ref(token, ';')
361 | ref(CONTINUE) & ref(identifier).optional() & ref(token, ';')
362 | ref(RETURN) & ref(expression).optional() & ref(token, ';')
363 | ref(THROW) & ref(expression).optional() & ref(token, ';')
364 | ref(expression).optional() & ref(token, ';')
365 | ref(ASSERT) & ref(token, '(') & ref(conditionalExpression) & ref(token, ')') & ref(token, ';')
366 | ref(functionDeclaration) & ref(functionBody)
367 ;
368
369 label() =>
370 ref(identifier) & ref(token, ':')
371 ;
372
373 iterationStatement() =>
374 ref(WHILE) & ref(token, '(') & ref(expression) & ref(token, ')') & ref(s tatement)
375 | ref(DO) & ref(statement) & ref(WHILE) & ref(token, '(') & ref(expression ) & ref(token, ')') & ref(token, ';')
376 | ref(FOR) & ref(token, '(') & ref(forLoopParts) & ref(token, ')') & ref(s tatement)
377 ;
378
379 forLoopParts() =>
380 ref(forInitializerStatement) & ref(expression).optional() & ref(token, ' ;') & ref(expressionList).optional()
381 | ref(declaredIdentifier) & ref(IN) & ref(expression)
382 | ref(identifier) & ref(IN) & ref(expression)
383 ;
384
385 forInitializerStatement() =>
386 ref(initializedVariableDeclaration) & ref(token, ';')
387 | ref(expression).optional() & ref(token, ';')
388 ;
389
390 selectionStatement() =>
391 ref(IF) & ref(token, '(') & ref(expression) & ref(token, ')') & ref(stat ement) & (ref(ELSE) & ref(statement)).optional()
392 | ref(SWITCH) & ref(token, '(') & ref(expression) & ref(token, ')') & ref( token, '{') & ref(switchCase).star() & ref(defaultCase).optional() & ref(token, '}')
393 ;
394
395 switchCase() =>
396 ref(label).optional() & (ref(CASE) & ref(expression) & ref(token, ':')). plus() & ref(statements)
397 ;
398
399 defaultCase() =>
400 ref(label).optional() & (ref(CASE) & ref(expression) & ref(token, ':')). star() & ref(DEFAULT) & ref(token, ':') & ref(statements)
401 ;
402
403 tryStatement() =>
404 ref(TRY) & ref(block) & (ref(catchPart).plus() & ref(finallyPart).option al() | ref(finallyPart))
405 ;
406
407 catchPart() =>
408 ref(CATCH) & ref(token, '(') & ref(declaredIdentifier) & (ref(token, ',' ) & ref(declaredIdentifier)).optional() & ref(token, ')') & ref(block)
409 ;
410
411 finallyPart() =>
412 ref(FINALLY) & ref(block)
413 ;
414
415 variableDeclaration() =>
416 ref(declaredIdentifier) & (ref(token, ',') & ref(identifier)).star()
417 ;
418
419 initializedVariableDeclaration() =>
420 ref(declaredIdentifier) & (ref(token, '=') & ref(expression)).optional() & (ref(token, ',') & ref(initializedIdentifier)).star()
421 ;
422
423 initializedIdentifierList() =>
424 ref(initializedIdentifier) & (ref(token, ',') & ref(initializedIdentifie r)).star()
425 ;
426
427 initializedIdentifier() =>
428 ref(identifier) & (ref(token, '=') & ref(expression)).optional()
429 ;
430
431 constInitializedVariableDeclaration() =>
432 ref(declaredIdentifier) & (ref(token, '=') & ref(constantExpression)).op tional() &
433 (ref(token, ',') & ref(constInitializedIdentifier)).star()
434 ;
435
436 constInitializedIdentifier() =>
437 ref(identifier) & (ref(token, '=') & ref(constantExpression)).optional()
438 ;
439
440 // The constant expression production is used to mark certain expressions
441 // as only being allowed to hold a compile-time constant. The grammar cannot
442 // express these restrictions (yet), so this will have to be enforced by a
443 // separate analysis phase.
444 constantExpression() =>
445 ref(expression)
446 ;
447
448 expression() =>
449 ref(assignableExpression) & ref(assignmentOperator) & ref(expression)
450 | ref(conditionalExpression)
451 ;
452
453 expressionList() =>
454 ref(expression) & (ref(token, ',') & ref(expression)).star()
455 ;
456
457 arguments() =>
458 ref(token, '(') & ref(argumentList).optional() & ref(token, ')')
459 ;
460
461 argumentList() =>
462 ref(namedArgument) & (ref(token, ',') & ref(namedArgument)).star()
463 | ref(expressionList) & (ref(token, ',') & ref(namedArgument)).star()
464 ;
465
466 namedArgument() =>
467 ref(label) & ref(expression)
468 ;
469
470 assignableExpression() =>
471 ref(primary) & (ref(arguments).star() & ref(assignableSelector)).plus()
472 | ref(SUPER) & ref(assignableSelector)
473 | ref(identifier)
474 ;
475
476 conditionalExpression() =>
477 ref(logicalOrExpression) & (ref(token, '?') & ref(expression) & ref(toke n, ':') & ref(expression)).optional()
478 ;
479
480 logicalOrExpression() =>
481 ref(logicalAndExpression) & (ref(token, '||') & ref(logicalAndExpression )).star()
482 ;
483
484 logicalAndExpression() =>
485 ref(bitwiseOrExpression) & (ref(token, '&&') & ref(bitwiseOrExpression)) .star()
486 ;
487
488 bitwiseOrExpression() =>
489 ref(bitwiseXorExpression) & (ref(token, '|') & ref(bitwiseXorExpression) ).star()
490 | ref(SUPER) & (ref(token, '|') & ref(bitwiseXorExpression)).plus()
491 ;
492
493 bitwiseXorExpression() =>
494 ref(bitwiseAndExpression) & (ref(token, '^') & ref(bitwiseAndExpression) ).star()
495 | ref(SUPER) & (ref(token, '^') & ref(bitwiseAndExpression)).plus()
496 ;
497
498 bitwiseAndExpression() =>
499 ref(equalityExpression) & (ref(token, '&') & ref(equalityExpression)).st ar()
500 | ref(SUPER) & (ref(token, '&') & ref(equalityExpression)).plus()
501 ;
502
503 equalityExpression() =>
504 ref(relationalExpression) & (ref(equalityOperator) & ref(relationalExpre ssion)).optional()
505 | ref(SUPER) & ref(equalityOperator) & ref(relationalExpression)
506 ;
507
508 relationalExpression() =>
509 ref(shiftExpression) & (ref(isOperator) & ref(type) | ref(relationalOper ator) & ref(shiftExpression)).optional()
510 | ref(SUPER) & ref(relationalOperator) & ref(shiftExpression)
511 ;
512
513 isOperator() =>
514 ref(IS) & ref(token, '!').optional()
515 ;
516
517 shiftExpression() =>
518 ref(additiveExpression) & (ref(shiftOperator) & ref(additiveExpression)) .star()
519 | ref(SUPER) & (ref(shiftOperator) & ref(additiveExpression)).plus()
520 ;
521
522 additiveExpression() =>
523 ref(multiplicativeExpression) & (ref(additiveOperator) & ref(multiplicat iveExpression)).star()
524 | ref(SUPER) & (ref(additiveOperator) & ref(multiplicativeExpression)).plu s()
525 ;
526
527 multiplicativeExpression() =>
528 ref(unaryExpression) & (ref(multiplicativeOperator) & ref(unaryExpressio n)).star()
529 | ref(SUPER) & (ref(multiplicativeOperator) & ref(unaryExpression)).plus()
530 ;
531
532 unaryExpression() =>
533 ref(postfixExpression)
534 | ref(prefixOperator) & ref(unaryExpression)
535 | ref(negateOperator) & ref(SUPER)
536 | ref(token, '-') & ref(SUPER)
537 | ref(incrementOperator) & ref(assignableExpression)
538 ;
539
540 postfixExpression() =>
541 ref(assignableExpression) & ref(postfixOperator)
542 | ref(primary) & ref(selector).star()
543 ;
544
545 selector() =>
546 ref(assignableSelector)
547 | ref(arguments)
548 ;
549
550 assignableSelector() =>
551 ref(token, '[') & ref(expression) & ref(token, ']')
552 | ref(token, '.') & ref(identifier)
553 ;
554
555 primary() =>
556 ref(primaryNoFE)
557 | ref(primaryFE)
558 ;
559
560 primaryFE() =>
561 ref(functionExpression)
562 | ref(primaryNoFE)
563 ;
564
565 primaryNoFE() =>
566 ref(THIS)
567 | ref(SUPER) & ref(assignableSelector)
568 | ref(literal)
569 | ref(identifier)
570 | ref(CONST).optional() & ref(typeArguments).optional() & ref(compoundLite ral)
571 | (ref(NEW) | ref(CONST)) & ref(type) & (ref(token, '.') & ref(identifier) ).optional() & ref(arguments)
572 | ref(expressionInParentheses)
573 ;
574
575 expressionInParentheses() =>
576 ref(token, '(') & ref(expression) & ref(token, ')')
577 ;
578
579 literal() => ref(token,
580 ref(NULL)
581 | ref(TRUE)
582 | ref(FALSE)
583 | ref(HEX_NUMBER)
584 | ref(NUMBER)
585 | ref(STRING))
586 ;
587
588 compoundLiteral() =>
589 ref(listLiteral)
590 | ref(mapLiteral)
591 ;
592
593 listLiteral() =>
594 ref(token, '[') & (ref(expressionList) & ref(token, ',').optional()).opt ional() & ref(token, ']')
595 ;
596
597 mapLiteral() =>
598 ref(token, '{') & (ref(mapLiteralEntry) & (ref(token, ',') & ref(mapLite ralEntry)).star() & ref(token, ',').optional()).optional() & ref(token, '}')
599 ;
600
601 mapLiteralEntry() =>
602 ref(token, STRING) & ref(token, ':') & ref(expression)
603 ;
604
605 functionExpression() =>
606 (ref(returnType).optional() & ref(identifier)).optional() & ref(formalPa rameterList) & ref(functionExpressionBody)
607 ;
608
609 functionDeclaration() =>
610 ref(returnType).optional() & ref(identifier) & ref(formalParameterList)
611 ;
612
613 functionPrefix() =>
614 ref(returnType).optional() & ref(identifier)
615 ;
616
617 functionBody() =>
618 ref(token, '=>') & ref(expression) & ref(token, ';')
619 | ref(block)
620 ;
621
622 functionExpressionBody() =>
623 ref(token, '=>') & ref(expression)
624 | ref(block)
625 ;
626
627 // -----------------------------------------------------------------
628 // Library files.
629 // -----------------------------------------------------------------
630 libraryUnit() =>
631 ref(libraryDefinition).end()
632 ;
633
634 libraryDefinition() =>
635 ref(LIBRARY) & ref(token, '{') & ref(libraryBody) & ref(token, '}')
636 ;
637
638 libraryBody() =>
639 ref(libraryImport).optional() & ref(librarySource).optional()
640 ;
641
642 libraryImport() =>
643 ref(IMPORT) & ref(token, '=') & ref(token, '[') & ref(importReferences). optional() & ref(token, ']')
644 ;
645
646 importReferences() =>
647 ref(importReference) & (ref(token, ',') & ref(importReference)).star() & ref(token, ',').optional()
648 ;
649
650 importReference() =>
651 (ref(token, IDENTIFIER) & ref(token, ':')).optional() & ref(token, STRIN G)
652 ;
653
654 librarySource() =>
655 ref(SOURCE) & ref(token, '=') & ref(token, '[') & ref(sourceUrls).option al() & ref(token, ']')
656 ;
657
658 sourceUrls() =>
659 ref(token, STRING) & (ref(token, ',') & ref(token, STRING)).star() & ref (token, ',').optional()
660 ;
661
662
663 // -----------------------------------------------------------------
664 // Lexical tokens.
665 // -----------------------------------------------------------------
666 IDENTIFIER_NO_DOLLAR() =>
667 ref(IDENTIFIER_START_NO_DOLLAR) & ref(IDENTIFIER_PART_NO_DOLLAR).star()
668 ;
669
670 IDENTIFIER() =>
671 ref(IDENTIFIER_START) & ref(IDENTIFIER_PART).star()
672 ;
673
674 HEX_NUMBER() =>
675 string('0x') & ref(HEX_DIGIT).plus()
676 | string('0X') & ref(HEX_DIGIT).plus()
677 ;
678
679 NUMBER() =>
680 ref(DIGIT).plus() & ref(NUMBER_OPT_FRACTIONAL_PART) & ref(EXPONENT).opti onal() & ref(NUMBER_OPT_ILLEGAL_END)
681 | char('.') & ref(DIGIT).plus() & ref(EXPONENT).optional() & ref(NUMBER_OP T_ILLEGAL_END)
682 ;
683
684 NUMBER_OPT_FRACTIONAL_PART() =>
685 char('.') & ref(DIGIT).plus()
686 | epsilon()
687 ;
688
689 NUMBER_OPT_ILLEGAL_END() => epsilon();
690 // ref(IDENTIFIER_START).end()
691 // | epsilon()
692 // ;
693
694 HEX_DIGIT() => pattern('0-9a-fA-F');
695
696 IDENTIFIER_START() => ref(IDENTIFIER_START_NO_DOLLAR) | char('\$');
697
698 IDENTIFIER_START_NO_DOLLAR() => ref(LETTER) | char('_');
699
700 IDENTIFIER_PART_NO_DOLLAR() => ref(IDENTIFIER_START_NO_DOLLAR) | ref(DIGIT);
701
702 IDENTIFIER_PART() => ref(IDENTIFIER_START) | ref(DIGIT);
703
704 LETTER() => letter();
705
706 DIGIT() => digit();
707
708 EXPONENT() => pattern('eE') & pattern('+-').optional() & ref(DIGIT).plus();
709
710 STRING() =>
711 char('@').optional() & ref(MULTI_LINE_STRING)
712 | ref(SINGLE_LINE_STRING)
713 ;
714
715 MULTI_LINE_STRING() =>
716 string('"""') & any().starLazy(string('"""')) & string('"""')
717 | string("'''") & any().starLazy(string("'''")) & string("'''")
718 ;
719
720 SINGLE_LINE_STRING() =>
721 char('"') & ref(STRING_CONTENT_DQ).star() & char('"')
722 | char("'") & ref(STRING_CONTENT_SQ).star() & char("'")
723 | string('@"') & pattern('^"\n\r').star() & char('"')
724 | string("@'") & pattern("^'\n\r").star() & char("'")
725 ;
726
727 STRING_CONTENT_DQ() =>
728 pattern('^\\"\n\r')
729 | char('\\') & pattern('\n\r')
730 ;
731
732 STRING_CONTENT_SQ() =>
733 pattern("^\\'\n\r")
734 | char('\\') & pattern('\n\r')
735 ;
736
737 NEWLINE() => pattern('\n\r');
738
739 HASHBANG() => string('#!') & pattern('^\n\r').star() & ref(NEWLINE).optional() ;
740
741
742 // -----------------------------------------------------------------
743 // Whitespace and comments.
744 // -----------------------------------------------------------------
745 HIDDEN() => ref(HIDDEN_STUFF).plus();
746
747 HIDDEN_STUFF() => ref(WHITESPACE)
748 | ref(SINGLE_LINE_COMMENT)
749 | ref(MULTI_LINE_COMMENT)
750 ;
751
752 WHITESPACE() => whitespace();
753
754 SINGLE_LINE_COMMENT() => string('//')
755 & ref(NEWLINE).neg().star()
756 & ref(NEWLINE).optional()
757 ;
758
759 MULTI_LINE_COMMENT() => string('/*')
760 & (ref(MULTI_LINE_COMMENT) | string('*/').neg()).star() & string('*/')
761 ;
762
763 }
OLDNEW
« no previous file with comments | « packages/petitparser/lib/smalltalk.dart ('k') | packages/petitparser/lib/src/debug/continuation.dart » ('j') | no next file with comments »

Powered by Google App Engine
This is Rietveld 408576698