375: semi:
376: | SEMI {()}
377:
378: exprx:
379: expr expr_terminator { $1,$2 }
380:
381: expr_terminator:
382: | SEMI { SEMI $1 }
383: | USER_KEYWORD { USER_KEYWORD $1 }
384: | VBAR { VBAR $1 }
385: | ENDMARKER { ENDMARKER }
386:
387: | ALL { ALL $1 }
388: | ASSERT { ASSERT $1 }
389: | AXIOM { AXIOM $1 }
390: | BODY { BODY $1 }
391: | CALL { CALL $1 }
392: | CASE { CASE $1 }
393: | CASENO { CASENO $1 }
394: | CCLASS { CCLASS $1 }
395: | CFUNCTION { CFUNCTION $1 }
396: | CLASS { CLASS $1 }
397: | COMMENT_KEYWORD { COMMENT_KEYWORD $1 }
398: | COMPOUND { COMPOUND $1 }
399: | CONST { CONST $1 }
400: | CPARSE { CPARSE $1 }
401: | CPROCEDURE { CPROCEDURE $1 }
402: | CSTRUCT { CSTRUCT $1 }
403: | CTOR { CTOR $1 }
404: | CTYPES { CTYPES $1 }
405: | DEF { DEF $1 }
406: | DO { DO $1 }
407: | DONE { DONE $1 }
408: | ELIF { ELIF $1 }
409: | ELSE { ELSE $1 }
410: | ENDCASE { ENDCASE $1 }
411: | ENDIF { ENDIF $1 }
412: | ENDMATCH { ENDMATCH $1 }
413: | ENUM { ENUM $1 }
414: | EXPECT { EXPECT $1 }
415: | EXPORT { EXPORT $1 }
416: | FOR { FOR $1 }
417: | FORGET { FORGET $1 }
418: | FORK { FORK $1 }
419: | FUNCTOR { FUNCTOR $1 }
420: | FUNCTION { FUNCTION $1 }
421: | GENERATOR { GENERATOR $1 }
422: | GOTO { GOTO $1 }
423: | HALT { HALT $1 }
424: | HEADER { HEADER $1 }
425: | IDENT { IDENT $1 }
426: | INCLUDE { INCLUDE $1 }
427: | INCOMPLETE { INCOMPLETE $1 }
428: | INF { INF $1 }
429: | IN { IN $1 }
430: | INSTANCE { INSTANCE $1 }
431: | IS { IS $1 }
432: | INHERIT { INHERIT $1 }
433: | INLINE { INLINE $1 }
434: | JUMP { JUMP $1 }
435: | LEMMA { LEMMA $1 }
436: | LET { LET $1 }
437: | LOOP { LOOP $1 }
438: | LVAL { LVAL $1 }
439: | MACRO { MACRO $1 }
440: | MODULE { MODULE $1 }
441: | NAMESPACE { NAMESPACE $1 }
442: | NAN { NAN $1 }
443: | NEW { NEW $1 }
444: | NOINLINE { NOINLINE $1 }
445: | NONTERM { NONTERM $1 }
446: | NORETURN { NORETURN $1 }
447: | NOT { NOT $1 }
448: | OBJECT { OBJECT $1 }
449: | OPEN { OPEN $1 }
450: | PACKAGE { PACKAGE $1 }
451: | POD { POD $1 }
452: | PRIVATE { PRIVATE $1 }
453: | PROCEDURE { PROCEDURE $1 }
454: | PROPERTY { PROPERTY $1 }
455: | REDUCE { REDUCE $1 }
456: | REF { REF $1 }
457: | RENAME { RENAME $1 }
458: | REQUIRES { REQUIRES $1 }
459: | RETURN { RETURN $1 }
460: | STRUCT { STRUCT $1 }
461: | THEN { THEN $1 }
462: | TODO { TODO $1 }
463: | TO { TO $1 }
464: | TYPEDEF { TYPEDEF $1 }
465: | TYPE { TYPE $1 }
466: | TYPECLASS { TYPECLASS $1 }
467: | UNION { UNION $1 }
468: | USE { USE $1 }
469: | VAL { VAL $1 }
470: | VAR { VAR $1 }
471: | VIRTUAL { VIRTUAL $1 }
472: | WHERE { WHERE $1 }
473: | WHEN { WHEN $1 }
474: | WITH { WITH $1 }
475: | YIELD { YIELD $1 }
476: | GC_POINTER { GC_POINTER $1 }
477: | GC_TYPE { GC_TYPE $1 }
478: | SVC { SVC $1 }
479: | DEREF { DEREF $1 }
480: statementsx:
481: | statement_aster statements_terminator { $1, $2 }
482:
483: statements_terminator:
484: | VBAR { VBAR $1 }
485: | DONE { DONE $1 }
486: | USER_KEYWORD { USER_KEYWORD $1 }
487: | ENDMARKER { ENDMARKER }
488:
489: compilation_unit:
490: | statement_aster ENDMARKER { $1 }
491:
492: expression:
493: | expr ENDMARKER { $1 }
494:
495: statement_aster:
496: | statement statement_aster { $1 :: $2 }
497: | { [] }
A compilation unit is just a sequence of statements.
Executable statements (or parts thereof) form the initialisation
code of the compilation unit.