C++博客-qiezi的学习园地-随笔分类-D

[D语言] D语言数组

qiezi — Sat, 07 Oct 2006 08:21:00 GMT

先看一段代码：

void main(){
    int[] c = [1,2,3];
    foreach(inout int i; c){
        writef(&i);
        writef(", ");
    }
    writefln("");

    c.length = 2;
    foreach(inout int i; c){
        writef(&i);
        writef(", ");
    }
    writefln("");

    c.length = 3;
    foreach(inout int i; c){
        writef(&i);
        writef(", ");
    }
    writefln("");

    c.length = 4;
    foreach(inout int i; c){
        writef(&i);
        writef(", ");
    }
    writefln("");
}

它输出结果如下：

B7D19FB0, B7D19FB4, B7D19FB8,
B7D19FB0, B7D19FB4,
B7D19FB0, B7D19FB4, B7D19FB8,
B7D1CFA0, B7D1CFA4, B7D1CFA8, B7D1CFAC,

可以看到前3行地址相同，后面一行地址不同。为什么？

D语言的数组分配是内存紧凑的，当减小数组长度减小时，只需要修改切片大小而不需要重新分配。当长度变大时，也会检查原来的缓冲区是否够大，以确定是否需要重新分配空间。注意第2次操作时把长度恢复为原来大小时，并非真的恢复了原来的状态，后面长出来的元素会被初始化为默认值。

再来看一个：

void main(){
    int[] c = [1,2,3];
    int[] d = c;

    foreach(inout int i; c){
        writef(&i);
        writef(", ");
    }
    writefln("");

    foreach(inout int i; d){
        writef(&i);
        writef(", ");
    }
    writefln("");

    d.length = 2;

    foreach(inout int i; c){
        writef(&i);
        writef(", ");
    }
    writefln("");

    foreach(inout int i; d){
        writef(&i);
        writef(", ");
    }
    writefln("");

    d.length = 4;

    foreach(inout int i; c){
        writef(&i);
        writef(", ");
    }
    writefln("");

    foreach(inout int i; d){
        writef(&i);
        writef(", ");
    }
    writefln("");
}

在执行int[] d = c;以后，d的确是和c共享了存储区。不过在改变d的长度以后，它就和c分道扬镳了。所以int[] d = c不能理解为d是一个指向c的引用，它实际上创建了一个新的数组对象，但并不拷贝数组元素，它和int[] d = c[0 .. length]是等价的，都是数组切片操作。

这个问题让我困惑不已。比如你用char[]表示一个单词，用char[][]表示一行，char[][][]表示多行。如何引用这个单词？你当然可以每次使用lines[i][j]，但如果处理步骤很多，这会不会看起来很头大？

看上去应该这样使用：

char[][][] lines;
char[][] line = lines[0];
line.length = line.length + 1;
line[length - 1] = ",";

可惜根据前面的结论，这将无法影响到lines。如果找不到一个引用类型指向数组，有时候使用起来还真是很麻烦。看起来把Line/Word包装成类是个勉强凑合的主意。。。

qiezi 2006-10-07 16:21 发表评论

[D语言] Array slicing

qiezi — Fri, 06 Oct 2006 01:35:00 GMT

数组slicing操作并不复制数据。

指针的slicing操作和数组slicing语意是相同的。

通过slicing生成D数组，比原来直接使用指针的好处是可以有边界检查。

最近刚好犯了这个错误，在使用freetype时，render出来的位图数据直接使用slicing生成数组保存起来。由于slicing并不复制数据，这样后面的render操作会覆盖前面的数据，所以我保存的数组其实都指向同一个缓冲区。当释放face对象时，缓冲区也没了，再访问恐怕要段错误了。

这个是D文档中明确描述了的，我却花了点时间才排除这个错误，写下来记录之～

qiezi 2006-10-06 09:35 发表评论

[D语言] DMD 0.168发布

qiezi — Thu, 05 Oct 2006 01:23:00 GMT

新特性：
1、给委托增加ptr属性，指向委托所绑定的对象。
这是一个语法糖，dg.ptr被转化为cast(void*)dg，它只能作右值，所以除了能读取它以外，在语法上禁止对它赋值。要想把委托绑定到不同的对象，你只能自己实现：

class Foo{
    int foo;
public:
    this(int foo){
        this.foo = foo;
    }

    void bar(){
        writefln(foo);
    }
}

void main(){

    alias void delegate() DG;
    DG dg = &(new Foo(1)).bar;

    Foo[10] foos;
    foreach(int i, inout Foo foo; foos){
        foo = new Foo(i);
    }

    void** ptr = cast(void**)&dg;
    foreach(Foo foo; foos){
        *ptr = cast(void*)foo;
        dg();
    }
}

这种方式也不是我们所希望的，一般来说委托绑定到多个对象时，因为是取到某成员函数指针，再进行绑定。比如模拟一个ActiveSupport所扩展的一个ruby.Array#map用法：

import std.stdio;

class Foo{
    int foo;
public:
    this(int foo){
        this.foo = foo;
    }

    void bar(){
        writefln(foo);
    }
}

class Array(T){
    private:
    T[] data;

    public:
    this(T[] data){
        this.data = data[0 .. length];
    }

    void map(void function() func){
        void delegate() dg;
        void** funcPtr = cast(void**)&dg + 1;
        *funcPtr = func;
        void ** ptr = cast(void**)&dg;
        foreach(T v; data){
            *ptr = cast(void*)v;
            dg();
        }
    }
}

void main(){
    auto arr = new Array!(Foo)([new Foo(1), new Foo(2), new Foo(3)]);
    arr.map(&Foo.bar);
}

是的，delegate内部保存了2个指针，所以我们可以容易地hack它。

[注：上面的main函数中数组直接量赋给栈对象也是这个版本中新增的内容，显然只能用于static对象是很鸡肋的。这里简单带过不提。]

[注：上面这个map的模拟并不是ActiveSupport的map扩展的全部用途，那个map还是收集返回值，这里只演示调用语法。ActiveSupport中扩展的map调用语法是map(&:to_s)，就可以收集到数组中所有元素调用to_s后的返回值。]

2、给内嵌内的实例增加outer属性，指向外层对象。

import std.stdio;

class Outer{
    class Inner{}

    this(){
        Inner inner = new Inner;
        inner.outer.foo();
    }

    void foo(){
        writefln("foo");
    }
}

void main(){
    Outer outer = new Outer;
}

这个特性可能应用并不是很广吧。

3、mixin多个析构函数。

template A(){
    this(){
    }
    ~this(){
        writefln("A::~A()");
    }
}

template B(){
    ~this(){
        writefln("B::~B()");
    }
}

class C{
    mixin A;
    mixin B;
}

void main(){
    C c = new C;
    delete c;
}

这些析构函数会和mixin相反的顺序执行。我不明白的是，为什么不让mixin多个构造函数？为何不让这些构造函数晚于被mixin的类（上面的C类）的构造函数，并按mixin进来的顺序执行？

qiezi 2006-10-05 09:23 发表评论

[D语言] DMD 0.167发布

qiezi — Tue, 19 Sep 2006 12:16:00 GMT

这个版本实现了计划已久的数组直接量。

import std.stdio;

void main(){
  {
    static int[] arr = [1,2,3,4,5];
    writefln(typeid(typeof(arr[0])));
    writefln(arr);
  }
  {
    static float[] arr = [1f,1,3,4,5];
    writefln(typeid(typeof(arr[0])));
    writefln(arr);
  }
  {
    static char[][] arr = ["1","2","3","4","5"];
    writefln(typeid(typeof(arr[0])));
    writefln(arr);
  }
}

数组类型由第1个元素类型决定，类型不匹配将会产生编译错误。

接着是多维数组：

import std.stdio;

void main(){
  static int[][] arr = [[1,2,3,4], [4,5,6], [7,8]];
  foreach(int[] sub; arr){
    foreach(int i; sub){
      writefln(i);
    }
  }
}

另一个特性是更强的typedef。原有的typedef强类型在某些情况下会产生混乱。

下面的代码摘自 http://www.digitalmars.com/pnews/read.php?server=news.digitalmars.com&group=digitalmars.D.bugs&artnum=3843

import std.stdio;

typedef int Int1;
typedef int Int2;

void show(Int1 v) {
     writefln("Int1: %d", v);
}

void show(Int2 v) {
     writefln("Int2: %d", v);
}

void show(int i) {
     writefln("int: %d", i);
}

void show(long l) {
     writefln("long: %d", l);
}

void main() {
     Int1 value1 = 42;
     Int2 value2 = 69;

     show(value1 + value2);
     show(value2 + value1);
     show(2 * value1);
     show(value1 * 2);
     show(value1 + value1);
     show(value2 - value2);
     show(value1 + 2);
     show(3 + value2);

     long l = 23;
     show(value1 + l);
     show(l + value2);

     short s = 105;
     show(s + value1);
     show(value2 + s);
}

如上面代码所示。typedef定义出来的类型和原有类型的相同形式重载函数可以共存，这可以完成更强类型的重载，C＋＋的重载还不能实现这个。

这个强类型的typedef好像原本就支持，大概是运算结果类型比较模糊。

好处是显页易见的。比如有一个Time和TimeInterval类型，它用来表示绝对时间或相对时间间隔；另有一个输出函数用来显示结果。

import std.stdio;
import std.string;

typedef long Time;
typedef long TimeInterval;

void output(Time t){
  writefln("Time: " ~ toString(cast(long)t));
}
void output(TimeInterval t){
  writefln("Interval: " ~ toString(cast(long)t));
}
void main(){
  Time time = cast(Time)100;
  TimeInterval interval = cast(TimeInterval)100;
  output(time);
  output(interval);
}

是的，使用上麻烦了很多，因为我们试图用一个数值类型去表示多个矢量类型。

这里Time time = cast(Time)100不再只是100这个简单的数值，它还携带了Time这个类型。TimeInterval interval = cast(TimeInterval)100也不只是100这个数值，我们给它赋予了时间间隔的含义。

还可以想像得更开阔一些，用它定义时间、长度、面积、加速度、速度、温度等，重载一些计算函数（可惜D还不支持全局操作符重载），这样就方便完成一些物理量的运算了，而且类型得到检查，速度加一个整数值结果还是速度，速度乘时间得到的是长度，时间减时间得到的是时间间隔，速度加时间将产生编译错误。。。。。。神奇的是这些类型可能都是一些简单类型，我相信它至少可以保证运行效率不会太低。当然你用C＋＋类也可以完成这些，并且利用编译器优化让它的效率保持最高，甚至内联的结果就是简单类型的运算，我还是更愿意使用这简单的类型来typedef。当然这可能需要写大量重复的函数重载形式，没有关系，我想使用模板和mixin应该可以简化这一过程，而且会有相当多的家伙们愿意使用这种麻烦的形式来获得更“正确”的编译检查。

所以说，D语言的typedef的意义其实就是实现了矢量类型。

又多想了一点。

强类型要，语法糖也应该要。是不是可以借鉴一下ruby的语法，实现这种调用呢？

Length l = 1.cm;
l = 1.m;
Time t = Time.now;
TimeInterval i = 3.hours;

免去了一些初始化的麻烦。

qiezi 2006-09-19 20:16 发表评论

[D语言] DMD 0.166发布

qiezi — Fri, 01 Sep 2006 14:34:00 GMT

这一版本在强大的民意压力之下取消了上一版的“隐式转换表达式为委托”这一特性，取而代之的是一个lazy关键字。

取消的理由是这个转换太隐晦了，最好是显式地标示出这种转换，所以引入一个lazy关键字。D语言还在发展中，很多特性都在尝试，这种修改也不是第一次了。

首先看看这个lazy。

上一版实现了这样一个特性：

void log(char[] delegate() msg){
writefln(msg());
}

log("Hello, " ~ "Li Jie! \n" ~ "Welcome!");

log的参数被隐式转化为一个委托，这样只有用到这个值的时候才真正求值。

由于这种隐式转化很容易形成陷阱，所以这一版改为一个lazy关键字，看起来要简洁一些了：

void log(lazy char[] msg){
writefln(msg);
}

log("Hello, " ~ "Li Jie! \n" ~ "Welcome!");

log函数中使用msg这个变量就会调用那个隐式的委托，要注意的是每次取msg的值都会执行这个委托，所以我觉得这个陷阱更大了，当然它把陷阱丢给编写代码的人，而不是使用代码的人，所以好坏还无从分辨。

下面这点代码可以演示这个小陷阱：

void foo(lazy int a){
  int b = a+1;
  int c = a*3;
  int d = a/2;
}

int bar(){
  writefln("Call bar()");
  return 12;
}

foo(bar());

看起来bar好像会执行一次，实际上这段代码会打印出3行"Call bar()"，原来使用委托还可以看到一个显式的函数调用呢。

另一个member templates特性未见到文档，猜想大概是支持成员函数模板吧。

qiezi 2006-09-01 22:34 发表评论

[D语言] DMD 0.165发布

qiezi — Mon, 21 Aug 2006 05:24:00 GMT

前几个版本主要是修正BUG，并没有多少新特性，这个版本终于增加了一个“隐式转换表达式到委托”，这个特性也使“懒惰(或延迟)求值”成为可能。

详细信息可见：http://www.digitalmars.com/d/lazy-evaluation.html

它首先解决了一个存在于java中的日志问题，java里面一个写日志标准格式如下：

if (log.isLoggable(Level.INFO)) {
log.info("aaaa");
}

因为log.info的参数求值可能影响性能，所以使用这种繁琐的方式来降低关闭日志时的性能开销。

C/C++使用宏来解决这个问题，唯一的问题是修改日志级别会导致项目必须重编译。

[注：指的是用宏来定义日志级别的方式，使用其它动态修改日志级别的方式对性能要求很高的项目来说可能不可接受]

D语言使用另一种方式来解决，首先要用到“表达式到委托的隐式转换”，下面是委托作为参数时的使用方法：

void foo(char[] delegate() dg){
  writefln(dg());
}

foo( delegate char[] (){
    return "Hello, World";
  }
);

因为这个委托并不需要参数，而返回值可以推导，所以在早先的一个版本里，D允许我们简化这个过程：

void foo(char[] delegate() dg){
writefln(dg());
}

foo({return "Hello, World";});

DMD 0.165允许我们更进一步：

void foo(char[] delegate() dg){
writefln(dg());
}

foo("Hello, World");

这个字符串参数会被隐式转换成一个委托。

现在可以用一样的方法处理日志，在没有宏的系统中，日志函数一般格式如下：

void log(char[] message)
{
if (logging)
fwritefln(logfile, message);
}

为了让它使用懒惰求值这个特性，这里把这个函数的参数改为委托：

void log(char[] delegate() dg)
{
if (logging)
fwritefln(logfile, dg());
}

从上面提到的内容我们知道使用它也很简单：

log("My name is " ~ "Li Jie");

这个参数的求值就是在log函数里面完成的。

当然委托会增加一些开销，在上面这个例子中，这个开销是在日志打开时执行委托所带来的，它增加了一次委托调用的开销，不过好在打开日志功能时，其它方面的开销远大过委托调用。关闭日志时，它不会带来开销，它只是把字符串指针压栈改为委托指针压栈。

qiezi 2006-08-21 13:24 发表评论

[D语言] 用D语言编写Ruby扩展

qiezi — Fri, 18 Aug 2006 22:17:00 GMT

Ruby语言的官方解释程序是使用C语言开发的，一般用C语言来编写扩展。D语言和C语言是二进制兼容的，所以可以使用D语言编写Ruby扩展。

一、移植C库到D的一般过程

C使用头文件来处理符号依赖，在D里面链接外部库文件时，要使用extern (C)声明来引入符号，这是一个转换过程。

如何转换一个C头文件到D文件？D文档的htomodule.html有详尽说明。一般的转换过程如下：

1、运行预处理程序处理掉头文件里面的宏。

2、删除经过预处理以后的多余信息。由于C的头文件包含，每个头文件经过预处理以后都会包含一些重复内容，我们需要剔除这部分内容，通过查找行号即可完成。

3、转换相应声明到D声明，这一步可以使用一个c2h程序来完成。

注意预处理程序处理完毕以后，宏函数以及宏定义的常量会被去除，这可能不是你想要的，所以最好的办法可能是手工转换。

另一种调用是在D里面调用动态链接库，这需要你使用implib工具从动态链接库产生一个.lib导入库文件，然后生成D声明，再编译链接即可。如果是在linux下使用共享库，则只需要编写D声明文件，然后直接链接即可。

二、调用C库

转换完毕以后，就可以调用了。如果你只是要测试一下，就可以只声明使用过的外部函数、变量即可。

例如我们要编写Programming Ruby里面的一个Ruby Extension例子，相应的D代码如下：

// test.d
module test;

import ruby;

extern (C)
VALUE t_init(VALUE self)
{
  VALUE arr = rb_ary_new();
  rb_iv_set(self, " @arr " , arr);
   return self;
}

extern (C)
VALUE t_add(VALUE self, VALUE anObject)
{
  VALUE arr = rb_iv_get(self, " @arr " );
  rb_ary_push(arr, anObject);
   return arr;
}

extern (C){

VALUE cTest;

alias VALUE( * func_type)();

export void Init_Test()
{
  cTest = rb_define_class( " Test " , rb_cObject);
  rb_define_method(cTest, " initialize " , cast(func_type) & t_init, 0 );
  rb_define_method(cTest, " add " , cast(func_type) & t_add, 1 );
}

}   // extern(C)

和C代码很相似。由于我们只使用了几个外部函数、变量，所以只需要声明这几个符号即可：

// ruby.d
module ruby;

extern (C){
    alias ulong VALUE;
    VALUE rb_cObject;
    VALUE rb_ary_new ();
    VALUE rb_ary_push (VALUE, VALUE);
    VALUE rb_iv_set (VALUE,   char * , VALUE);
    VALUE rb_iv_get (VALUE,   char * );
    VALUE rb_define_class ( char * ,VALUE);
     void rb_define_method (VALUE, char * ,VALUE( * )(), int );
}

三、生成动态链接库(Windows DLL)或共享库(Linux so文件)

D语言在Windows上编写DLL，除了要有D源文件以外，还要有DLL定义文件：

// test.def
LIBRARY         Test
DESCRIPTION      ' Test written in D '

EXETYPE  NT
CODE            PRELOAD DISCARDABLE
DATA            PRELOAD SINGLE

这是一个通用的格式，只是一些描述信息，因为D中可以使用export关键字导出符号，所以不需要在这里声明导出函数，只有在编写COM DLL时才会增加其它一些信息。

另外由于D语言要初始化GC以及其它一些信息，所以还需要在DllMain里面调用初始化及终止代码。由于不同平台的初始化过程不完全相同，这里我简单封闭了一下不同平台的初始化代码：

// os/library.d
module os.library;

extern (C){
   void gc_init();
   void gc_term();
  version(Windows) void _minit();
   void _moduleCtor();
   void _moduleDtor();
   void _moduleUnitTests();
  version(linux) void _STI_monitor_staticctor();
  version(linux) void _STI_critical_init();
  version(linux) void _STD_monitor_staticdtor();
  version(linux) void _STD_critical_term();
}

extern (C)
void d_init()
{
   // writefln("Start init D runtime");
  version(linux) _STI_monitor_staticctor();
  version(linux) _STI_critical_init();
  gc_init();
  version(Windows) _minit();
  _moduleCtor();
  _moduleUnitTests();
   // writefln("init finished");
}

extern (C)
void d_fini()
{
   // writefln("Start term D runtime");
  _moduleDtor();
  gc_term();
  version(linux) _STD_critical_term();
  version(linux) _STD_monitor_staticdtor();
   // writefln("term finished");
}

现在可以为Windows编写初始化及终止代码：

// os/dll.d
module os.dll;

private import os.library;
private import std.c.windows.windows;

HINSTANCE g_hInst;

extern (Windows)
BOOL DllMain(HINSTANCE hInstance, ULONG ulReason, LPVOID pvReserved)
{
   switch (ulReason)
  {
     case DLL_PROCESS_ATTACH:
      d_init();
       break ;

     case DLL_PROCESS_DETACH:
      d_fini();
       break ;

     case DLL_THREAD_ATTACH:
     case DLL_THREAD_DETACH:
       // Multiple threads not supported yet
       return false ;
  }
  g_hInst = hInstance;
   return true ;
}

由于Linux共享库并没有标准的入口函数(或是我不知道它)，这里使用gcc扩展的初始、终止代码，不过是以C语言实现的：

// os/so.c
#include < ruby.h >
static void so_init( void ) __attribute__((constructor));
static void so_fini( void ) __attribute__((destructor));

extern void d_init( void );
extern void d_fini( void );

void so_init( void )
{
d_init();
}

void so_fini( void )
{
d_fini();
}

现在可以尝试编译链接，在Linux上编译命令如下：

gcc - o os / so.o - c os / so.c - I / usr / lib / ruby / 1.8 / i686 - linux
gdc - o Test.so test.d os / so.o ruby.d - shared - fPIC - lruby

你可以在irb下测试：

require ' Test '
test = Test. new
test.add( 1 )
test.add( 2 )
test.add( " a " )

可以看到add总是返回一个array，与期望结果一致。

使用gdc是因为dmd在linux上无法生成共享库。

在Windows上的编译命令如下：

dmd - oftest.dll test.d test.def ruby18.lib os / dll.d os / library.d

ruby18.lib是使用implib从msvcrt-ruby18.dll导出的，这个编译过程很顺利，不过不幸的是它运行有一些问题，大概是一些初始值错误，我暂时还没有找到原因。或许也应该尝试一下gdc，不过我不知道如何从.DLL文件导出一个gdc支持的ELF格式的导入库文件。

四、项目打算

打算建立一个rubyd项目，除了转换ruby头文件以外，还要作一些扩展，比如转换D类到ruby类，这方面已有借鉴，比如dsource.org上的pyd项目。

由于以前在建立项目方面有过失败经历(asgard项目由于兴趣转移和其它原因比如语法丑陋等而未能进行)，这次还是保守一些，先完成D声明的转换，我已经使用工具转换了所有头文件，不过正如前面所说，宏函数和宏常量都丢失了，所以需要重新手工转换。

五、其它问题

1、如何从.DLL文件导出一个gdc支持的ELF格式的导入库文件？如果你知道可以告诉我，先谢过了。

2、dmd生成可执行文件问题不大，生成动态链接库或共享库有很大缺陷，特别是不能生成共享库，我可不想再找一个只能再Windows上正常运行的编译器。如何让它改进这些方面？

3、gdc使用dmd前端和gcc后端，应该会成熟一些，不过一般会比dmd前端版本稍低，而且gdc发布版本不是很频繁，大概4-5个dmd版本才会有一个gdc版本(初略计算)，所以一些新特性不能够及时加入进来。

qiezi 2006-08-19 06:17 发表评论

COM接口IDL转换为D接口以及__uuidof实现。

qiezi — Tue, 11 Apr 2006 06:26:00 GMT

D语言里面，可以通过version(Windows)来兼容COM接口，不过对于__uuidof却没有相应实现。

原始COM接口定义类似这样（找个简单的）：

[
    local,
    object,
    uuid(594f31d0-7f19-11d0-b194-00a0c90dc8bf)
]
interface IRpcChannelBuffer2 : IRpcChannelBuffer
{

    HRESULT GetProtocolVersion
    (
        [in,out] DWORD *pdwVersion
    );
}

VC＋＋中可通过__uuidof操作符来获取COM接口中的uuid“元”信息。

转换为D接口后代码如下：

version(Windows) {

interface IRpcChannelBuffer2 : IRpcChannelBuffer
{
HRESULT GetProtocolVersion (DWORD* pdwVersion);
}

}

失去了uuid信息。只要稍作修改，在转换时保存uuid，即可以模板来模拟实现__uuidof操作符。

import std.c.windows.com;
import std.string;
import std.stdio;

private:

template HexStrToUbyte(char[] str)
{
    const ubyte HexStrToUbyte = cast(ubyte)HexStrToUlong!(str);
}

template HexStrToUshort(char[] str)
{
    const ushort HexStrToUshort = cast(ushort)HexStrToUlong!(str);
}

template HexStrToUint(char[] str)
{
    const uint HexStrToUint = cast(uint)HexStrToUlong!(str);
}

template HexStrToUlong(char[] str)
{
    static if (str.length == 1)
        const ulong HexStrToUlong = HexToUbyte!(str[0..1]);
    else
        const ulong HexStrToUlong
            = HexToUbyte!(str[length-1..length])
              + 16UL * HexStrToUlong!(str[0..length-1]);
}

private:

template HexToUbyte(char[] c)
{
    static if (c[0] >= '0' && c[0] <= '9')
        const ubyte HexToUbyte = c[0] - '0';
    else static if (c[0] == 'A' || c[0] == 'a')
        const ubyte HexToUbyte = 0xa;
    else static if (c[0] == 'B' || c[0] == 'b')
        const ubyte HexToUbyte = 0xb;
    else static if (c[0] == 'C' || c[0] == 'c')
        const ubyte HexToUbyte = 0xc;
    else static if (c[0] == 'D' || c[0] == 'd')
        const ubyte HexToUbyte = 0xd;
    else static if (c[0] == 'E' || c[0] == 'e')
        const ubyte HexToUbyte = 0xe;
    else static if (c[0] == 'F' || c[0] == 'f')
        const ubyte HexToUbyte = 0xf;
}

template HexToUbyte_bug(char c)
{
    static if (c >= '0' && c <= '9')
        const ubyte HexToUbyte1 = c - '0';
    else static if (c == 'A' || c == 'a')
        const ubyte HexToUbyte1 = 0xa;
    else static if (c == 'B' || c == 'b')
        const ubyte HexToUbyte1 = 0xb;
    else static if (c == 'C' || c == 'c')
        const ubyte HexToUbyte1 = 0xc;
    else static if (c == 'D' || c == 'd')
        const ubyte HexToUbyte1 = 0xd;
    else static if (c == 'E' || c == 'e')
        const ubyte HexToUbyte1 = 0xe;
    else static if (c == 'F' || c == 'f')
        const ubyte HexToUbyte1 = 0xf;
}

template IIDFromStr(char[] str)
{
    const IID IIDFromStr = {
        HexStrToUint!(str[0..8]),
        HexStrToUshort!(str[9..13]),
        HexStrToUshort!(str[14..18]),
        [
          HexStrToUbyte!(str[19..21]),
          HexStrToUbyte!(str[21..23]),
          HexStrToUbyte!(str[24..26]),
          HexStrToUbyte!(str[26..28]),
          HexStrToUbyte!(str[28..30]),
          HexStrToUbyte!(str[30..32]),
          HexStrToUbyte!(str[32..34]),
          HexStrToUbyte!(str[34..36])
        ]
    };
}

template __uuidof(T:IUnknown)
{
    IID __uuidof = IIDFromStr!("00000000-0000-0000-C000-000000000046");
}

template __uuidof(T:IClassFactory)
{
    IID __uuidof = IIDFromStr!("00000001-0000-0000-C000-000000000046");
}

void main()
{
    IID iu  = __uuidof!(IUnknown);
    IID icp = __uuidof!(IClassFactory);

    writefln(iu.Data1);
    writefln(iu.Data2);
    writefln(iu.Data3);
    writefln(iu.Data4);
}

如上面代码，接口在转换时，把：

[
    local,
    object,
    uuid(594f31d0-7f19-11d0-b194-00a0c90dc8bf)
]
interface IRpcChannelBuffer2 : IRpcChannelBuffer
{

    HRESULT GetProtocolVersion
    (
        [in,out] DWORD *pdwVersion
    );
}

转换为：

template __uuidof(T:IRpcChannelBuffer2)
{
IID __uuidof = IIDFromStr!("594f31d0-7f19-11d0-b194-00a0c90dc8bf");
}
version (Windows) {

interface IRpcChannelBuffer2 : IRpcChannelBuffer {
HRESULT GetProtocolVersion (DWORD* pdwVersion);
}

}

即可，这个可以交由自动化工具完成。

由于__uuidof模板值在编译期决议，没有实际的运行期开销。

qiezi 2006-04-11 14:26 发表评论