htomodule.dd

Ddoc

$(D_S C の $(D .h) ファイルから D のモジュールへの変換,

	D は Cのソースコードを直接コンパイルすることはできませんが、
	Cへのインターフェイスを書いたり、Cのオブジェクトファイルとリンクしたり、
	DLL内のC関数を呼び出したりするのは簡単です。
	Cのコードへのインターフェイスは通常、$(D .h) ファイルにあります。
	ですからCのコードと接続するには、Cの $(D .h) ファイルを D
	のモジュールへと変換する必要があります。しかしこれは、
	人間の判断が必須な部分が少なからずあるため、
	機械的に行うのは難しい作業です。
	以下は、このような変換作業のガイドとなっています。

<h4>プリプロセッサ</h4>

	$(D .h) ファイルは時々、
	$(D #include) や $(D #ifdef) のようなマクロが何層にも重なった泥沼状態になっていることがあります。
	D は C のようなテキストプリプロセッサを持たないので、
	マクロを取り除くには、
	まずプリプロセッサの出力を取ってくることになります。DMC (Digital
	Mars C/C++ compiler) では、コマンド：

$(CONSOLE
<a href="http://www.digitalmars.com/ctg/sc.html">dmc</a> <a href="http://www.digitalmars.com/ctg/sc.html#dashc">-c</a> program.h <a href="http://www.digitalmars.com/ctg/sc.html#dashe">-e</a> <a href="http://www.digitalmars.com/ctg/sc.html#dashl">-l</a>
)

	によって、全てのプリプロセスを終えた後のファイルが $(D program.lst)
	として生成されます。
	<p>

	$(D #if), $(D #ifdef), $(D #include),
	などの文は全て取り除いてください。

<h4>リンケージ</h4>

	一般に、Cのリンケージを付与するには：

---------------------------
extern (C)
{
     /* ...ファイルの内容... */
}
---------------------------

	モジュール全体を上のように囲んで下さい。

<h4>型</h4>

	ファイル全体に検索と置換をかけることで、
	Cの型をDの型へ改名できるでしょう。
	以下の表が、32bitのCのコードからの典型的な対応表になっています。
	<p>

	$(TABLE1
	<caption>Cの型からDの型への対応</caption>
	<tr>
	<th>C での型
	<th>D での型
	<tr>
	<td>long double
	<td>real
	<tr>
	<td>unsigned long long
	<td>ulong
	<tr>
	<td>long long
	<td>long
	<tr>
	<td>unsigned long
	<td>uint
	<tr>
	<td>long
	<td>int
	<tr>
	<td>unsigned
	<td>uint
	<tr>
	<td>unsigned short
	<td>ushort
	<tr>
	<td>signed char
	<td>byte
	<tr>
	<td>unsigned char
	<td>ubyte
	<tr>
	<td>wchar_t
	<td>wchar or dchar
	<tr>
	<td>bool
	<td>bool, byte, int
	<tr>
	<td>size_t
	<td>size_t
	<tr>
	<td>ptrdiff_t
	<td>ptrdiff_t
	)

<h4>NULL</h4>

	$(D NULL) や $(D ((void*)0)) は
	$(D null) に置き換えます。

<h4>数値リテラル</h4>

	数値リテラルの接尾辞  $(SINGLEQUOTE L) や $(SINGLEQUOTE l) は取り除きます。
	これは、C の $(D long) は （通常）D の $(D int) と同じサイズだからです。
	同様に、接尾辞 $(SINGLEQUOTE LL)
	は単独の $(SINGLEQUOTE L) に置き換えるべきです。
	接尾辞 $(SINGLEQUOTE u) は全て D でも同様に働きます。

<h4>文字列リテラル</h4>

	ほとんどの場合、接頭辞 $(SINGLEQUOTE L) は単純に消して構いません。
	D では、文字列は必要なときに暗黙にワイド文字列へ変換されます。
	しかし、

$(CCODE
L"string"
)

	これをこう置き換えることもできます：

---------------------------
"string"w	// ワイド文字が16bitの環境
"string"d	// ワイド文字が32bitの環境
---------------------------

<h4>マクロ</h4>

	次のような一連のマクロは：

$(CCODE
#define FOO	1
#define BAR	2
#define ABC	3
#define DEF	40
)

	次で代用します：

---------------------------
enum
{   FOO = 1,
    BAR = 2,
    ABC = 3,
    DEF = 40
}
---------------------------

	あるいは：

---------------------------
const int FOO = 1;
const int BAR = 2;
const int ABC = 3;
const int DEF = 40;
---------------------------

	あるいは：

$(CCODE
#define MAX(a,b) ((a) < (b) ? (b) : (a))
)

	のようなものは、関数で置き換えることができます：

---------------------------
int MAX(int a, int b) { return (a < b) ? b : a; }
---------------------------

	<!-- 以下のtipsは Jarrett Billingsley による -->

	関数を使う方法は、しかし、実行時ではなくコンパイル時に評価されなければならない、
	静的初期化子の中では使用することができません。
	コンパイル時については、テンプレートが使えます：

$(CCODE
#define GT_DEPTH_SHIFT  (0)
#define GT_SIZE_SHIFT   (8)
#define GT_SCHEME_SHIFT (24)
#define GT_DEPTH_MASK   (0xffU << GT_DEPTH_SHIFT)
#define GT_TEXT         ((0x01) << GT_SCHEME_SHIFT)

/* graphtypeを構築するマクロ */
#define GT_CONSTRUCT(depth,scheme,size) \
	((depth) | (scheme) | ((size) << GT_SIZE_SHIFT))

/* 一般的なgraphtype */
#define GT_TEXT16  GT_CONSTRUCT(4, GT_TEXT, 16)
)

	対応する D のコードは:

---------------------------
const uint GT_DEPTH_SHIFT  = 0;
const uint GT_SIZE_SHIFT   = 8;
const uint GT_SCHEME_SHIFT = 24;
const uint GT_DEPTH_MASK   = 0xffU << GT_DEPTH_SHIFT;
const uint GT_TEXT         = 0x01 << GT_SCHEME_SHIFT;

// graphtypeを構築するテンプレート
template GT_CONSTRUCT(uint depth, uint scheme, uint size)
{
 // 定数の名前をテンプレートの名前と同じにする
 const uint GT_CONSTRUCT = (depth | scheme | (size << GT_SIZE_SHIFT));
}

// 一般的なgraphtype
const uint GT_TEXT16 = GT_CONSTRUCT!(4, GT_TEXT, 16);
---------------------------


<h4>宣言リスト</h4>

	D では、宣言のリストの中で型を変更することを許しません。
	したがって：

$(CCODE
int *p, q, t[3], *s;
)

	は次のように書かれなければなりません：

---------------------------
int* p, s;
int q;
int[3] t;
---------------------------

<h4>void引数リスト</h4>

	引数を１個もとらない関数：

$(CCODE
int foo(void);
)

	は、Dでは：

---------------------------
int foo();
---------------------------

$(V1

<h4>const 型修飾子</h4>

	D の $(D const) は記憶域クラスであり、型修飾子ではありません。従って、
	型修飾子としての $(D const) は全て取り除きます。

$(CCODE
void foo(const int *p, char *const q);
)

	は、こうなります：

---------------------------
void foo(int* p, char* q);
---------------------------
)
<h4>外部グローバル C 変数</h4>

	Dでは常にグローバル変数の宣言は、同時に変数の定義でもあります。
	しかし、リンクするCで作ったオブジェクトファイルの中にも定義があると、
	多重定義エラーとなってしまいます。この問題を解決するには、
	extern 記憶クラスを使うという手があります。
	例えば、こんなCのヘッダーファイル
	$(D foo.h) は:

$(CCODE
struct Foo { };
struct Foo bar;
)

	これは次のようなDのモジュールに置き換えられます。$(D foo.d):

---------------------------
struct Foo { }
extern (C)
{
    extern Foo bar;
}
---------------------------


<h4>Typedef</h4>

	D では、$(D alias) が C の $(D typedef) と同じ働きをします。

$(CCODE
typedef int foo;
)

	は、こうします：

---------------------------
alias int foo;
---------------------------

<h4>構造体</h4>

	次のような宣言は：

$(CCODE
typedef struct Foo
{   int a;
    int b;
} Foo, *pFoo, *lpFoo;
)

	こう置き換えます：

---------------------------
struct Foo
{   int a;
    int b;
}
alias Foo* pFoo, lpFoo;
---------------------------

<h4>構造体メンバのアラインメント</h4>

	D の普通の実装では、構造体のメンバは同じ環境の C
	コンパイラと同様に整列するようになっています。しかし、
	$(D .h) ファイルの中にアラインメントを制御する $(D #pragma)
	が含まれている場合は、Dの $(D align) 属性で対応します：

$(CCODE
#pragma pack(1)
struct Foo
{
    int a;
    int b;
};
#pragma pack()
)

	becomes:

---------------------------
struct Foo
{
  align (1):
    int a;
    int b;
}
---------------------------

<h4>ネストした構造体</h4>

$(CCODE
struct Foo
{
    int a;
    struct Bar
    {
	int c;
    } bar;
};

struct Abc
{
    int a;
    struct
    {
	int c;
    } bar;
};
)

	は、こうなります：

---------------------------
struct Foo
{
    int a;
    struct Bar
    {
	int c;
    }
    Bar bar;
}

struct Abc
{
    int a;
    struct
    {
	int c;
    }
}
---------------------------

<h4>$(D __cdecl), $(D __pascal), $(D __stdcall)</h4>

$(CCODE
int __cdecl x;
int __cdecl foo(int a);
int __pascal bar(int b);
int __stdcall abc(int c);
)

	は、こうなります：

---------------------------
extern (C) int x;
extern (C) int foo(int a);
extern (Pascal) int bar(int b);
extern (Windows) int abc(int c);
---------------------------

<h4>$(D __declspec(dllimport))</h4>

$(CCODE
__declspec(dllimport) int __stdcall foo(int a);
)

	は、こうなります：

---------------------------
export extern (Windows) int foo(int a);
---------------------------

<h4>$(D __fastcall)</h4>

	残念なことに、D は $(D __fastcall) 呼び出し規約に対応していません。
	このため、緩衝コードが一段必要になります。Cで書いた：

$(CCODE
int __fastcall foo(int a);

int myfoo(int a)
{
    return foo(int a);
}
)

	を $(D __fastcall) をサポートするCコンパイラでコンパイルしてリンクするか、
	それを
	<a href="http://www.digitalmars.com/ctg/obj2asm.html">obj2asm</a>
	で逆アセンブルして D の $(D myfoo) の中に
	<a href="iasm.html">インラインアセンブラ</a> で挿入することになります。

)

Macros:
	TITLE=C の .h ファイルから D のモジュールへの変換
	WIKI=HToModule
	CATEGORY_HOWTOS=$0