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: | { [] }
A compilation unit is just a sequence of statements.
Executable statements (or parts thereof) form the initialisation
code of the compilation unit.