5.16.3. Compilation Unit

Start data section to src/flx_parse.mly[3 /33 ] Next Prev First Last
   342: semi:
   343:   | SEMI {()}
   344: 
   345: exprx:
   346:   expr expr_terminator { $1,$2 }
   347: 
   348: expr_terminator:
   349:   | SEMI { SEMI $1 }
   350:   | USER_KEYWORD { USER_KEYWORD $1 }
   351:   | VBAR { VBAR $1 }
   352:   | ENDMARKER { ENDMARKER }
   353: 
   354:   | ALL { ALL $1 }
   355:   | ASSERT { ASSERT $1 }
   356:   | AXIOM { AXIOM $1 }
   357:   | BODY { BODY $1 }
   358:   | CALL { CALL $1 }
   359:   | CASE { CASE $1 }
   360:   | CASENO { CASENO $1 }
   361:   | CLASS { CLASS $1 }
   362:   | COMMENT_KEYWORD { COMMENT_KEYWORD $1 }
   363:   | COMPOUND { COMPOUND $1 }
   364:   | CONST { CONST $1 }
   365:   | CCLASS { CCLASS $1 }
   366:   | CSTRUCT { CSTRUCT $1 }
   367:   | CTOR { CTOR $1 }
   368:   | CTYPES { CTYPES $1 }
   369:   | DEF { DEF $1 }
   370:   | DO { DO $1 }
   371:   | DONE { DONE $1 }
   372:   | ELIF { ELIF $1 }
   373:   | ELSE { ELSE $1 }
   374:   | ENDIF { ENDIF $1 }
   375:   | ENDMATCH { ENDMATCH $1 }
   376:   | ENUM { ENUM $1 }
   377:   | EXPECT { EXPECT $1 }
   378:   | EXPORT { EXPORT $1 }
   379:   | FOR { FOR $1 }
   380:   | FORGET { FORGET $1 }
   381:   | FORK { FORK $1 }
   382:   | FUNCTOR { FUNCTOR $1 }
   383:   | FUNCTION { FUNCTION $1 }
   384:   | GOTO { GOTO $1 }
   385:   | HEADER { HEADER $1 }
   386:   | IDENT { IDENT $1 }
   387:   | INCLUDE { INCLUDE $1 }
   388:   | INCOMPLETE { INCOMPLETE $1 }
   389:   | INF { INF $1 }
   390:   | IN { IN $1 }
   391:   | IS { IS $1 }
   392:   | INHERIT { INHERIT $1 }
   393:   | INLINE { INLINE $1 }
   394:   | JUMP { JUMP $1 }
   395:   | LET { LET $1 }
   396:   | LOOP { LOOP $1 }
   397:   | LVAL { LVAL $1 }
   398:   | MACRO { MACRO $1 }
   399:   | MODULE { MODULE $1 }
   400:   | NAN { NAN $1 }
   401:   | NEW { NEW $1 }
   402:   | NOINLINE { NOINLINE $1 }
   403:   | NONTERM { NONTERM $1 }
   404:   | NORETURN { NORETURN $1 }
   405:   | NOT { NOT $1 }
   406:   | OBJECT { OBJECT $1 }
   407:   | OPEN { OPEN $1 }
   408:   | PACKAGE { PACKAGE $1 }
   409:   | POD { POD $1 }
   410:   | PRIVATE { PRIVATE $1 }
   411:   | PROCEDURE { PROCEDURE $1 }
   412:   | PROPERTY { PROPERTY $1 }
   413:   | REDUCE { REDUCE $1 }
   414:   | RENAME { RENAME $1 }
   415:   | REQUIRES { REQUIRES $1 }
   416:   | RETURN { RETURN $1 }
   417:   | STRUCT { STRUCT $1 }
   418:   | THEN { THEN $1 }
   419:   | TODO { TODO $1 }
   420:   | TO { TO $1 }
   421:   | TYPEDEF { TYPEDEF $1 }
   422:   | TYPE { TYPE $1 }
   423:   | UNION { UNION $1 }
   424:   | USE { USE $1 }
   425:   | VAL { VAL $1 }
   426:   | VAR { VAR $1 }
   427:   | WHEN { WHEN $1 }
   428:   | WITH { WITH $1 }
   429:   | UNDERSCORE { UNDERSCORE $1 }
   430:   | GC_POINTER { GC_POINTER $1 }
   431:   | GC_TYPE { GC_TYPE $1 }
   432:   | SVC { SVC $1 }
   433:   | DEREF { DEREF $1 }
   434: statementsx:
   435:   | statement_aster statements_terminator { $1, $2 }
   436: 
   437: statements_terminator:
   438:   | DONE { DONE $1 }
   439:   | USER_KEYWORD { USER_KEYWORD $1 }
   440:   | ENDMARKER { ENDMARKER }
   441: 
   442: compilation_unit:
   443:   | statement_aster ENDMARKER { $1 }
   444: 
   445: expression:
   446:   | expr ENDMARKER { $1 }
   447: 
   448: statement_aster:
   449:   | statement statement_aster { $1 :: $2 }
   450:   | { [] }
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.