#ifdef __cplusplus

/* C++ 言語の場合 */
#define HIDEMARU_MACRO_DLL extern "C" __declspec(dllexport)

#else /* __cplusplus */

/* C 言語の場合 */
#define HIDEMARU_MACRO_DLL __declspec(dllexport)

#endif /* __cplusplus */ 

#include <windows.h>

/* これを忘れると gcc でコンパイルした時に DllMain が実行されない */
#ifdef __cplusplus
extern "C" {
#endif

/*
 * DLLエントリポイント関数の型と典型的なスケルトンコード
 */
BOOL APIENTRY /* int __stdcall */
DllMain(HINSTANCE hInstance, DWORD ul_reason_for_call, LPVOID pParam)
{
    switch (ul_reason_for_call) {
    case DLL_PROCESS_ATTACH:
        /* ここにグローバル変数等の初期化コードを書く */
        /* ※loaddll でDLLをロードした時はここが実行される */
        break;
    
    case DLL_PROCESS_DETACH:
        /* ここにグローバル変数等の後始末コードを書く */
        /* ※freedll でDLLをアンロードした時はここが実行される */
        break;
    
    case DLL_THREAD_ATTACH:
        /* ここにスレッド毎に必要な変数等の初期化コードを書く */
        break;
    
    case DLL_THREAD_DETACH:
        /* ここにスレッド毎に必要な変数等の後始末コードを書く */
        break;
    }
    return TRUE;
}

#ifdef __cplusplus
}
#endif

/* hello_world.c */

HIDEMARU_MACRO_DLL /* __declspec(dllexport) */
LPCSTR hello(void) /* LPCSTR は const char* の typedef */
{
    return "hello world!";
}

// テスト用マクロ

loaddll "hello_world.dll"; // 作成したDLLのロード

message dllfuncstr("hello"); // hello() の呼出し

freedll; // DLLのアンロード

/* hello2.c */

HIDEMARU_MACRO_DLL
LPCSTR hello(void)
{
    char buf[13]; /* スタックに配列を確保 */
    
    lstrcpy(buf,"hello world!"); /* スタック上の配列に文字列をコピー */
    
    return buf; /* おっとっと… */
}

/* hello3.c */

#include <stdlib.h>

HIDEMARU_MACRO_DLL
LPCSTR hello(void)
{
    char* buf = malloc(13); /* ヒープ領域にメモリを確保 */
    
    lstrcpy(buf,"hello world!"); /* 確保したメモリに文字列をコピー */
    
    return buf; /* おいおい、誰が free(buf) を呼ぶんだ？ */
}

/* hello_what.c */

HIDEMARU_MACRO_DLL
LPCSTR hello_what(LPCSTR what)
{
    static char buf[80]; /* 静的にバッファを確保 */

    lstrcpy(buf, "hello "); /* "hello " 部分をコピー */
    lstrcpyn(buf + 6, what, 74); /* 渡された文字列をコピー */

    return buf;
}

/* hello_what2.c */

#include <stdlib.h>

LPSTR pszBuffer; /* ヒープ領域に確保するメモリへのポインタ */
int nBufSize;    /* 確保したメモリのサイズ */

#define BUF_SIZE 16 /* バッファの初期サイズ */

/* DLLエントリポイント関数 */
BOOL APIENTRY
DllMain(HINSTANCE hInstance, DWORD ul_reason_for_call, LPVOID pParam)
{
    switch (ul_reason_for_call) {
    case DLL_PROCESS_ATTACH:
        /* loaddll された時に実行される */
        nBufSize = BUF_SIZE;
        pszBuffer = malloc(BUF_SIZE); /* 初期サイズでバッファを確保 */
        break;
    case DLL_PROCESS_DETACH:
        /* freedll された時に実行される */
        free(pszBuffer); /* ヒープ領域に確保したメモリを開放 */
        break;
    }
    return TRUE;
}

#define HEADER_SIZE 6  /* "hello " の文字数 */

/* "hello " + what を返す(エラーの時は "" を返す) */
HIDEMARU_MACRO_DLL
LPCSTR hello_what(LPCSTR what)
{
    int len;
    
    if (IsBadStringPtr(what,1)) return ""; /* 引数が無効 */
    
    len = lstrlen(what) + HEADER_SIZE + 1; /* 戻り値に必要なメモリサイズ */
    if (len > nBufSize) {
        /* 現在のバッファではサイズが足らないのでメモリを(再)確保 */
        
        free(pszBuffer); /* 古いメモリを開放 */
        pszBuffer = malloc(len); /* 新たにヒープ領域にメモリを確保 */
        if (pszBuffer == NULL) return ""; /* no memory */
        nBufSize = len; /* 確保したバッファのサイズを記憶 */
        lstrcpy(pszBuffer, "hello "); /* ヘッダをコピー */
    }
    
    /* "hello " の後ろに what の内容をコピー */
    lstrcpy(pszBuffer + HEADER_SIZE, what);
    
    return pszBuffer;
}

// テスト用マクロ

loaddll "hello_what.dll"; // ヒープ領域にメモリが確保される

// 初回の呼出し…文字数が少ないので最初に確保したメモリがそのまま使われる
message dllfuncstr("hello_what","world!!");

// 現在のバッファのサイズより文字数が多いので新たにメモリを確保
message dllfuncstr("hello_what","の訳は「ハロー」です");

freedll; // 最後に確保したメモリはここで開放される

/* sprintf.c */

#include <stdarg.h> /* マクロ va_???() の定義 */

#define MAX_BUF 1024 /* バッファサイズ(もう少し大きい方がいい？) */
char buf[MAX_BUF]; /* バッファは静的に確保 */

HIDEMARU_MACRO_DLL
LPCSTR sprintf(LPCSTR fmt, ...)
{
    buf[0] = '\0'; /* 不正な引数の場合は "" を返す */
    
    if (!IsBadStringPtr(fmt,1)) {
        va_list args; /* 可変個の引数を扱うためのデータ型 */
        
        va_start(args,fmt); /* args を初期化する */
        wvsprintf(buf,fmt,args); /* API に丸投げ(^^; */
        va_end(args); /* パラメータのスキャンを終了 */
    }
    
    return buf;
}

/* sprintf2.c */

#include <stdarg.h>

#define MAX_BUF 1024
char buf[MAX_BUF];

/*
    本来なら文字列長がバッファサイズを越えない様に
    チェックをする必要があるが、今回は簡潔さのためにばっさり省略してある
 */
HIDEMARU_MACRO_DLL
LPCSTR sprintf2(LPCSTR fmt, ...)
{
    va_list args; /* 可変個の引数を扱うためのデータ型 */
    LPSTR ptr = buf; /* バッファを埋めるためのポインタ */
    LPCSTR str;
    int len;
    
    if (IsBadStringPtr(fmt,1)) return ""; /* 不正な引数の場合 */
    
    va_start(args,fmt); /* args を fmt の次を指すように初期化する */
    while (*fmt != '\0') {
        if (IsDBCSLeadByte(*fmt)) {
            /* ２バイト文字の場合 */
            *ptr++ = *fmt++;
            *ptr++ = *fmt++;
        } else if (*fmt == '%') {
            /* 書式指定文字の場合 */
            /* va_arg() マクロの第１引数に args (va_list)、
               第２引数に変数型を指定すると、
               指定した型の値を返し、
               args が次のパラメータを指すように変更される。
               なお、文字列への変換は wsprintf() に丸投げ(^^; */
            switch (*++fmt) {
            case 'd':
                /* 10進整数 */
                len = wsprintf(ptr, "%d", va_arg(args, int));
                if (len < 2) return "";
                ptr += len;
                break;
            case 'x':
                /* 16進整数 */
                len = wsprintf(ptr, "%x", va_arg(args, int));
                if (len < 2) return "";
                ptr += len;
                break;
            case 's':
                /* 文字列 */
                str = va_arg(args, LPCSTR);
                /* ポインタの正当性チェック */
                if (IsBadStringPtr(str,1)) return "";
                len = wsprintf(ptr, "%s", str);
                if (len < 2) return "";
                ptr += len;
                break;
            default:
                /* その他の場合はそのままコピー */
                *ptr++ = *fmt;
            }
            fmt++;
        } else {
            /* 普通の文字の場合 */
            *ptr++ = *fmt++;
        }
    }
    *ptr = '\0'; /* NULL 文字で終端させる */
    va_end(args); /* args を NULL にしてパラメータのスキャンを終了 */
    
    return buf;
}

// テストマクロ

loaddll "sprintf.dll";

// 現在の tickcount 値を保存
#n = tickcount;

// wvsprintf() 丸投げ版
message dllfuncstr("sprintf","現在の tick = 0x%08x",#n);

// 自作版
message dllfuncstr("sprintf2","%s の場合は %d です","１０進数",#n);

freedll;

/* n1 〜 nN の数値の最大値を返す */
int max(int N, int n1, ...); 

/* destfile に srcfile 以下を追加する。引数の最後は "" で終わること！！ */
int cat(LPCSTR destfile, LPCSTR srcfile, ...); 

// getfilename.cpp

HIDEMARU_MACRO_DLL // extern "C" __declspec(dllexport)
LPCSTR getfilename(int hWnd, LPCSTR inidir, LPCSTR inifile)
{
    static char buf[MAX_PATH]; // 今回は静的にバッファを確保
    
    buf[0] = '\0';
    // パラメータの正当性チェックをお忘れなく
    if (::IsBadStringPtr(inidir, 1) || ::IsBadStringPtr(inifile, 1)) {
        return buf;
    }
    if (!::IsWindow(reinterpret_cast<HWND>(hWnd))) hWnd = 0;
    
    // 初期ファイル名
    lstrcpy(buf,inifile);
    
    // GetOpenFileName() に渡す OPENFILENAME 構造体の設定
    OPENFILENAME ofn;
    ::ZeroMemory(&ofn, sizeof(ofn));
    ofn.lStructSize = sizeof(ofn);
    ofn.hwndOwner = reinterpret_cast<HWND>(hWnd);
    ofn.lpstrFilter = "全てのファイル (*.*)\0*.*\0";
    ofn.nFilterIndex = 1;
    ofn.lpstrFile = buf;
    ofn.nMaxFile = MAX_PATH;
    ofn.Flags = OFN_HIDEREADONLY|OFN_EXPLORER|OFN_NOCHANGEDIR;
    ofn.lpstrInitialDir = *inidir ? inidir : 0;
    
    // ダイアログの表示(キャンセルの場合は "" を返す)
    if (!::GetOpenFileName(&ofn)) buf[0] = '\0';
    
    return buf;
}

loaddll "getfilename.dll";

// 第１パラメータにはオーナーウィンドウのウィンドウハンドルを指定する
message dllfuncstr("getfilename",hidemaruhandle(0),hidemarudir,"foo.txt");

freedll;

// show_window.cpp

WNDPROC wc; // ウィンドウクラスの登録とインスタンスハンドルの保持に使用

// ウィンドウのコールバック関数
// 殆ど何もしてない(終了処理だけ)
HRESULT CALLBACK
MyWindowProc(HWND hWnd, UINT uMsg, WPARAM wParam, LPARAM lParam)
{
    switch (uMsg) {
    case WM_CLOSE:
        ::DestroyWindow(hWnd);
        break;
    case WM_DESTROY:
        ::PostQuitMessage(0); // この API 呼出しでメッセージループが終了
        break;
    default:
        return ::DefWindowProc(hWnd, uMsg, wParam, lParam);
    }
    return 0;
}

// extern "C" を忘れると gcc の場合に DllMain が呼び出されなくなる
extern "C" BOOL APIENTRY
DllMain(HINSTANCE hInstance, DWORD ul_reason_for_call, LPVOID)
{
    // DLL のインスタンスハンドルをここで取得する
    switch (ul_reason_for_call) {
    case DLL_PROCESS_ATTACH:
        // ウィンドウクラスの登録
        ::ZeroMemory(&wc, sizeof(wc));
        wc.style = CS_HREDRAW | CS_VREDRAW;
        wc.lpfnWndProc = (WNDPROC)MyWindowProc;
        wc.hInstance = hInstance; // DLL のインスタンスハンドルを指定する
        wc.hbrBackground = (HBRUSH)(COLOR_WINDOW + 1);
        wc.lpszClassName = "HidemaruMacroDLL_Sample";
        return ::RegisterClass(&wc) != 0;
        
    case DLL_PROCESS_DETACH:
        // ウィンドウクラスの登録を削除
        ::UnregisterClass(wc.lpszClassName, wc.hInstance);
        return TRUE;
        
    default:
        break;
    }
    return TRUE;
}


// ウィンドウを表示するDLL関数
HIDEMARU_MACRO_DLL
int show_window(LPCSTR title)
{
    // この関数の中で行っていることは普通のウィンドウアプリケーションが
    // WinMain() で行っている処理とほぼ同じ
    // (ウィンドウクラスの登録は DllMain() 内で行っているため不要)
    
    // ウィンドウの表示
    HWND hWnd = ::CreateWindow(wc.lpszClassName,
                               title,
                               WS_OVERLAPPEDWINDOW | WS_POPUP,
                               CW_USEDEFAULT, CW_USEDEFAULT,
                               400, 300,
                               NULL,
                               NULL,
                               wc.hInstance, // DLL のインスタンスハンドル
                               NULL);
    if (hWnd == NULL) return -1;
    ::ShowWindow(hWnd, SW_SHOW);
    
    // メッセージループを回す…って勝手にそんなことしてもいいの？？
    MSG msg;
    while (::GetMessage(&msg, NULL, 0, 0)) {
        ::TranslateMessage(&msg);
        ::DispatchMessage(&msg);
    }
    
    return msg.wParam;
}

// show_window2.cpp

WNDCLASS wc; // 表示するウィンドウのウィンドウクラス構造体
HANDLE hThread; // スレッドハンドル
HWND hWndUser;  // ウィンドウハンドル

// ウィンドウのコールバック関数
HRESULT CALLBACK
MyWindowProc(HWND hWnd, UINT uMsg, WPARAM wParam, LPARAM lParam)
{
    switch (uMsg) {
    case WM_CLOSE:
        ::DestroyWindow(hWnd);
        break;
    case WM_DESTROY:
        ::PostQuitMessage(0); // この API 呼出しでスレッドのメッセージループが終了
        break;
    default:
        return ::DefWindowProc(hWnd, uMsg, wParam, lParam);
    }
    return 0;
}

// DLL エントリポイント関数
extern "C" BOOL APIENTRY
DllMain(HINSTANCE hInstance, DWORD ul_reason_for_call, LPVOID pParam)
{
    switch (ul_reason_for_call) {
    case DLL_PROCESS_ATTACH:
        // wc の初期化と登録作業
        ::ZeroMemory(&wc, sizeof(wc));
        wc.style = CS_HREDRAW | CS_VREDRAW;
        wc.lpfnWndProc = (WNDPROC)MyWindowProc;
        wc.hInstance = hInstance; // DLL のインスタンスハンドルを指定する
        wc.hbrBackground = (HBRUSH)(COLOR_WINDOW + 1);
        wc.lpszClassName = "HidemaruMacroDLL_Sample";
        return ::RegisterClass(&wc) != 0;
        
    case DLL_PROCESS_DETACH:
        // 後始末
        if (hWndUser != NULL) {
            ::SendMessage(hWndUser,WM_CLOSE,0,0);
            hWndUser = NULL;
        }
        if (hThread != NULL) {
            ::TerminateThread(hThread,-1);
            ::CloseHandle(hThread);
            hThread = NULL;
        }
        return ::UnregisterClass(wc.lpszClassName, wc.hInstance);
        
    default:
        break;
    }
    return TRUE;
}

// ウィンドウを表示するスレッド関数(::CreateThread() に渡す)
DWORD WINAPI ShowWindowProc(LPVOID pParam)
{
    // ウィンドウの作成
    hWndUser = ::CreateWindow(wc.lpszClassName,
                              (LPCSTR)pParam, // ウィンドウタイトルへのポインタ
                              WS_OVERLAPPEDWINDOW | WS_POPUP,
                              CW_USEDEFAULT, CW_USEDEFAULT,
                              400, 300,
                              NULL,
                              NULL,
                              wc.hInstance, // DLL のインスタンスハンドル
                              NULL);
    if (hWndUser == NULL) ::ExitThread(-1);
    ::ShowWindow(hWndUser, SW_SHOW);
    
    // 別スレッド内でメッセージループを回すのがミソ
    MSG msg;
    while (::GetMessage(&msg, NULL, 0, 0)) {
        ::TranslateMessage(&msg);
        ::DispatchMessage(&msg);
    }
    ::ExitThread(msg.wParam);
    return -1; // 有り得ないはず
}


// ウィンドウを表示するDLL関数
// ウィンドウが閉じられたことは wait_close() を呼び出すことで判断する
HIDEMARU_MACRO_DLL
int show_window(LPCSTR title)
{
    // 既にウィンドウを表示中の場合は関数は失敗する
    if (hThread != NULL || ::IsBadStringPtr(title, 1)) return -1;
    
    // ウィンドウの表示を行うスレッドを開始させる
    DWORD dwThreadID = 0;
    hThread = ::CreateThread(NULL, 0,
                            (LPTHREAD_START_ROUTINE)ShowWindowProc,
                            (LPVOID)title, // ShowWindowProc の引数
                            0,
                            &dwThreadID);
    
    return hThread != NULL;
}

// スレッドの終了コードを文字列で返すDLL関数
// time ミリ秒待ってもスレッドが終了しない場合は "" を返す
// 何らかのエラーの場合は "-1" を返す
HIDEMARU_MACRO_DLL
LPCSTR wait_close(int time)
{
    static char buf[32];
    
    // スレッドはまだ走っていない
    if (hThread == NULL) return "-1";
    
    buf[0] = '\0';
    if (::WaitForSingleObject(hThread, time) == WAIT_OBJECT_0) {
        // スレッドが終了した
        DWORD dwRetCode = -1;
        ::GetExitCodeThread(hThread, &dwRetCode);
        ::CloseHandle(hThread);
        hThread = NULL;
        hWndUser = NULL;
        wsprintf(buf, "%ld", (long)dwRetCode);
    }
    
    return buf;
}

// ウィンドウタイトルを動的に変更するDLL関数
HIDEMARU_MACRO_DLL
int settitle(LPCSTR str)
{
    if (::IsBadStringPtr(str, 1) || hWndUser == NULL) return 0;
    return ::SetWindowText(hWndUser, str);
}

// ウィンドウを表示し、閉じられた時のリターンコードを返すDLL関数
// 要するに前のサンプルと同じモーダルウィンドウだが、
// 呼出し側のプロセスを止めてしまうので背後の秀丸エディタウィンドウの描画がされなくなる
HIDEMARU_MACRO_DLL
int do_modal(LPCSTR title)
{
    if (!show_window(title)) return -1;
    return atoi(wait_close(INFINITE));
}

loaddll "win_test.dll";

// ウィンドウの表示テストその１
if (!dllfunc("show_window","ウィンドウのテスト１")) {
    message "ウィンドウの表示に失敗";
} else {
//  disablebreak; // 再描画も禁止されるのでコメントアウト
    $ret = ""; // wait_close() からの戻り値
    ##sec = 0; // 経過秒数を保存する変数
    ##start = tickcount; // 開始時刻
    
    // ウィンドウの終了を wait_close() の戻り値で判断しながら、
    // １秒毎にウィンドウタイトルを書き換える処理
    while ($ret == "") { // ウィンドウが閉じたら "" 以外が返る
        ##now = (tickcount - ##start) / 1000; // 経過秒数
        if (##now > ##sec) {
            // ウィンドウのタイトルの書き換え
            ##sec = ##now;
            #n = dllfunc("settitle",
                         "ウィンドウのテスト１(" + str(##sec) + " 秒経過)");
        }
        // 1 ミリ秒だけウィンドウの終了を待つ
        $ret = dllfuncstr("wait_close", 1);
    }
    
    message "リターンコード = " + $ret;
}

// ウィンドウの表示テストその２
message "リターンコード = " + str(dllfunc("do_modal","ウィンドウのテスト２"));

freedll;

/* test_hello.c */
#include <windows.h>
#include <stdio.h>

/* hello() 関数の型の typedef */
typedef LPCSTR (__cdecl *PFNFUNC)(void);

int main(int argc, char** argv)
{
    HINSTANCE hDll;
    FARPROC pfnHello;
    LPCSTR ret;
    
    /* DLLのロード */
    if ((hDll = LoadLibrary("hello_world.dll")) == NULL) {
        fputs("DLL が見つかりません\n",stderr);
        return -1;
    }
    
    /* DLL関数へのポインタを取得 */
    if ((pfnHello = GetProcAddress(hDll, "hello")) == NULL) {
        fputs("指定された関数が見つかりません\n",stderr);
        FreeLibrary(hDll);
        return -1;
    }
    
    /* 取得したポインタを使ってDLL関数を呼び出す */
    ret = (*(PFNFUNC)pfnHello)();
    
    /* 結果を表示 */
    fputs(ret, stdout);
    
    /* DLLのアンロード */
    FreeLibrary(hDll);
    
    return 0;
}