5.16.3. Compilation Unit

Start data section to src/flx_parse.mly[3 /35 ] Next Prev First Last
   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:   | { [] }
End data section to src/flx_parse.mly[3]
A compilation unit is just a sequence of statements. Executable statements (or parts thereof) form the initialisation code of the compilation unit.