B. Grammar

This appendix contains summaries of the lexical and syntactic grammars found in the main document, and of the grammar extensions for unsafe code. Grammar productions appear here in the same order that they appear in the main document.

B.1 Lexical grammar

input:
input-section_opt

input-section:
input-section-part
input-section   input-section-part

input-section-part:
input-elements_opt   new-line
pp-directive

input-elements:
input-element
input-elements   input-element

input-element:
whitespace
comment
token

B.1.1 Line terminators

new-line:
Carriage return character (U+000D)
Line feed character (U+000A)
Carriage return character (U+000D) followed by line feed character (U+000A)
Next line character (U+0085)
Line separator character (U+2028)
Paragraph separator character (U+2029)

B.1.2 White space

whitespace:
Any character with Unicode class Zs
Horizontal tab character (U+0009)
Vertical tab character (U+000B)
Form feed character (U+000C)

B.1.3 Comments

comment:
single-line-comment
delimited-comment

single-line-comment:
//   input-characters_opt

input-characters:
input-character
input-characters   input-character

input-character:
Any Unicode character except a new-line-character

new-line-character:
Carriage return character (U+000D)
Line feed character (U+000A)
Next line character (U+0085)
Line separator character (U+2028)
Paragraph separator character (U+2029)

delimited-comment::
/*   delimited-comment-text_opt   asterisks   /

delimited-comment-text::
delimited-comment-section
delimited-comment-text   delimited-comment-section

delimited-comment-section::
not-asterisk
asterisks   not-slash

asterisks::
*
asterisks   *

not-asterisk:
Any Unicode character except *

not-slash:
Any Unicode character except /

B.1.4 Tokens

token:
identifier
keyword
integer-literal
real-literal
character-literal
string-literal
operator-or-punctuator

B.1.5 Unicode character escape sequences

unicode-escape-sequence:
\u   hex-digit   hex-digit   hex-digit   hex-digit
\U   hex-digit   hex-digit   hex-digit  hex-digit   hex-digit   hex-digit   hex-digit   hex-digit

B.1.6 Identifiers

identifier:
available-identifier
@   identifier-or-keyword

available-identifier:
An identifier-or-keyword that is not a keyword

identifier-or-keyword:
identifier-start-character   identifier-part-characters_opt

identifier-start-character:
letter-character
_ (the underscore character U+005F)

identifier-part-characters:
identifier-part-character
identifier-part-characters   identifier-part-character

identifier-part-character:
letter-character
decimal-digit-character
connecting-character
combining-character
formatting-character

letter-character:
A Unicode character of classes Lu, Ll, Lt, Lm, Lo, or Nl
A unicode-escape-sequence representing a character of classes Lu, Ll, Lt, Lm, Lo, or Nl

combining-character:
A Unicode character of classes Mn or Mc
A unicode-escape-sequence representing a character of classes Mn or Mc

decimal-digit-character:
A Unicode character of the class Nd
A unicode-escape-sequence representing a character of the class Nd

connecting-character: 
A Unicode character of the class Pc
A unicode-escape-sequence representing a character of the class Pc

formatting-character: 
A Unicode character of the class Cf
A unicode-escape-sequence representing a character of the class Cf

B.1.7 Keywords

keyword:  one of
abstract    as          base        bool        break
byte        case        catch       char        checked
class       const       continue    decimal     default
delegate    do          double      else        enum
event       explicit    extern      false       finally
fixed       float       for         foreach     goto
if          implicit    in          int         interface
internal    is          lock        long        namespace
new         null        object      operator    out
override    params      private     protected   public
readonly    ref         return      sbyte       sealed
short       sizeof      stackalloc  static      string
struct      switch      this        throw       true
try         typeof      uint        ulong       unchecked
unsafe      ushort      using       virtual     void
volatile    while

B.1.8 Literals

literal:
boolean-literal
integer-literal
real-literal
character-literal
string-literal
null-literal

boolean-literal:
true
false

integer-literal:
decimal-integer-literal
hexadecimal-integer-literal

decimal-integer-literal:
decimal-digits   integer-type-suffix_opt

decimal-digits:
decimal-digit
decimal-digits   decimal-digit

decimal-digit:  one of
0  1  2  3  4  5  6  7  8  9

integer-type-suffix:  one of
U  u  L  l  UL  Ul  uL  ul  LU  Lu  lU  lu

hexadecimal-integer-literal:
0x   hex-digits   integer-type-suffix_opt
0X   hex-digits   integer-type-suffix_opt

hex-digits:
hex-digit
hex-digits   hex-digit

hex-digit:  one of
0  1  2  3  4  5  6  7  8  9  A  B  C  D  E  F  a  b  c  d  e  f

real-literal:
decimal-digits   .   decimal-digits   exponent-part_opt   real-type-suffix_opt
.   decimal-digits   exponent-part_opt   real-type-suffix_opt
decimal-digits   exponent-part   real-type-suffix_opt
decimal-digits   real-type-suffix

exponent-part:
e   sign_opt   decimal-digits
E   sign_opt   decimal-digits

sign:  one of
+  -

real-type-suffix:  one of
F  f  D  d  M  m

character-literal:
'   character   '

character:
single-character
simple-escape-sequence
hexadecimal-escape-sequence
unicode-escape-sequence

single-character:
 Any character except ' (U+0027), \ (U+005C), and new-line-character

simple-escape-sequence:  one of
\'  \"  \\  \0  \a  \b  \f  \n  \r  \t  \v

hexadecimal-escape-sequence:
\x   hex-digit   hex-digit_opt   hex-digit_opt   hex-digit_opt

string-literal:
regular-string-literal
verbatim-string-literal

regular-string-literal:
"   regular-string-literal-characters_opt   "

regular-string-literal-characters:
regular-string-literal-character
regular-string-literal-characters   regular-string-literal-character

regular-string-literal-character:
single-regular-string-literal-character
simple-escape-sequence
hexadecimal-escape-sequence
unicode-escape-sequence

single-regular-string-literal-character:
Any character except " (U+0022), \ (U+005C), and new-line-character

verbatim-string-literal:
@"   verbatim -string-literal-characters_opt   "

verbatim-string-literal-characters:
verbatim-string-literal-character
verbatim-string-literal-characters   verbatim-string-literal-character

verbatim-string-literal-character:
single-verbatim-string-literal-character
quote-escape-sequence

single-verbatim-string-literal-character:
any character except "

quote-escape-sequence:
""

null-literal:
null

B.1.9 Operators and punctuators

operator-or-punctuator:  one of
{     }     [     ]     (     )     .     ,     :     ;
+     -     *     /     %     &     |     ^     !     ~
=     <     >     ?     ++    --    &&    ||    <<    >>
==    !=    <=    >=    +=    -=    *=    /=    %=    &=
|=    ^=    <<=   >>=   ->

B.1.10 Pre-processing directives

pp-directive:
pp-declaration
pp-conditional
pp-line
pp-diagnostic
pp-region

pp-new-line:
whitespace_opt   single-line-comment_opt   new-line

conditional-symbol:
Any identifier-or-keyword except true or false

pp-expression:
whitespace_opt   pp-or-expression   whitespace_opt

pp-or-expression:
pp-and-expression
pp-or-expression   whitespace_opt   ||   whitespace_opt   pp-and-expression

pp-and-expression:
pp-equality-expression
pp-and-expression   whitespace_opt   &&   whitespace_opt   pp-equality-expression

pp-equality-expression:
pp-unary-expression
pp-equality-expression   whitespace_opt   ==   whitespace_opt   pp-unary-expression
pp-equality-expression   whitespace_opt   !=   whitespace_opt   pp-unary-expression

pp-unary-expression:
pp-primary-expression
!   whitespace_opt   pp-unary-expression

pp-primary-expression:
true
false
conditional-symbol
(   whitespace_opt   pp-expression   whitespace_opt   )

pp-declaration:
whitespace_opt   #   whitespace_opt   define   whitespace   conditional-symbol   pp-new-line
whitespace_opt   #   whitespace_opt   undef   whitespace   conditional-symbol   pp-new-line

pp-conditional:
pp-if-section   pp-elif-sections_opt   pp-else-section_opt   pp-endif

pp-if-section:
whitespace_opt   #   whitespace_opt   if   whitespace   pp-expression   pp-new-line   conditional-section_opt

pp-elif-sections:
pp-elif-section
pp-elif-sections   pp-elif-section

pp-elif-section:
whitespace_opt   #   whitespace_opt   elif   whitespace   pp-expression   pp-new-line   conditional-section_opt

pp-else-section:
whitespace_opt   #   whitespace_opt   else   pp-new-line   conditional-section_opt

pp-endif:
whitespace_opt   #   whitespace_opt   endif   pp-new-line

conditional-section:
input-section
skipped-section

skipped-section:
skipped-section-part
skipped-section   skipped-section-part

skipped-section-part:
skipped-characters_opt   new-line
pp-directive

skipped-characters:
whitespace_opt   not-number-sign   input-characters_opt

not-number-sign:
Any input-character except #

pp-line:
whitespace_opt   #   whitespace_opt   line   whitespace   line-indicator   pp-new-line

line-indicator:
decimal-digits   whitespace   file-name
decimal-digits
default

file-name:
"   file-name-characters   "

file-name-characters:
file-name-character
file-name-characters   file-name-character

file-name-character:
Any input-character except "

pp-diagnostic:
whitespace_opt   #   whitespace_opt   error   pp-message
whitespace_opt   #   whitespace_opt   warning   pp-message

pp-message:
new-line
whitespace   input-characters_opt   new-line

pp-region:
pp-start-region   conditional-section_opt   pp-end-region

pp-start-region:
whitespace_opt   #   whitespace_opt   region   pp-message

pp-end-region:
whitespace_opt   #   whitespace_opt   endregion   pp-message

B.2 Syntactic grammar

B.2.1 Basic concepts

namespace-name:
namespace-or-type-name

type-name:
namespace-or-type-name

namespace-or-type-name:
identifier
namespace-or-type-name   .   identifier

B.2.2 Types

type:
value-type
reference-type

value-type:
struct-type
enum-type

struct-type:
type-name
simple-type

simple-type:
numeric-type
bool

numeric-type:
integral-type
floating-point-type
decimal

integral-type:
sbyte
byte
short
ushort
int
uint
long
ulong
char

floating-point-type:
float
double

enum-type:
type-name

reference-type:
class-type
interface-type
array-type
delegate-type

class-type:
type-name
object
string

interface-type:
type-name

array-type:
non-array-type   rank-specifiers

non-array-type:
type

rank-specifiers:
rank-specifier
rank-specifiers   rank-specifier

rank-specifier:
[   dim-separators_opt   ]

dim-separators:
,
dim-separators   ,

delegate-type:
type-name

B.2.3 Variables

variable-reference:
expression

B.2.4 Expressions

argument-list:
argument
argument-list   ,   argument

argument:
expression
ref   variable-reference
out   variable-reference

primary-expression:
primary-no-array-creation-expression
array-creation-expression

primary-no-array-creation-expression:
literal
simple-name
parenthesized-expression
member-access
invocation-expression
element-access
this-access
base-access
post-increment-expression
post-decrement-expression
object-creation-expression
delegate-creation-expression
 typeof-expression
 checked-expression
unchecked-expression

simple-name:
identifier

parenthesized-expression:
(   expression   )

member-access:
primary-expression   .   identifier
predefined-type   .   identifier

predefined-type:  one of
bool     byte     char     decimal  double   float    int      long
object   sbyte    short    string   uint     ulong    ushort

invocation-expression:
primary-expression   (   argument-list_opt   )

element-access:
primary-no-array-creation-expression   [   expression-list   ]

expression-list:
expression
expression-list   ,   expression

this-access:
this

base-access:
base   .   identifier
base   [   expression-list   ]

post-increment-expression:
primary-expression   ++

post-decrement-expression:
primary-expression   --

object-creation-expression:
new   type   (   argument-list_opt   )

array-creation-expression:
new   non-array-type   [   expression-list   ]   rank-specifiers_opt   array-initializer_opt
new   array-type   array-initializer

delegate-creation-expression:
new   delegate-type   (   expression   )

typeof-expression:
typeof   (   type   )
typeof   (   void   )

checked-expression:
checked   (   expression   )

unchecked-expression:
unchecked   (   expression   )

unary-expression:
primary-expression
+   unary-expression
-   unary-expression
!   unary-expression
~   unary-expression
pre-increment-expression
pre-decrement-expression
cast-expression

pre-increment-expression:
++   unary-expression

pre-decrement-expression:
--   unary-expression

cast-expression:
(   type   )   unary-expression

multiplicative-expression:
unary-expression
multiplicative-expression   *   unary-expression
multiplicative-expression   /   unary-expression
multiplicative-expression   %   unary-expression

additive-expression:
multiplicative-expression
additive-expression   +   multiplicative-expression
additive-expression   –   multiplicative-expression

shift-expression:
additive-expression
shift-expression   <<   additive-expression
shift-expression   >>   additive-expression

relational-expression:
shift-expression
relational-expression   <   shift-expression
relational-expression   >   shift-expression
relational-expression   <=   shift-expression
relational-expression   >=   shift-expression
relational-expression   is   type
relational-expression   as   type

equality-expression:
relational-expression
equality-expression   ==   relational-expression
equality-expression   !=   relational-expression

and-expression:
equality-expression
and-expression   &   equality-expression

exclusive-or-expression:
and-expression
exclusive-or-expression   ^   and-expression

inclusive-or-expression:
exclusive-or-expression
inclusive-or-expression   |   exclusive-or-expression

conditional-and-expression:
inclusive-or-expression
conditional-and-expression   &&   inclusive-or-expression

conditional-or-expression:
conditional-and-expression
conditional-or-expression   ||   conditional-and-expression

conditional-expression:
conditional-or-expression
conditional-or-expression   ?   expression   :   expression

assignment:
unary-expression   assignment-operator   expression

assignment-operator:  one of
=   +=   -=   *=   /=   %=   &=   |=   ^=   <<=   >>=

expression:
conditional-expression
assignment

constant-expression:
expression

boolean-expression:
expression

B.2.5 Statements

statement:
labeled-statement
declaration-statement
embedded-statement

embedded-statement:
block
empty-statement
expression-statement
selection-statement
iteration-statement
jump-statement
try-statement
checked-statement
unchecked-statement
lock-statement
using-statement

block:
{   statement-list_opt   }

statement-list:
statement
statement-list   statement

empty-statement:
;

labeled-statement:
identifier   :   statement

declaration-statement:
local-variable-declaration   ;
local-constant-declaration   ;

local-variable-declaration:
type   local-variable-declarators

local-variable-declarators:
local-variable-declarator
local-variable-declarators   ,   local-variable-declarator

local-variable-declarator:
identifier
identifier   =   local-variable-initializer

local-variable-initializer:
expression
array-initializer

local-constant-declaration:
const   type   constant-declarators

constant-declarators:
constant-declarator
constant-declarators   ,   constant-declarator

constant-declarator:
identifier   =   constant-expression

expression-statement:
statement-expression   ;

statement-expression:
invocation-expression
object-creation-expression
assignment
post-increment-expression
post-decrement-expression
pre-increment-expression
pre-decrement-expression

selection-statement:
if-statement
switch-statement

if-statement:
if   (   boolean-expression   )   embedded-statement
if   (   boolean-expression   )   embedded-statement   else   embedded-statement

boolean-expression:
expression

switch-statement:
switch   (   expression   )   switch-block

switch-block:
{   switch-sections_opt   }

switch-sections:
switch-section
switch-sections   switch-section

switch-section:
switch-labels   statement-list

switch-labels:
switch-label
switch-labels   switch-label

switch-label:
case   constant-expression   :
default   :

iteration-statement:
while-statement
do-statement
for-statement
foreach-statement

while-statement:
while   (   boolean-expression   )   embedded-statement

do-statement:
do   embedded-statement   while   (   boolean-expression   )   ;

for-statement:
for   (   for-initializer_opt   ;   for-condition_opt   ;   for-iterator_opt   )   embedded-statement

for-initializer:
local-variable-declaration
statement-expression-list

for-condition:
boolean-expression

for-iterator:
statement-expression-list

statement-expression-list:
statement-expression
statement-expression-list   ,   statement-expression

foreach-statement:
foreach   (   type   identifier   in   expression   )   embedded-statement

jump-statement:
break-statement
continue-statement
goto-statement
return-statement
throw-statement

break-statement:
break   ;

continue-statement:
continue   ;

goto-statement:
goto   identifier   ;
goto   case   constant-expression   ;
goto   default   ;

return-statement:
return   expression_opt   ;

throw-statement:
throw   expression_opt   ;

try-statement:
try   block   catch-clauses
try   block   finally-clause
try   block   catch-clauses   finally-clause

catch-clauses:
specific-catch-clauses   general-catch-clause_opt
specific-catch-clauses_opt   general-catch-clause

specific-catch-clauses:
specific-catch-clause
specific-catch-clauses   specific-catch-clause

specific-catch-clause:
catch   (   class-type   identifier_opt   )   block

general-catch-clause:
catch   block

finally-clause:
finally   block

checked-statement:
checked   block

unchecked-statement:
unchecked   block

lock-statement:
lock   (   expression   )   embedded-statement

using-statement:
using   (    resource-acquisition   )    embedded-statement

resource-acquisition:
local-variable-declaration
expression

B.2.6 Namespaces

compilation-unit:
using-directives_opt  global-attributes_opt    namespace-member-declarations_opt

namespace-declaration:
namespace   qualified-identifier   namespace-body   ;_opt

qualified-identifier:
identifier
qualified-identifier   .   identifier

namespace-body:
{   using-directives_opt   namespace-member-declarations_opt   }

using-directives:
using-directive
using-directives   using-directive

using-directive:
using-alias-directive
using-namespace-directive

using-alias-directive:
using   identifier   =   namespace-or-type-name   ;

using-namespace-directive:
using   namespace-name   ;

namespace-member-declarations:
namespace-member-declaration
namespace-member-declarations   namespace-member-declaration

namespace-member-declaration:
namespace-declaration
type-declaration

type-declaration:
class-declaration
struct-declaration
interface-declaration
enum-declaration
delegate-declaration

B.2.7 Classes

class-declaration:
attributes_opt   class-modifiers_opt   class   identifier   class-base_opt   class-body   ;_opt

class-modifiers:
class-modifier
class-modifiers   class-modifier

class-modifier:
new
public
protected
internal
private
abstract
sealed

class-base:
:   class-type
:   interface-type-list
:   class-type   ,   interface-type-list

interface-type-list:
interface-type
interface-type-list   ,   interface-type

class-body:
{   class-member-declarations_opt   }

class-member-declarations:
class-member-declaration
class-member-declarations   class-member-declaration

class-member-declaration:
constant-declaration
field-declaration
method-declaration
property-declaration
event-declaration
indexer-declaration
operator-declaration
constructor-declaration
destructor-declaration
static-constructor-declaration
type-declaration

constant-declaration:
attributes_opt   constant-modifiers_opt   const   type   constant-declarators   ;

constant-modifiers:
constant-modifier
constant-modifiers   constant-modifier

constant-modifier:
new
public
protected
internal
private

constant-declarators:
constant-declarator
constant-declarators   ,   constant-declarator

constant-declarator:
identifier   =   constant-expression

field-declaration:
attributes_opt   field-modifiers_opt   type   variable-declarators   ;

field-modifiers:
field-modifier
field-modifiers   field-modifier

field-modifier:
new
public
protected
internal
private
static
readonly
volatile

variable-declarators:
variable-declarator
variable-declarators   ,   variable-declarator

variable-declarator:
identifier
identifier   =   variable-initializer

variable-initializer:
expression
array-initializer

method-declaration:
method-header   method-body

method-header:
attributes_opt   method-modifiers_opt   return-type   member-name   (   formal-parameter-list_opt   )

method-modifiers:
method-modifier
method-modifiers   method-modifier

method-modifier:
new
public
protected
internal
private
static
virtual
sealed
override
abstract
extern

return-type:
type
void

member-name:
identifier
interface-type   .   identifier

method-body:
block
;

formal-parameter-list:
fixed-parameters
fixed-parameters   ,   parameter-array
parameter-array

fixed-parameters:
fixed-parameter
fixed-parameters   ,   fixed-parameter

fixed-parameter:
attributes_opt   parameter-modifier_opt   type   identifier

parameter-modifier:
ref
out

parameter-array:
attributes_opt   params   array-type   identifier

property-declaration:
attributes_opt   property-modifiers_opt   type   member-name   {   accessor-declarations   }

property-modifiers:
property-modifier
property-modifiers   property-modifier

property-modifier:
new
public
protected
internal
private
static
virtual
sealed
override
abstract
extern

member-name:
identifier
interface-type   .   identifier

accessor-declarations:
get-accessor-declaration   set-accessor-declaration_opt
set-accessor-declaration   get-accessor-declaration_opt

get-accessor-declaration:
attributes_opt   get   accessor-body

set-accessor-declaration:
attributes_opt   set   accessor-body

accessor-body:
block
;

event-declaration:
attributes_opt   event-modifiers_opt   event   type   variable-declarators   ;
attributes_opt   event-modifiers_opt   event   type   member-name   {   event-accessor-declarations   }

event-modifiers:
event-modifier
event-modifiers   event-modifier

event-modifier:
new
public
protected
internal
private
static
virtual
sealed
override
abstract
extern

event-accessor-declarations:
add-accessor-declaration   remove-accessor-declaration
remove-accessor-declaration   add-accessor-declaration

add-accessor-declaration:
attributes_opt   add   block

remove-accessor-declaration:
attributes_opt   remove   block

indexer-declaration:
attributes_opt   indexer-modifiers_opt   indexer-declarator   {   accessor-declarations   }

indexer-modifiers:
indexer-modifier
indexer-modifiers   indexer-modifier

indexer-modifier:
new
public
protected
internal
private
virtual
sealed
override
abstract
extern

indexer-declarator:
type   this   [   formal-parameter-list   ]
type   interface-type   .   this   [   formal-parameter-list   ]

operator-declaration:
attributes_opt   operator-modifiers   operator-declarator   operator-body

operator-modifiers:
operator-modifier
operator-modifiers   operator-modifier

operator-modifier:
public
static
extern

operator-declarator:
unary-operator-declarator
binary-operator-declarator
conversion-operator-declarator

unary-operator-declarator:
type   operator   overloadable-unary-operator   (   type   identifier   )

overloadable-unary-operator:  one of
+   -   !   ~   ++   --   true   false

binary-operator-declarator:
type   operator   overloadable-binary-operator   (   type   identifier   ,   type   identifier   )

overloadable-binary-operator:  one of
+   -   *   /   %   &   |   ^   <<   >>   ==   !=   >   <   >=   <=

conversion-operator-declarator:
implicit   operator   type   (   type   identifier   )
explicit   operator   type   (   type   identifier   )

operator-body:
block
;

constructor-declaration:
attributes_opt   constructor-modifiers_opt   constructor-declarator   constructor-body

constructor-modifiers:
constructor-modifier
constructor-modifiers   constructor-modifier

constructor-modifier:
public
protected
internal
private
extern

constructor-declarator:
identifier   (   formal-parameter-list_opt   )   constructor-initializer_opt

constructor-initializer:
:   base   (   argument-list_opt   )
:   this   (   argument-list_opt   )

constructor-body:
block
;

static-constructor-declaration:
attributes_opt   static-constructor-modifiers  identifier   (   )   static-constructor-body

static-constructor-modifiers:
extern_opt static
static extern_opt

static-constructor-body:
block
;

destructor-declaration:
attributes_opt   extern_opt   ~   identifier   (   )    destructor-body

destructor-body:
block
;

B.2.8 Structs

struct-declaration:
attributes_opt   struct-modifiers_opt   struct   identifier   struct-interfaces_opt   struct-body   ;_opt

struct-modifiers:
struct-modifier
struct-modifiers   struct-modifier

struct-modifier:
new
public
protected
internal
private

struct-interfaces:
:   interface-type-list

struct-body:
{   struct-member-declarations_opt   }

struct-member-declarations:
struct-member-declaration
struct-member-declarations   struct-member-declaration

struct-member-declaration:
constant-declaration
field-declaration
method-declaration
property-declaration
event-declaration
indexer-declaration
operator-declaration
constructor-declaration
static-constructor-declaration
type-declaration

B.2.9 Arrays

array-type:
non-array-type   rank-specifiers

non-array-type:
type

rank-specifiers:
rank-specifier
rank-specifiers   rank-specifier

rank-specifier:
[   dim-separators_opt   ]

dim-separators:
,
dim-separators   ,

array-initializer:
{   variable-initializer-list_opt   }
{   variable-initializer-list   ,   }

variable-initializer-list:
variable-initializer
variable-initializer-list   ,   variable-initializer

variable-initializer:
expression
array-initializer

B.2.10 Interfaces

interface-declaration:
attributes_opt   interface-modifiers_opt   interface   identifier   interface-base_opt   interface-body   ;_opt

interface-modifiers:
interface-modifier
interface-modifiers   interface-modifier

interface-modifier:
new
public
protected
internal
private

interface-base:
:   interface-type-list

interface-body:
{   interface-member-declarations_opt   }

interface-member-declarations:
interface-member-declaration
interface-member-declarations   interface-member-declaration

interface-member-declaration:
interface-method-declaration
interface-property-declaration
interface-event-declaration
interface-indexer-declaration

interface-method-declaration:
attributes_opt   new_opt   return-type   identifier   (   formal-parameter-list_opt   )   ;

interface-property-declaration:
attributes_opt   new_opt   type   identifier   {   interface-accessors   }

interface-accessors:
attributes_opt   get   ;
attributes_opt   set   ;
attributes_opt   get   ;   attributes_opt   set   ;
attributes_opt   set   ;   attributes_opt   get   ;

interface-event-declaration:
attributes_opt   new_opt   event   type   identifier   ;

interface-indexer-declaration:
attributes_opt   new_opt   type   this   [   formal-parameter-list   ]   {   interface-accessors   }

B.2.11 Enums

enum-declaration:
attributes_opt   enum-modifiers_opt   enum   identifier   enum-base_opt   enum-body   ;_opt

enum-base:
:   integral-type

enum-body:
{   enum-member-declarations_opt   }
{   enum-member-declarations   ,   }

enum-modifiers:
enum-modifier
enum-modifiers   enum-modifier

enum-modifier:
new
public
protected
internal
private

enum-member-declarations:
enum-member-declaration
enum-member-declarations   ,   enum-member-declaration

enum-member-declaration:
attributes_opt   identifier
attributes_opt   identifier   =   constant-expression

B.2.12 Delegates

delegate-declaration:
attributes_opt   delegate-modifiers_opt   delegate   return-type   identifier
            (   formal-parameter-list_opt   )   ;

delegate-modifiers:
delegate-modifier
delegate-modifiers   delegate-modifier

delegate-modifier:
new
public
protected
internal
private

B.2.13 Attributes

global-attributes:
global-attribute-sections

global-attribute-sections:
global-attribute-section
global-attribute-sections  global-attribute-section

global-attribute-section:
[   global-attribute-target-specifier   attribute-list   ]
[   global-attribute-target-specifier   attribute-list   ,]

global-attribute-target-specifier:
global-attribute-target   :

global-attribute-target:
assembly
module

attributes:
attribute-sections

attribute-sections:
attribute-section
attribute-sections   attribute-section

attribute-section:
[   attribute-target-specifier_opt   attribute-list   ]
[   attribute-target-specifier_opt   attribute-list   ,   ]

attribute-target-specifier:
attribute-target   :

attribute-target:
field
event
method
param
property
return
type

attribute-list:
attribute
attribute-list   ,   attribute

attribute:
attribute-name   attribute-arguments_opt

attribute-name:
 type-name

attribute-arguments:
(   positional-argument-list_opt   )
(   positional-argument-list   ,   named-argument-list   )
(   named-argument-list   )

positional-argument-list:
positional-argument
positional-argument-list   ,   positional-argument

positional-argument:
attribute-argument-expression

named-argument-list:
named-argument
named-argument-list   ,   named-argument

named-argument:
identifier   =   attribute-argument-expression

attribute-argument-expression:
expression

B.3 Grammar extensions for unsafe code

class-modifier:
...
unsafe

struct-modifier:
...
unsafe

interface-modifier:
...
unsafe

delegate-modifier:
...
unsafe

field-modifier:
...
unsafe

method-modifier:
...
unsafe

property-modifier:
...
unsafe

event-modifier:
...
unsafe

indexer-modifier:
...
unsafe

operator-modifier:
...
unsafe

constructor-modifier:
...
unsafe

destructor-declaration:
attributes_opt   extern_opt   unsafe_opt   ~   identifier   (   )    destructor-body
attributes_opt   unsafe_opt   extern_opt   ~   identifier   (   )    destructor-body

static-constructor-modifiers:
extern_opt   unsafe_opt   static
unsafe_opt   extern_opt   static
extern_opt   static   unsafe_opt
unsafe_opt   static   extern_opt
static   extern_opt   unsafe_opt
static   unsafe_opt   extern_opt

embedded-statement:
...
unsafe-statement

unsafe-statement:
unsafe   block

type:
value-type
reference-type
pointer-type

pointer-type:
unmanaged-type   *
void   *

unmanaged-type:
type

primary-no-array-creation-expression:
...
pointer-member-access
pointer-element-access
sizeof-expression

unary-expression:
...
pointer-indirection-expression
addressof-expression

pointer-indirection-expression:
*   unary-expression

pointer-member-access:
primary-expression   ->   identifier

pointer-element-access:
primary-no-array-creation-expression   [   expression   ]

addressof-expression:
&   unary-expression

sizeof-expression:
sizeof   (   unmanaged-type   )

embedded-statement:
...
fixed-statement

fixed-statement:
fixed   (   pointer-type   fixed-pointer-declarators   )   embedded-statement

fixed-pointer-declarators:
fixed-pointer-declarator
fixed-pointer-declarators   ,   fixed-pointer-declarator

fixed-pointer-declarator:
identifier   =   fixed-pointer-initializer

fixed-pointer-initializer:
&   variable-reference
expression

local-variable-initializer:
expression
array-initializer
stackalloc-initializer

stackalloc-initializer:
stackalloc   unmanaged-type   [   expression   ]