语 句 3 （2.014）

18 Synchronized 语句
synchronized 语句用来在多线程情况下同步临界区内的语句。

Synchronized语句：
synchronized 作用域语句
synchronized ( 表达式 ) 作用域语句

synchronized 每次只允许一个线程 执行 作用域语句。

synchronized (表达式)，其中的 表达式 会计算成一个 Object 引用，整个则同时只允许有一个线程在使用该 Object 来执行 作用域语句。如果 表达式 是 接口 的一个实例，则它会类型转换成一个 Object。


即使 作用域语句 由于异常、goto 或 return 被终止了，synchronization 也会被释放。
样例:
synchronized { ... }
这实现一个标准的临界区。


19 Try 语句

异常处理由 try-catch-finally 语句完成。

Try语句：
try 作用域语句 多个Catch
try 作用域语句 多个Catch Finally语句
try 作用域语句 Finally语句

多个Catch：
最后的Catch
Catch
Catch 多个Catch

最后的Catch：
catch 无作用域非空语句

Catch：
catch ( Catch参数 ) 无作用域非空语句

Finally语句：
finally 无作用域非空语句

Catch参数 声明类型为 T 的变量 v，这里的 T 是 Object 或继承自 Object。v 由抛出的表达式进行初始化，如果 T 具有跟抛出的表达式相同的类型或是其基类的话。如果异常对象的类型为 T 或者继承自 T，则该 catch 子句就会被执行。

如果只给定了类型 T 而没有变量 v，那么该 catch 依然会被执行。

如果有 Catch参数 类型 T1 隐藏了后面类型为 T2 的 Catch，则会产生一个错误；例如，
如果 T1 跟 T2 同类型或是 T2 的基类，则这就是一个错误。

最后的Catch 会捕捉所有的异常。

Finally语句 总是会被执行，无论是否 try 作用域语句 由于goto、break、continue、return、exception 或失败而退出。

如果一个异常在 Finally语句 里产生了，而在执行 FinallyStatement 之前没有被捕捉到，则新的表达式会替换所有原来的表达式：

import std.stdio;

int main()
{
try
{
try
{
throw new Exception("first");
}
finally
{
writefln("finally");
throw new Exception("second");
}
}
catch(Exception e)
{
writefln("catch %s", e.msg);
}
writefln("done");
return 0;
}

输出：
finally
catch second
done

Finally语句 不可能因为 goto、break、continue 或 return 而退出；也不可以因为 goto 而进入。
Finally语句 不可能包含任何的 Catches。在将来的版本中这个限制可以被放宽。


20 Throw 语句

抛出一个异常。

Throw语句：
throw 表达式 ;

表达式 被计算，结果必须是 Object 引用类型。该 Object 的引用被作为异常抛出。
throw new Exception("message");


21 作用域守护语句(Scope Guard Statement)

作用域守护语句：
scope(exit) 非空或无作用域块语句
scope(success) 非空或无作用域块语句
scope(failure) 非空或无作用域块语句

作用域守护语句 在当前作用域的 结束处 执行 非空或无作用域 块语句，而不是在 作用域守护语句 所在的那个地方执行。

scope(exit) 会在正常退出该作用域时或在由于异常展开而退出时执行 非空或无作用域块语句。

scope(failure) 会在由于异常展开退出该作用域时执行非空或无作用域块语句。

scope(success) 则会在正常退出该作用域时执行 非空或无作用域块语句。

如果在一个作用域内有多重 作用域守护语句，那么它们执行的顺序则跟它们在词法上出现
的顺序相反。如果有 auto 实例在访作用域结束处被析构，那么它们也以跟词法上相反的顺
序跟 作用域守护语句 交叉在一起。

writef("1");
{
writef("2");
scope(exit) writef("3");
scope(exit) writef("4");
writef("5");
}
writefln();

输出：
12543
{
scope(exit) writef("1");
scope(success) writef("2");
scope(exit) writef("3");
scope(success) writef("4");
}
writefln();

输出：
4321
class Foo
{
this() { writef("0"); }
~this() { writef("1"); }
}
try
{
scope(exit) writef("2");
scope(success) writef("3");
auto Foo f = new Foo();
scope(failure) writef("4");
throw new Exception("msg");
scope(exit) writef("5");
scope(success) writef("6");
scope(failure) writef("7");
}
catch (Exception e)
{}
writefln();

输出：
0412

scope(exit) 或 scope(success) 语句不可能由于 throw、goto、break、continue 或 return 退
出；也不可能由于 goto 而进入。

  2.014中没有
22 Volatile 语句
[color=red]没有什么代码活动能跨越 volatile 语句的边界。[/color]

Volatile语句：
volatile 语句
volatile ;

语句 会被计算。在 语句 之前的所有内存写操作都保证在 语句 中或其后的内存读操作之
前完成。在 语句 之后的所有内存读操作都保证在 语句 中或其前的所有内存写完成之后执
行。

[color=red]volatile 语句不能保证原子性。为了该目的，应该使用 synchronized 语句。[/color]

23 Asm 语句
asm 语句用来支持内联汇编：

Asm语句：

asm { }
asm { Asm指令列表 }
Asm指令列表：
Asm指令 ;
Asm指令 ; Asm指令列表

asm 语句使你可以直接使用汇编语言指令。这样不必费力地采用外部的汇编程序就可以获得
对CPU特殊特征的直接访问能力。D 编译器会替你管理函数调用约定、堆栈设置等等恼人
的事情。

指令的格式，当然，高度依赖于目标CPU的指令集，所以是由 实现定义 的。但是，格式
需要遵循下述约定：

• 必须使用同 D 语言相同的记号。
• 注释的形式必须同 D 语言的相通。
• Asm 指令以‘;’结尾，而不是以行尾结尾。

这些规则保证 D 的源代码可以独立于语法或语义分析而被记号化。

例如，对于 Intel Pentium 处理器：

int x = 3;
asm
{
mov EAX,x; // 将 x 载入寄存器 EAX
}

内联汇编可以用来直接访问硬件：
int gethardware()
{
asm
{
mov EAX, dword ptr 0x1234;
}
}

对于某些 D 实现，如将 D 翻译为 C 的翻译器来说，内联汇编没有什么意义，也就不需要
实现它。version 语句可以用来应付这种情况：

version (D_InlineAsm_X86)
{
asm
{
...
}
}
else
{
/* ... some workaround ... */
}

24 Pragma 语句

Pragma语句：
Pragma 无作用域语句

25 Mixin 语句

Mixin语句：
mixin ( 赋值表达式 ) ;
赋值表达式 必须在编译时求值成一个常量字符串。该字符串的文本内容必须要可编译成一
个有效的语句列表，而且同样地被编译。

import std.stdio;
void main()
{
int j;
mixin("
int x = 3;
for (int i = 0; i < 3; i++)
writefln(x + i, ++j);
"); // 正确
const char[] s = "int y;";

  2.014
26 Foreach Range Statement

A foreach range statement loops over the specified range. 
ForeachRangeStatement:
    Foreach (ForeachType; LwrExpression .. UprExpression ) ScopeStatement

LwrExpression:
    Expression

UprExpression:
    Expression
ForeachType declares a variable with either an explicit type, or a type inferred from LwrExpression and UprExpression. The ScopeStatement is then executed n times, where n is the result of UprExpression - LwrExpression. If UprExpression is less than or equal to LwrExpression, the ScopeStatement is executed zero times. If Foreach is foreach, then the variable is set to LwrExpression, then incremented at the end of each iteration. If Foreach is foreach_reverse, then the variable is set to UprExpression, then decremented before each iteration. LwrExpression and UprExpression are each evaluated exactly once, regardless of how many times the ScopeStatement is executed. 

import std.stdio;

int foo()
{
    writefln("foo");
    return 10;
}

void main()
{
    foreach (i; 0 .. foo())
    {
	writef(i);
    }
}

Prints:

foo0123456789

。。。。