This is the context-free grammar for Emboss.  Terminal symbols are in `"quotes"`
or are named in `CamelCase`; nonterminal symbols are named in `snake_case`.  The
term `<empty>` to the right of the `->` indicates an empty production (a rule
where the left-hand-side may be parsed from an empty string).

This listing is auto-generated from the grammar defined in `module_ir.py`.

Note that, unlike in many languages, comments are included in the grammar.  This
is so that comments can be handled more easily by the autoformatter; comments
are ignored by the compiler.  This is distinct from *documentation*, which is
included in the IR for use by documentation generators.

```shell
module                                 -> comment-line* doc-line* import-line*
                                          attribute-line* type-definition*
type-definition                        -> bits
                                        | enum
                                        | external
                                        | struct
struct                                 -> "struct" type-name
                                          delimited-parameter-definition-list?
                                          ":" Comment? eol struct-body
struct-body                            -> Indent doc-line* attribute-line*
                                          type-definition* struct-field-block
                                          Dedent
struct-field-block                     -> <empty>
                                        | conditional-struct-field-block
                                          struct-field-block
                                        | unconditional-struct-field
                                          struct-field-block
unconditional-struct-field             -> anonymous-bits-field-definition
                                        | field
                                        | inline-bits-field-definition
                                        | inline-enum-field-definition
                                        | inline-struct-field-definition
                                        | virtual-field
virtual-field                          -> "let" snake-name "=" expression
                                          Comment? eol field-body?
field-body                             -> Indent doc-line* attribute-line* Dedent
expression                             -> choice-expression
choice-expression                      -> logical-expression
                                        | logical-expression "?"
                                          logical-expression ":"
                                          logical-expression
logical-expression                     -> and-expression
                                        | comparison-expression
                                        | or-expression
or-expression                          -> comparison-expression
                                          or-expression-right+
or-expression-right                    -> or-operator comparison-expression
or-operator                            -> "||"
comparison-expression                  -> additive-expression
                                        | additive-expression
                                          equality-expression-right+
                                        | additive-expression
                                          greater-expression-right-list
                                        | additive-expression inequality-operator
                                          additive-expression
                                        | additive-expression
                                          less-expression-right-list
less-expression-right-list             -> equality-expression-right*
                                          less-expression-right
                                          equality-or-less-expression-right*
equality-or-less-expression-right      -> equality-expression-right
                                        | less-expression-right
less-expression-right                  -> less-operator additive-expression
less-operator                          -> "<"
                                        | "<="
inequality-operator                    -> "!="
greater-expression-right-list          -> equality-expression-right*
                                          greater-expression-right
                                          equality-or-greater-expression-right*
equality-or-greater-expression-right   -> equality-expression-right
                                        | greater-expression-right
greater-expression-right               -> greater-operator additive-expression
greater-operator                       -> ">"
                                        | ">="
equality-expression-right              -> equality-operator additive-expression
equality-operator                      -> "=="
additive-expression                    -> times-expression
                                          additive-expression-right*
additive-expression-right              -> additive-operator times-expression
additive-operator                      -> "+"
                                        | "-"
times-expression                       -> negation-expression
                                          times-expression-right*
times-expression-right                 -> multiplicative-operator
                                          negation-expression
multiplicative-operator                -> "*"
negation-expression                    -> additive-operator bottom-expression
                                        | bottom-expression
bottom-expression                      -> "(" expression ")"
                                        | boolean-constant
                                        | builtin-reference
                                        | constant-reference
                                        | field-reference
                                        | function-name "(" argument-list ")"
                                        | numeric-constant
numeric-constant                       -> Number
argument-list                          -> <empty>
                                        | expression comma-then-expression*
comma-then-expression                  -> "," expression
function-name                          -> "$lower_bound"
                                        | "$max"
                                        | "$present"
                                        | "$upper_bound"
field-reference                        -> snake-reference field-reference-tail*
field-reference-tail                   -> "." snake-reference
snake-reference                        -> builtin-field-word
                                        | snake-word
snake-word                             -> SnakeWord
builtin-field-word                     -> "$max_size_in_bits"
                                        | "$max_size_in_bytes"
                                        | "$min_size_in_bits"
                                        | "$min_size_in_bytes"
                                        | "$size_in_bits"
                                        | "$size_in_bytes"
constant-reference                     -> constant-reference-tail
                                        | snake-reference "."
                                          constant-reference-tail
constant-reference-tail                -> constant-word
                                        | type-word "." constant-reference-tail
                                        | type-word "." snake-reference
type-word                              -> CamelWord
constant-word                          -> ShoutyWord
builtin-reference                      -> builtin-word
builtin-word                           -> "$is_statically_sized"
                                        | "$next"
                                        | "$static_size_in_bits"
boolean-constant                       -> BooleanConstant
and-expression                         -> comparison-expression
                                          and-expression-right+
and-expression-right                   -> and-operator comparison-expression
and-operator                           -> "&&"
snake-name                             -> snake-word
inline-struct-field-definition         -> field-location "struct" snake-name
                                          abbreviation? ":" Comment? eol
                                          struct-body
abbreviation                           -> "(" snake-word ")"
field-location                         -> expression "[" "+" expression "]"
inline-enum-field-definition           -> field-location "enum" snake-name
                                          abbreviation? ":" Comment? eol
                                          enum-body
enum-body                              -> Indent doc-line* attribute-line*
                                          enum-value+ Dedent
enum-value                             -> constant-name "=" expression attribute*
                                          doc? Comment? eol enum-value-body?
enum-value-body                        -> Indent doc-line* attribute-line* Dedent
doc                                    -> Documentation
attribute                              -> "[" attribute-context? "$default"?
                                          snake-word ":" attribute-value "]"
attribute-value                        -> expression
                                        | string-constant
string-constant                        -> String
attribute-context                      -> "(" snake-word ")"
constant-name                          -> constant-word
inline-bits-field-definition           -> field-location "bits" snake-name
                                          abbreviation? ":" Comment? eol
                                          bits-body
bits-body                              -> Indent doc-line* attribute-line*
                                          type-definition* bits-field-block
                                          Dedent
bits-field-block                       -> <empty>
                                        | conditional-bits-field-block
                                          bits-field-block
                                        | unconditional-bits-field
                                          bits-field-block
unconditional-bits-field               -> unconditional-anonymous-bits-field
                                        | virtual-field
unconditional-anonymous-bits-field     -> field
                                        | inline-bits-field-definition
                                        | inline-enum-field-definition
conditional-bits-field-block           -> "if" expression ":" Comment? eol Indent
                                          unconditional-bits-field+ Dedent
field                                  -> field-location type snake-name
                                          abbreviation? attribute* doc? Comment?
                                          eol field-body?
type                                   -> type-reference delimited-argument-list?
                                          type-size-specifier?
                                          array-length-specifier*
array-length-specifier                 -> "[" "]"
                                        | "[" expression "]"
type-size-specifier                    -> ":" numeric-constant
delimited-argument-list                -> "(" argument-list ")"
type-reference                         -> snake-word "." type-reference-tail
                                        | type-reference-tail
type-reference-tail                    -> type-word
                                        | type-word "." type-reference-tail
anonymous-bits-field-definition        -> field-location "bits" ":" Comment? eol
                                          anonymous-bits-body
anonymous-bits-body                    -> Indent attribute-line*
                                          anonymous-bits-field-block Dedent
anonymous-bits-field-block             -> <empty>
                                        | conditional-anonymous-bits-field-block
                                          anonymous-bits-field-block
                                        | unconditional-anonymous-bits-field
                                          anonymous-bits-field-block
conditional-anonymous-bits-field-block -> "if" expression ":" Comment? eol Indent
                                          unconditional-anonymous-bits-field+
                                          Dedent
conditional-struct-field-block         -> "if" expression ":" Comment? eol Indent
                                          unconditional-struct-field+ Dedent
eol                                    -> "\n" comment-line*
delimited-parameter-definition-list    -> "(" parameter-definition-list ")"
parameter-definition-list              -> <empty>
                                        | parameter-definition
                                          parameter-definition-list-tail*
parameter-definition-list-tail         -> "," parameter-definition
parameter-definition                   -> snake-name ":" type
type-name                              -> type-word
external                               -> "external" type-name ":" Comment? eol
                                          external-body
external-body                          -> Indent doc-line* attribute-line* Dedent
enum                                   -> "enum" type-name ":" Comment? eol
                                          enum-body
bits                                   -> "bits" type-name
                                          delimited-parameter-definition-list?
                                          ":" Comment? eol bits-body
attribute-line                         -> attribute Comment? eol
import-line                            -> "import" string-constant "as"
                                          snake-word Comment? eol
doc-line                               -> doc Comment? eol
comment-line                           -> Comment? "\n"
```

The following productions are automatically generated to handle zero-or-more,
one-or-more, and zero-or-one repeated lists (`foo*`, `foo+`, and `foo?`
nonterminals) in LR(1).  They are included for completeness, but may be ignored
if you just want to understand the grammar.

```shell
"$default"?                           -> <empty>
                                       | "$default"
Comment?                              -> <empty>
                                       | Comment
abbreviation?                         -> <empty>
                                       | abbreviation
additive-expression-right*            -> <empty>
                                       | additive-expression-right
                                         additive-expression-right*
and-expression-right*                 -> <empty>
                                       | and-expression-right
                                         and-expression-right*
and-expression-right+                 -> and-expression-right
                                         and-expression-right*
array-length-specifier*               -> <empty>
                                       | array-length-specifier
                                         array-length-specifier*
attribute*                            -> <empty>
                                       | attribute attribute*
attribute-context?                    -> <empty>
                                       | attribute-context
attribute-line*                       -> <empty>
                                       | attribute-line attribute-line*
comma-then-expression*                -> <empty>
                                       | comma-then-expression
                                         comma-then-expression*
comment-line*                         -> <empty>
                                       | comment-line comment-line*
delimited-argument-list?              -> <empty>
                                       | delimited-argument-list
delimited-parameter-definition-list?  -> <empty>
                                       | delimited-parameter-definition-list
doc-line*                             -> <empty>
                                       | doc-line doc-line*
doc?                                  -> <empty>
                                       | doc
enum-value*                           -> <empty>
                                       | enum-value enum-value*
enum-value+                           -> enum-value enum-value*
enum-value-body?                      -> <empty>
                                       | enum-value-body
equality-expression-right*            -> <empty>
                                       | equality-expression-right
                                         equality-expression-right*
equality-expression-right+            -> equality-expression-right
                                         equality-expression-right*
equality-or-greater-expression-right* -> <empty>
                                       | equality-or-greater-expression-right
                                         equality-or-greater-expression-right*
equality-or-less-expression-right*    -> <empty>
                                       | equality-or-less-expression-right
                                         equality-or-less-expression-right*
field-body?                           -> <empty>
                                       | field-body
field-reference-tail*                 -> <empty>
                                       | field-reference-tail
                                         field-reference-tail*
import-line*                          -> <empty>
                                       | import-line import-line*
or-expression-right*                  -> <empty>
                                       | or-expression-right or-expression-right*
or-expression-right+                  -> or-expression-right or-expression-right*
parameter-definition-list-tail*       -> <empty>
                                       | parameter-definition-list-tail
                                         parameter-definition-list-tail*
times-expression-right*               -> <empty>
                                       | times-expression-right
                                         times-expression-right*
type-definition*                      -> <empty>
                                       | type-definition type-definition*
type-size-specifier?                  -> <empty>
                                       | type-size-specifier
unconditional-anonymous-bits-field*   -> <empty>
                                       | unconditional-anonymous-bits-field
                                         unconditional-anonymous-bits-field*
unconditional-anonymous-bits-field+   -> unconditional-anonymous-bits-field
                                         unconditional-anonymous-bits-field*
unconditional-bits-field*             -> <empty>
                                       | unconditional-bits-field
                                         unconditional-bits-field*
unconditional-bits-field+             -> unconditional-bits-field
                                         unconditional-bits-field*
unconditional-struct-field*           -> <empty>
                                       | unconditional-struct-field
                                         unconditional-struct-field*
unconditional-struct-field+           -> unconditional-struct-field
                                         unconditional-struct-field*
```

The following regexes are used to tokenize input into the corresponding symbols.
Note that the `Indent`, `Dedent`, and `EndOfLine` symbols are generated using
separate logic.

Pattern                                    | Symbol
------------------------------------------ | ------------------------------
`\[`                                       | `"["`
`\]`                                       | `"]"`
`\(`                                       | `"("`
`\)`                                       | `")"`
`\:`                                       | `":"`
`\=`                                       | `"="`
`\+`                                       | `"+"`
`\-`                                       | `"-"`
`\*`                                       | `"*"`
`\.`                                       | `"."`
`\?`                                       | `"?"`
`\=\=`                                     | `"=="`
`\!\=`                                     | `"!="`
`\&\&`                                     | `"&&"`
`\|\|`                                     | `"||"`
`\<`                                       | `"<"`
`\>`                                       | `">"`
`\<\=`                                     | `"<="`
`\>\=`                                     | `">="`
`\,`                                       | `","`
`\$static_size_in_bits`                    | `"$static_size_in_bits"`
`\$is_statically_sized`                    | `"$is_statically_sized"`
`\$max`                                    | `"$max"`
`\$present`                                | `"$present"`
`\$upper_bound`                            | `"$upper_bound"`
`\$lower_bound`                            | `"$lower_bound"`
`\$next`                                   | `"$next"`
`\$size_in_bits`                           | `"$size_in_bits"`
`\$size_in_bytes`                          | `"$size_in_bytes"`
`\$max_size_in_bits`                       | `"$max_size_in_bits"`
`\$max_size_in_bytes`                      | `"$max_size_in_bytes"`
`\$min_size_in_bits`                       | `"$min_size_in_bits"`
`\$min_size_in_bytes`                      | `"$min_size_in_bytes"`
`\$default`                                | `"$default"`
`struct`                                   | `"struct"`
`bits`                                     | `"bits"`
`enum`                                     | `"enum"`
`external`                                 | `"external"`
`import`                                   | `"import"`
`as`                                       | `"as"`
`if`                                       | `"if"`
`let`                                      | `"let"`
`EmbossReserved[A-Za-z0-9]*`               | `BadWord`
`emboss_reserved[_a-z0-9]*`                | `BadWord`
`EMBOSS_RESERVED[_A-Z0-9]*`                | `BadWord`
`"(?:[^"\n\\]\|\\[n\\"])*"`                | `String`
`[0-9]+`                                   | `Number`
`[0-9]{1,3}(?:_[0-9]{3})*`                 | `Number`
`0x[0-9a-fA-F]+`                           | `Number`
`0x_?[0-9a-fA-F]{1,4}(?:_[0-9a-fA-F]{4})*` | `Number`
`0x_?[0-9a-fA-F]{1,8}(?:_[0-9a-fA-F]{8})*` | `Number`
`0b[01]+`                                  | `Number`
`0b_?[01]{1,4}(?:_[01]{4})*`               | `Number`
`0b_?[01]{1,8}(?:_[01]{8})*`               | `Number`
`true\|false`                              | `BooleanConstant`
`[a-z][a-z_0-9]*`                          | `SnakeWord`
`[A-Z][A-Z_0-9]*[A-Z_][A-Z_0-9]*`          | `ShoutyWord`
`[A-Z][a-zA-Z0-9]*[a-z][a-zA-Z0-9]*`       | `CamelWord`
`-- .*`                                    | `Documentation`
`--$`                                      | `Documentation`
`--.*`                                     | `BadDocumentation`
`\s+`                                      | *no symbol emitted*
`#.*`                                      | `Comment`
`[0-9][bxBX]?[0-9a-fA-F_]*`                | `BadNumber`
`[a-zA-Z_$0-9]+`                           | `BadWord`

The following 534 keywords are reserved, but not used, by Emboss.  They may not
be used as field, type, or enum value names.

`ATOMIC_BOOL_LOCK_FREE` `ATOMIC_CHAR16_T_LOCK_FREE` `ATOMIC_CHAR32_T_LOCK_FREE`
`ATOMIC_CHAR_LOCK_FREE` `ATOMIC_FLAG_INIT` `ATOMIC_INT_LOCK_FREE`
`ATOMIC_LLONG_LOCK_FREE` `ATOMIC_LONG_LOCK_FREE` `ATOMIC_POINTER_LOCK_FREE`
`ATOMIC_SHORT_LOCK_FREE` `ATOMIC_VAR_INIT` `ATOMIC_WCHAR_T_LOCK_FREE` `BUFSIZ`
`CGFloat` `CHAR_BIT` `CHAR_MAX` `CHAR_MIN` `CLOCKS_PER_SEC` `CMPLX` `CMPLXF`
`CMPLXL` `DBL_DECIMAL_DIG` `DBL_DIG` `DBL_EPSILON` `DBL_HAS_SUBNORM`
`DBL_MANT_DIG` `DBL_MAX` `DBL_MAX_10_EXP` `DBL_MAX_EXP` `DBL_MIN`
`DBL_MIN_10_EXP` `DBL_MIN_EXP` `DBL_TRUE_MIN` `DECIMAL_DIG` `DOMAIN` `EDOM`
`EILSEQ` `EOF` `ERANGE` `EXIT_FAILURE` `EXIT_SUCCESS` `FE_ALL_EXCEPT`
`FE_DFL_ENV` `FE_DIVBYZERO` `FE_DOWNWARD` `FE_INEXACT` `FE_INVALID`
`FE_OVERFLOW` `FE_TONEAREST` `FE_TOWARDZERO` `FE_UNDERFLOW` `FE_UPWARD`
`FILENAME_MAX` `FLT_DECIMAL_DIG` `FLT_DIG` `FLT_EPSILON` `FLT_EVAL_METHOD`
`FLT_HAS_SUBNORM` `FLT_MANT_DIG` `FLT_MAX` `FLT_MAX_10_EXP` `FLT_MAX_EXP`
`FLT_MIN` `FLT_MIN_10_EXP` `FLT_MIN_EXP` `FLT_RADIX` `FLT_ROUNDS` `FLT_TRUE_MIN`
`FOPEN_MAX` `FP_FAST_FMA` `FP_FAST_FMAF` `FP_FAST_FMAL` `FP_ILOGB0`
`FP_ILOGBNAN` `FP_INFINITE` `FP_NAN` `FP_NORMAL` `FP_SUBNORMAL` `FP_ZERO`
`False` `HUGE_VAL` `HUGE_VALF` `HUGE_VALL` `INFINITY` `INT16_C` `INT16_MAX`
`INT16_MIN` `INT32_C` `INT32_MAX` `INT32_MIN` `INT64_C` `INT64_MAX` `INT64_MIN`
`INT8_C` `INT8_MAX` `INT8_MIN` `INTMAX_C` `INTMAX_MAX` `INTMAX_MIN` `INTPTR_MAX`
`INTPTR_MIN` `INT_FAST16_MAX` `INT_FAST16_MIN` `INT_FAST32_MAX` `INT_FAST32_MIN`
`INT_FAST64_MAX` `INT_FAST64_MIN` `INT_FAST8_MAX` `INT_FAST8_MIN`
`INT_LEAST16_MAX` `INT_LEAST16_MIN` `INT_LEAST32_MAX` `INT_LEAST32_MIN`
`INT_LEAST64_MAX` `INT_LEAST64_MIN` `INT_LEAST8_MAX` `INT_LEAST8_MIN` `INT_MAX`
`INT_MIN` `LC_ALL` `LC_COLLATE` `LC_CTYPE` `LC_MONETARY` `LC_NUMERIC` `LC_TIME`
`LDBL_DECIMAL_DIG` `LDBL_DIG` `LDBL_EPSILON` `LDBL_HAS_SUBNORM` `LDBL_MANT_DIG`
`LDBL_MAX` `LDBL_MAX_10_EXP` `LDBL_MAX_EXP` `LDBL_MIN` `LDBL_MIN_10_EXP`
`LDBL_MIN_EXP` `LDBL_TRUE_MIN` `LLONG_MAX` `LLONG_MIN` `LONG_MAX` `LONG_MIN`
`MATH_ERREXCEPT` `MATH_ERRNO` `MAXFLOAT` `MB_CUR_MAX` `MB_LEN_MAX` `M_1_PI`
`M_2_PI` `M_2_SQRTPI` `M_3PI_4` `M_E` `M_INVLN2` `M_IVLN10` `M_LN10` `M_LN2`
`M_LN2HI` `M_LN2LO` `M_LOG10E` `M_LOG2E` `M_LOG2_E` `M_PI` `M_PI_2` `M_PI_4`
`M_SQRT1_2` `M_SQRT2` `M_SQRT3` `M_SQRTPI` `M_TWOPI` `NAN` `NDEBUG` `NSInteger`
`NSNumber` `NSObject` `NULL` `None` `ONCE_FLAG_INIT` `OVERFLOW` `PLOSS`
`PTRDIFF_MAX` `PTRDIFF_MIN` `RAND_MAX` `SCHAR_MAX` `SCHAR_MIN` `SEEK_CUR`
`SEEK_END` `SEEK_SET` `SHRT_MAX` `SHRT_MIN` `SIGABRT` `SIGFPE` `SIGILL` `SIGINT`
`SIGSEGV` `SIGTERM` `SIG_ATOMIC_MAX` `SIG_ATOMIC_MIN` `SIG_DFL` `SIG_ERR`
`SIG_IGN` `SING` `SIZE_MAX` `Self` `TIME_UTC` `TLOSS` `TMP_MAX` `TMP_MAX_S`
`TSS_DTOR_ITERATIONS` `True` `UCHAR_MAX` `UINT16_C` `UINT16_MAX` `UINT32_C`
`UINT32_MAX` `UINT64_C` `UINT64_MAX` `UINT8_C` `UINT8_MAX` `UINTMAX_C`
`UINTMAX_MAX` `UINTPTR_MAX` `UINT_FAST16_MAX` `UINT_FAST32_MAX`
`UINT_FAST64_MAX` `UINT_FAST8_MAX` `UINT_LEAST16_MAX` `UINT_LEAST32_MAX`
`UINT_LEAST64_MAX` `UINT_LEAST8_MAX` `UINT_MAX` `ULLONG_MAX` `ULONG_MAX`
`UNDERFLOW` `USHRT_MAX` `WCHAR_MAX` `WCHAR_MIN` `WEOF` `WINT_MAX` `WINT_MIN`
`abstract` `acos` `acosh` `after` `alignas` `alignof` `and` `and_eq` `andalso`
`asin` `asinh` `asm` `assert` `atan` `atan2` `atanh`
`atomic_compare_exchange_strong` `atomic_compare_exchange_strong_explicit`
`atomic_compare_exchange_weak` `atomic_compare_exchange_weak_explicit`
`atomic_exchange` `atomic_exchange_explicit` `atomic_fetch_add`
`atomic_fetch_add_explicit` `atomic_fetch_and` `atomic_fetch_and_explicit`
`atomic_fetch_or` `atomic_fetch_or_explicit` `atomic_fetch_sub`
`atomic_fetch_sub_explicit` `atomic_fetch_xor` `atomic_fetch_xor_explicit`
`atomic_init` `atomic_is_lock_free` `atomic_load` `atomic_load_explicit`
`atomic_store` `atomic_store_explicit` `auto` `band` `become` `begin` `bitand`
`bitor` `bnot` `bool` `boolean` `bor` `box` `break` `bsl` `bsr` `bxor` `byte`
`carg` `case` `catch` `cbrt` `ceil` `chan` `char` `char16_t` `char32_t` `cimag`
`class` `classdef` `compl` `complex` `concept` `cond` `conj` `const`
`const_cast` `constexpr` `continue` `copysign` `cos` `cosh` `cproj` `crate`
`creal` `decltype` `def` `default` `defer` `del` `delete` `div` `do` `double`
`dynamic_cast` `elif` `else` `elseif` `end` `erf` `erfc` `errno` `except` `exec`
`exp` `exp2` `explicit` `expm1` `export` `extends` `extern` `fabs` `fallthrough`
`fdim` `final` `finally` `float` `floor` `fma` `fmax` `fmin` `fmod` `fn` `for`
`fortran` `fpclassify` `frexp` `friend` `from` `fun` `func` `function` `global`
`go` `goto` `hypot` `ilogb` `imaginary` `impl` `implementation` `implements`
`in` `inline` `instanceof` `int` `interface` `is` `isfinite` `isgreater`
`isgreaterequal` `isinf` `isless` `islessequal` `islessgreater` `isnan`
`isnormal` `isunordered` `kill_dependency` `lambda` `ldexp` `lgamma` `llrint`
`llround` `log` `log10` `log1p` `log2` `logb` `long` `loop` `lrint` `lround`
`macro` `map` `match` `math_errhandling` `mod` `move` `mut` `mutable`
`namespace` `native` `nearbyint` `new` `nextafter` `nexttoward` `noexcept`
`nonatomic` `nonlocal` `noreturn` `not` `not_eq` `null` `nullptr` `of`
`offsetof` `operator` `or` `or_eq` `orelse` `otherwise` `override` `package`
`parfor` `pass` `persistent` `pow` `print` `priv` `private` `proc` `property`
`protected` `protocol` `pub` `public` `pure` `raise` `range` `readonly`
`readwrite` `receive` `ref` `register` `reinterpret_cast` `rem` `remainder`
`remquo` `requires` `restrict` `retain` `rethrow` `return` `rint` `round`
`scalbln` `scalbn` `select` `self` `setjmp` `short` `signbit` `signed` `sin`
`sinh` `sizeof` `spmd` `sqrt` `static` `static_assert` `static_cast` `stderr`
`stdin` `stdout` `strictfp` `strong` `super` `switch` `synchronized` `tan`
`tanh` `template` `tgamma` `this` `thread_local` `throw` `throws` `trait`
`transient` `trunc` `try` `type` `typedef` `typeid` `typename` `typeof` `union`
`unsafe` `unsafe_unretained` `unsigned` `unsized` `use` `using` `va_arg`
`va_copy` `va_end` `va_start` `var` `virtual` `void` `volatile` `wchar_t` `weak`