blocks, but are not permitted as embedded statements.
labeled-statement:
identifier : statement
A labeled statement declares a label with the name given by the identifier.
The scope of a label is the whole
block in which the label is declared, including any nested blocks. It is a
compile-time error for two labels
with the same name to have overlapping scopes.
A label can be referenced from goto statements (§15.9.3) within the scope
of the label. [Note: This means
that goto statements can transfer control within blocks and out of blocks,
but never into blocks. end note]
Labels have their own declaration space and do not interfere with other
identifiers. [Example: The example
int F(int x) {
if (x >= 0) goto x;
x = -x;
x: return x;
}
is valid and uses the name x as both a parameter and a label. end example]
Execution of a labeled statement corresponds exactly to execution of the
statement following the label.
In addition to the reachability provided by normal flow of control, a
labeled statement is reachable if the
label is referenced by a reachable goto statement. (Exception: If a goto
statement is inside a try that
includes a finally block, and the labeled statement is outside the try, and
the end point of the finally
block is unreachable, then the labeled statement is not reachable from that
goto statement.)
15.5 Declaration statements
A declaration-statement declares a local variable or constant. Declaration
statements are permitted in blocks,
but are not permitted as embedded statements.
declaration-statement:
local-variable-declaration ;
local-constant-declaration ;
15.5.1 Local variable declarations
A local-variable-declaration declares one or more local variables.
local-variable-declaration:
type local-variable-declarators
Chapter 15 Statements
181
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
The type of a local-variable-declaration specifies the type of the
variables introduced by the declaration.
The type is followed by a list of local-variable-declarators, each of which
introduces a new variable. A
local-variable-declarator consists of an identifier that names the
variable, optionally followed by an
.=. token and a local-variable-initializer that gives the initial value of
the variable.
The value of a local variable is obtained in an expression using a
simple-name (§14.5.2), and the value of a
local variable is modified using an assignment (§14.13). A local variable
must be definitely assigned (§12.3)
at each location where its value is obtained.
The scope of a local variable declared in a local-variable-declaration is
the block in which the declaration
occurs. It is an error to refer to a local variable in a textual position
that precedes the local-variabledeclarator
of the local variable. Within the scope of a local variable, it is a
compile-time error to declare
another local variable or constant with the same name.
A local variable declaration that declares multiple variables is equivalent
to multiple declarations of single
variables with the same type. Furthermore, a variable initializer in a
local variable declaration corresponds
exactly to an assignment statement that is inserted immediately after the
declaration.
[Example: The example
void F() {
int x = 1, y, z = x * 2;
}
corresponds exactly to
void F() {
int x; x = 1;
int y;
int z; z = x * 2;
}
end example]
15.5.2 Local constant declarations
A local-constant-declaration declares one or more local constants.
local-constant-declaration:
const type constant-declarators
constant-declarators:
constant-declarator
constant-declarators , constant-declarator
constant-declarator:
identifier = constant-expression
The type of a local-constant-declaration specifies the type of the
constants introduced by the declaration.
The type is followed by a list of constant-declarators, each of which
introduces a new constant. A constantdeclarator
consists of an identifier that names the constant, followed by an .=.
token, followed by a
constant-expression (§14.15) that gives the value of the constant.
C# LANGUAGE SPECIFICATION
182
The type and constant-expression of a local constant declaration must
follow the same rules as those of a
constant member declaration (§17.3).
The value of a local constant is obtained in an expression using a
simple-name (§14.5.2).
The scope of a local constant is the block in which the declaration occurs.
It is an error to refer to a local
constant in a textual position that precedes its constant-declarator.
Within the scope of a local constant, it is
a compile-time error to declare another local variable or constant with the
same name.
A local constant declaration that declares multiple constants is equivalent
to multiple declarations of single
constants with the same type.