ラベル Delphi Programming Tips の投稿を表示しています。 すべての投稿を表示
ラベル Delphi Programming Tips の投稿を表示しています。 すべての投稿を表示

2025年12月11日

Skia4Delphiでリソースとして埋め込まれたフォントを使用する

このアーティクルはDelphi Advent Calendar 2025の11日目の記事です。

ここまでリソースとして埋め込まれたフォントをVCL(GDI)で使用する方法を見てきました。ところで埋め込んだフォントをSkia4DelphiのTSkLabelやISkCanvasでも使用したいときは、少し違う方法が必要になります。
Skia4Delphiで描画に使用するフォントはTSkDefaultProviders.RegisterTypeface(かIFMXFontManagerService.AddCustomFontFromFile)で登録するのですが、このときのリソースタイプは(FONTではなく)RCDATAになっている必要があります。しかしフォント以外のリソースもリソースタイプRCDATAとして登録されるため、Win32APIのEnumResourceNames関数でプログラムに含まれるRT_RCDATAのリソースを列挙し、コールバック関数でリソースを読み出したら先頭4バイトでフォントデータかどうかを判別してからWin32APIのAddFontMemResourceEx関数とTSkDefaultProviders.RegisterTypefaceに渡すようにします。

まずプロジェクトにフォントをリソースとして追加します。Delphi IDEの"メインメニュー"→"プロジェクト"→"リソースと画像"で"<プロジェクト名>のリソース"ダイアログで、フォントをリソースとして追加します。このときリソースタイプを"RCDATA"に変更しておきます。
次にプログラムのなるべく早い時点でこのフォントを読み出して登録します。
unit LoadResFontsForSkia;

{$IFNDEF SKIA}
{$MESSAGE ERROR 'Enable Skia4Delphi.'}
{$ENDIF}

interface

uses
  Winapi.Windows,
  System.SysUtils, System.Classes,
  Vcl.Skia;

implementation

type
  TFontType = (ftNotFont, ftGDIFont, ftWebFont);

function CheckFontData(Stream: TStream): TFontType;
var
  Signature: DWORD;
begin
  Result := TFontType.ftNotFont;

  Stream.Position := 0;
  try
    if Stream.Read(Signature,SizeOf(Signature)) <> SizeOf(Signature) then
    begin
      Exit;
    end;

    case Signature of
      $00000100,  // TrueType
      $4F45454F,  // 'OTTO' OpenType
      $66637474:  // 'ttcf' TrueType Collection
      begin
        Result := TFontType.ftGDIFont;
      end;

      $46464F77,  // 'wOFF' Web Open Font
      $32464F77:  // 'wOF2' Web Open Font 2
      begin
        Result := TFontType.ftWebFont;
      end;
    end;

  finally
    Stream.Position := 0;
  end;
end;

function EnumResNameProc(hModule: HMODULE; lpszType: PChar; lpszName: PChar; lParam: LONG_PTR): BOOL; stdcall;
var
  RS: TResourceStream;
  NumFonts: DWORD;
  FontType: TFontType;
begin
  { Load resource }
  if Is_IntResource(lpszName) = False then
  begin
    { By name }
    RS := TResourceStream.Create(HInstance,String(lpszName),RT_RCDATA);
  end
  else
  begin
    { By index }
    RS := TResourceStream.CreateFromID(HInstance,NativeUInt(lpszName),RT_RCDATA);
  end;

  try
    FontType := CheckFontData(RS);
    if FontType in [TFontType.ftGDIFont] then
    begin
      { Regsiter font to GDI }
      if AddFontMemResourceEx(RS.Memory,RS.Size,nil,@NumFonts) = 0 then
      begin
        RaiseLastOSError;
      end;
    end;

    if FontType in [TFontType.ftGDIFont, TFontType.ftWebFont] then
    begin
      { Register font to Skia4Delphi }
      TSkDefaultProviders.RegisterTypeface(RS);
    end;

  finally
    RS.Free;
  end;

  Result := True;
end;

procedure LoadResourceFonts;
begin
  if EnumResourceNames(HInstance,RT_RCDATA,@EnumResNameProc,0) = False then
  begin
    RaiseLastOSError;
  end;
end;

initialization
  LoadResourceFonts;

end.
ユニットのinitialization部で呼び出しているLoadResourceFonts関数では、Win32APIのEnumResourceNames関数でプログラムに含まれるRT_RCDATAのリソースを列挙します。コールバック関数EnumResNameProcではコンストラクタTResourceStream.Createを呼び出してフォントをストリームに読み出し、フォントデータかどうかの判定関数CheckFontDataを呼び出します。CheckFontData関数ではストリームから先頭4バイトを読み出し、TrueType(.ttf)、TrueType Collection(.ttc)、OpenType(.otf)、OpenType Collection(.otc)、WOFF(.woff)、WOFF2(.woff2)のそれぞれのシグネチャに一致するかどうかでフォントデータかどうかの判定を行います。GDIでは使用できないWOFF/WOFF2形式のフォントもSkia4Delphiでは使用できるので、WOFF/WOFF2形式のときはAddFontMemResourceEx関数に加えてTSkDefaultProviders.RegisterTypefaceも呼び出すようにしています。
これで登録したフォントはSkia4DelphiのFont.Familiesにそのフォント名を指定することで使用できます。TSkLabelならTSkLabel.TextSettings.Font.Families、ISkCanvasに対する描画ならTSkTypeface.MakeFromNameの第1パラメータです。

ん?リソースタイプFONTではなくRCDATAで埋め込んだフォントデータをAddFontMemResourceEx関数に渡せる?じゃあ前回のアーティクルのようにリソースコンパイラを差し替えたりせず、RCDATAでやればいいのでは?と思うかもしれません。その通りで、今回の方法(フォントをRCDATAで埋め込む)を使えば、Delphi 12.3およびそれ以前でもビルド前イベントでresinatorを使って処理する必要はありません。しかしプログラムにフォント以外のRCDATAのリソースが埋め込まれていた場合は、それらもすべて読み出してフォントデータかどうかの判別をする必要があります。このオーバヘッドを許容できるのであれば、今回の方法でも問題ありません。

2025年12月10日

Delphi 12.3までの環境でフォントをリソースとして埋め込むとコンパイル時にエラーになる場合の対策

このアーティクルはDelphi Advent Calendar 2025の10日目の記事です。

前回のアーティクルでプログラムにフォントをリソースとして埋め込んで使用する方法を見てきましたが、Delphi 12.3 Athensおよびそれ以前の環境ではコンパイルしようとすると、埋め込もうとしたフォントによっては
[BRCC32 エラー] "brcc32" はコード 1 を伴って終了しました。
とリソースコンパイラでエラーになることがあります。

Delphiのリソースのコンパイルはデフォルトではbrcc32.exe→cgrc.exe→rc.exeと、最終的にMicrosoftのリソースコンパイラが使われるのですが、このrc.exeに多数の不具合と未定義動作があり、フォントを解析するときの処理の不具合でこのような状況になるようです(下記記事参照)。
一方Delphi 13 Florenceでは新機能ページのIDEツールの改善のリソース コンパイラの項にあるように、Ryan Liptakさんによるrc.exe互換のオープンソース実装であるresinatorをデフォルトで使用するように変更されています。
そこでこのresinatorをDelphi 12.3までの環境で使用する手順を確認していきます。

同じ環境にDelphi 13 Florence(またはそれ以降のバージョン)がインストールされている場合はパスが通った場所に既にresinatorが配置されているため、別途インストールする必要はありません。そうでない場合は、まずGitHubのリポジトリにアクセスし、最新版のWindows x64のバイナリ(2025/10/23現在ではv0.1.0にあるwindows-x86_64-resinator.zip)をダウンロードし、resinator.exeを(できればパスが通った)適切な場所に展開します(簡単なのはDelphiのインストール先のbinフォルダの下あたりかも)。
次にDelphiのIDEでエラーになるプロジェクトを開き、"メインメニュー"→"プロジェクト"→"リソースと画像"で"<プロジェクト名>のリソース"ダイアログを開いてすべての項目を削除して"OK"で閉じます(<プロジェクト名>Resource.rcファイルは削除されませんので、これをresinatorでコンパイルします)。
"メインメニュー"→"プロジェクト"→"オプション"で"プロジェクトオプション"ダイアログを開き、"ビルド"→"ビルドイベント"のターゲットで"全ての構成 - Windows 32 ビットプラットフォーム"(または"全ての構成 - Windows 64 ビットプラットフォーム")を選択し、"ビルド前イベント"の"コマンド"に
resinator.exe -v $(PROJECTNAME)Resource.rc $(PROJECTNAME).dres
と設定します(もしパスが通っていない場所にresinator.exeを配置した場合は"resinator.exe"を絶対パスで指定してください)。
最後にプロジェクトファイル(*.dpr)の "program プロジェクト名;" の次に "{$R *.dres}" の行を追加します(リソースダイアログで全項目削除すると自動的に削除されてしまうので)。
program Project1;

{$R *.dres}

uses
  Vcl.Forms,
  ...
こんな感じです。これでコンパイルするとビルド前イベントで"(プロジェクト名)を信頼しますか?"という警告ダイアログが表示されるので、"このプロジェクトを常に信頼する"にチェックを入れて"はい"をクリックします。
これによって、プロジェクトをコンパイルするときのビルド前イベントでリソーススクリプトファイル(.rc)をresinatorでコンパイルしてリソースファイル(.dres)を生成しておき、リンカでこのリソースファイルをリンクする、という動作になります。

Skia4Delphiの描画(TSkLabelやISkCanvas)でもリソースとして埋め込んだフォントを使用する方法については次のアーティクルで説明します。

なおMicrosoftのリソースコンパイラrc.exeにどのような不具合があり、resinatorではどのような動作に修正されているのかについてはRyan LiptakさんのblogのEvery bug/quirk of the Windows resource compiler (rc.exe), probably - ryanliptak.comというアーティクルにまとめられています。

2025年12月9日

プログラムにフォントをリソースとして埋め込んで使用する

プログラムにフォントをリソースとして埋め込んで使用する このアーティクルはDelphi Advent Calendar 2025の9日目の記事です。

プログラムのUIや印刷などで、標準でWindowsに含まれないフォントを使用したいようなことがあります。もちろんインストーラなどを使って実行環境に(ライセンスに従って)フォントをインストールすることができればそれでよいのですが、状況によってはフォントのインストールが難しい、ということもあります。このような場合にプログラムにフォントをリソースとして埋め込み、これを実行時にWindowsに登録して使用する、という方法があります。

まずプロジェクトにフォントをリソースとして追加します。Delphi IDEの"メインメニュー"→"プロジェクト"→"リソースと画像"→"<プロジェクト名>のリソース"ダイアログで、フォント(.ttfなど)をリソースとして追加します。このときリソースタイプはFONT、リソース識別子は(デフォルトの)1からの整数とします(一意であれば整数値でも文字列でも構いません)。これでリソーススクリプトファイル <プロジェクト名>Resource.rc が用意されて、コンパイル時にリソースコンパイラでリソースファイル <プロジェクト名>.dres が作られます。またプロジェクトソースの "program <プロジェクト名>;" の次に "{$R *.dres}" の行が自動的に追加されることでこのリソースファイルが実行ファイルにリンクされる、ということになります。

プログラム側の対応ですが、プログラムのなるべく早い時点でこのフォントを読み出して登録します。
unit LoadResFontsForGDI;

interface

uses
  Winapi.Windows,
  System.SysUtils, System.Classes;

implementation

function EnumResNameProc(hModule: HMODULE; lpszType: PChar; lpszName: PChar; lParam: LONG_PTR): BOOL; stdcall;
var
  RS: TResourceStream;
  NumFonts: DWORD;
begin
  { Load font }
  if Is_IntResource(lpszName) = False then
  begin
    { By name }
    RS := TResourceStream.Create(HInstance,String(lpszName),RT_FONT);
  end
  else
  begin
    { By index }
    RS := TResourceStream.CreateFromID(HInstance,NativeUInt(lpszName),RT_FONT);
  end;

  try
    { Regsiter font to GDI }
    if AddFontMemResourceEx(RS.Memory,RS.Size,nil,@NumFonts) = 0 then
    begin
      RaiseLastOSError;
    end;

  finally
    RS.Free;
  end;

  Result := True;
end;

procedure LoadResourceFonts;
begin
  if EnumResourceNames(HInstance,RT_FONT,@EnumResNameProc,0) = False then
  begin
    RaiseLastOSError;
  end;
end;

initialization
  LoadResourceFonts;

end.
ユニットのinitialization部で呼び出しているLoadResourceFonts関数では、Win32APIのEnumResourceNames関数でプログラムに含まれるRT_FONTのリソースを列挙します。コールバック関数EnumResNameProcではパラメータlpszNameに格納されているリソース名が名前かインデックスかをIs_IntResource関数で判定し、名前であればコンストラクタTResourceStream.Createの文字列を取るオーバロードを、インデックスであればインデックスを取るオーバロードを呼び出してフォントをリソースストリームに読み出し、Memoryプロパティの示すアドレスとSizeプロパティの示すサイズ(バイト数)をWin32APIのAddFontMemResourceEx関数に渡して登録します。
このようなユニットをプロジェクトに追加することで、プログラムの開始時に埋め込まれているフォントリソースをWindowsに登録して使用することができるようになります。

え?Delphi 12 Athensやそれ以前の環境でコンパイルしようとするとBRCC32 エラーになる?それはMicrosoftのリソースコンパイラ(rc.exe)の不具合が原因です。次のアーティクルではこの問題を解決します。

2023年12月27日

文字列の表示幅を取得する

前回はSkia4DelphiのISkUnicodeを使って文字列を書記素クラスタ(grapheme cluster)に分割する方法を扱いましたが、(等幅フォントでの表記を前提として)文字列が何文字分の幅を占めるのか(いわゆる"表示幅")を取得するためには、それぞれの書記素クラスタ(の基底文字)がいわゆる"半角幅"(halfwidth、1/2 Em)なのか"全角幅"(fullwidth、1 Em)なのかを知る必要があります(Emは文字の高さを基準にした単位で、1/2 Emは高さの半分の文字幅、1 Emは高さと同じ文字幅になる、という意味)。これに関するUnicodeの規格がUnicode Standard Annex #11 East Asian Width(UAX #11)になります。

UAX #11では既存の実装に配慮して、文字をその占める幅によって
  • Fullwidth("F"/全角)
  • Halfwidth ("H"/半角)
  • Wide ("W"/広)
  • Narrow ("Na"/狭)
  • Ambiguous ("A"/曖昧)
  • Neutral ("N"/中立)(Not East Asian)
に分類しています。"F"は全角英数などUnicodeの規格上"FULLWIDTH"とされるもの、"H"は半角カナなど"HALFWIDTH"とされるもの、"W"はJISの漢字や東アジアの組版専用の句読点など文字幅が1 Emで扱われてきたもの、"Na"は半角英数など"F"や"W"に対応する全角文字が存在するもの、"A"はJISのギリシャ文字やキリル文字のように東アジアでは文字幅が1 Emで扱われるもの、"N"はそれ以外のもの、となり、"F"と"W"は全角幅、"H"、"Na"、"N"は半角幅として扱います。ここで問題になるのが"A"で、これは組版の文脈(≒使われるフォント)によって、全角幅か半角幅かのどちらかになります(例えばギリシャ文字やキリル文字はMS Gothicのような日本語のフォントでは全角幅に、Consolasのような欧文のフォントでは半角幅になる)。

では実際にどの文字(コードポイント)がどの分類になるのか、ですが、これはUnicodeデータベースの一部としてhttps://www.unicode.org/Public/UCD/latest/ucd/EastAsianWidth.txtにリストされています。基本的にこれを何らかの形で配列化しておいて参照すればいいのですが、Unicode(UCS4)で扱えるコードポイントは最大でU+0000からU+10FFFFの1,114,112個あり、単純にテーブル化すると約1MBになってしまいます。しかしプレーン4~13は未割当で定義も存在しません(この場合はデフォルトで"N"である(All code points, assigned or unassigned, that are not listed explicitly are given the value "N".)と明記されています)。そこで今回はプレーン毎に分割して、フルマッピングするプレーンと1つの値で代表させるプレーン、という形で領域を節約した実装を考えてみます。

まずはUAX #11で規定されている分類を列挙型として定義し、レコードヘルパでそれぞれに対応する文字幅を返すようにします。
type
  TEastAsianWidth = (Neutral,     // N
                     Fullwidth,   // F
                     Halfwidth,   // H
                     Wide,        // W
                     Narrow,      // Na
                     Ambiguous);  // A

  TEastAsianWidthHelper = record helper for TEastAsianWidth
  private
    const
      Width: array [Boolean,TEastAsianWidth] of Integer =
        ((1,                      // Neutral
          2,                      // Fullwidth
          1,                      // Halfwidth
          2,                      // Wide
          1,                      // Narrow
          1),                     // Ambiguous (same as Neutral)
         (1,                      // Neutral
          2,                      // Fullwidth
          1,                      // Halfwidth
          2,                      // Wide
          1,                      // Narrow
          2));                    // Ambiguous (same as Fullwidth)
  private
    class var
      FEastAsian: Boolean;
  public
    function GetWidth: Integer; overload; inline;
    class property EastAsian: Boolean read FEastAsian write FEastAsian;
  end;

function TEastAsianWidthHelper.GetWidth: Integer;
begin
  Result := Width[FEastAsian,Self];
end;
ここでクラスプロパティTEastAsianWidth.EastAsianは"A"の扱いを決めるもので、Trueなら東アジアの組版(フォントが日本語など)、Falseなら欧文の組版(フォントが欧文)であることを示します。
次にEastAsianWidth.txtをテーブル化します。まずそれぞれのプレーンを格納するテーブルのレコード型と、このテーブルへのポインタと代表値をセットにしたレコード型を定義します。
type
  TPlaneData = packed record
  public
    Data: array [0..65535] of Byte;
  end;
  PPlaneData = ^TPlaneData;

  TPlane = record
    PlaneDefault: Byte;
    PlaneData: PPlaneData;
  end;
このTPlaneの配列(0..16)を今回はEastAsianWidth.txtから生成しますが、とりあえず仮に
const
  Plane0: TPlaneData = (Data: (
    $00,$00,$00,$00,$00,$00,$00,$00,$00,$00,$00,$00,$00,$00,$00,$00,
    ...
    $00,$00,$00,$00,$00,$00,$00,$00,$00,$00,$00,$00,$00,$00,$00,$00));
  Plane0Default = $00;
  Plane1Default = $00;
  ...
  Plane16Default = $00;

  Planes: array [0..16] of TPlane =
    ((PlaneDefault: Plane0Default; PlaneData: @Plane0),
     (PlaneDefault: Plane1Default; PlaneData: nil),
     ...
     (PlaneDefault: Plane16Default; PlaneData: nil));
こんな定数定義があるものとします。これを使用する形でレコードヘルパTEastAsianWidthHelperにクラスメソッドGetEastAsianWidthを追加します。
uses
  System.SysUtils, System.RTLConsts;

type
  TEastAsianWidthHelper = record helper for TEastAsianWidth
  public
    ...
    class function GetEastAsianWidth(C: UCS4Char): TEastAsianWidth; static;
  end;

class function TEastAsianWidthHelper.GetEastAsianWidth(C: UCS4Char): TEastAsianWidth;
var
  PlaneNum: Integer;
  Plane: TPlane;
  B: Byte;
begin
  PlaneNum := (C shr 16) and $FFFF;
  if (PlaneNum < Low(Planes)) and (PlaneNum > High(Planes)) then
  begin
    raise EArgumentOutOfRangeException.CreateRes(@SArgumentOutOfRange);
  end;

  Plane := Planes[PlaneNum];
  if Plane.PlaneData <> nil then
  begin
    B := Plane.PlaneData^.Data[C and $FFFF];
  end
  else
  begin
    B := Plane.PlaneDefault;
  end;

  Result := TEastAsianWidth(B);
end;
クラスメソッドGetEastAsianWidthでは、プレーン毎のテーブルがあればそこから、テーブルがなければ代表値を取得し、列挙型TEastAsianWidthとして返します。

あとはUnicodeのバージョンアップに簡単に追随できるようにするために、EastAsianWidth.txtから上記のテーブル部分を自動生成する処理を別ユニットに作っていきます。

まず読み込んだプレーン毎のデータを格納するレコード型と、関係するメソッド(初期化、値の指定、代表値だけでテーブルを省略可能かどうかの判定)を用意します。
type
  TPlaneData = record
    Table: array [$0000..$FFFF] of Byte;
    procedure Init;
    procedure Fill(StartIndex: UInt16; EndIndex: UInt16; Data: Byte);
    function  IsAllSame: Boolean;
  end;

procedure TPlaneData.Init;
var
  I: Integer;
begin
  for I := Low(Table) to High(Table) do
  begin
    Table[I] := 0;  // 'Neutral'
  end;
end;

procedure TPlaneData.Fill(StartIndex: UInt16; EndIndex: UInt16; Data: Byte);
var
  I: Integer;
begin
  for I := StartIndex to EndIndex do
  begin
    Table[I] := Data;
  end;
end;

function TPlaneData.IsAllSame: Boolean;
var
  I: Integer;
  B: Byte;
begin
  B := Table[Low(Table)];
  for I := Low(Table) + 1 to High(Table) do
  begin
    if Table[I] <> B then
    begin
      Result := False;
      Exit;
    end;
  end;
  Result := True;
end;
これを使ってUCS4のコード範囲全体を扱うレコード型を用意します。
type
  TEastAsianWidthProperties = record
    Planes: array [0..16] of TPlaneData;
    procedure Init;
  end;
  PEastAsianWidthProperties = ^TEastAsianWidthProperties;

procedure TEastAsianWidthProperties.Init;
var
  I: Integer;
begin
  for I := Low(Planes) to High(Planes) do
  begin
    Planes[I].Init;
  end;
end;
あとはEastAsianWidth.txtを解析して値を格納し、テーブル化するメソッドを用意します。
uses
  System.Classes, System.SysUtils, System.RegularExpressions, System.SysConst;

function SymbolToEastAsianWidth(const S: String): Byte;
const
  EastAsianWidthSymbols: array [0..5] of String =
    ('N',
     'F',
     'H',
     'W',
     'Na',
     'A');
begin
  for Result := Low(EastAsianWidthSymbols) to High(EastAsianWidthSymbols) do
  begin
    if EastAsianWidthSymbols[Result] = S then
    begin
      Exit;
    end;
  end;
  raise EConvertError.CreateRes(@SRangeError);
end;

procedure ConvertEastAsianWidth(Input, Output: TStrings);
var
  PEAWP: PEastAsianWidthProperties;
  RegEx1: TRegEx;
  RegEx2: TRegEx;
  Match: TMatch;
  I: Integer;
  S: String;
  Position: Integer;
  StartCodePoint: String;
  EndCodePoint: String;
  Name: String;
  Plane: UInt16;
  CPLow: UInt16;
  CPLow2: UInt16;
  PlaneDefault: Byte;
begin
  New(PEAWP);
  try
    PEAWP^.Init;

    RegEx1 := TRegEx.Create('([0-9A-Fa-f]{4,6})[.][.]([0-9A-Fa-f]{4,6})\s*[;]\s*(.{1,2})\s*');
    RegEx2 := TRegEx.Create('([0-9A-Fa-f]{4,6})\s*[;]\s*(.{1,2})\s*');

    for I := 0 to Input.Count - 1 do
    begin
      S := Input.Strings[I];

      Position := Pos('#',S);
      if Position > 0 then
      begin
        Delete(S,Position,Length(S));
      end;
      S := Trim(S);

      if S = '' then
      begin
        Continue;
      end;

      Match := RegEx1.Match(S);
      if Match.Success = True then
      begin
        StartCodePoint := Match.Groups[1].Value;
        EndCodePoint := Match.Groups[2].Value;
        Name := Match.Groups[3].Value;
      end
      else
      begin
        Match := RegEx2.Match(S);
        if Match.Success = True then
        begin
          StartCodePoint := Match.Groups[1].Value;
          EndCodePoint := StartCodePoint;
          Name := Match.Groups[2].Value;
        end;
      end;

      if Match.Success = True then
      begin
        Plane := (StrToInt64('$' + StartCodePoint)  shr 16) and $FFFF;
        if Plane <= 16 then
        begin
          CPLow  := (StrToInt64('$' + StartCodePoint)) and $FFFF;
          CPLow2 := (StrToInt64('$' + EndCodePoint))   and $FFFF;
          PEAWP^.Planes[Plane].Fill(CPLow,CPLow2,Ord(SymbolToEastAsianWidth(Name)));
        end;
      end;
    end;

    for Plane := Low(PEAWP^.Planes) to High(PEAWP^.Planes) do
    begin
      Output.Add(Format('  { Plane%d }',[Plane]));
      if PEAWP^.Planes[Plane].IsAllSame = False then
      begin
        Output.Add(Format('  Plane%d: TPlaneData = (Data: (',[Plane]));
        S := '';
        for I := Low(PEAWP^.Planes[Plane].Table) to High(PEAWP^.Planes[Plane].Table) do
        begin
          if (I mod 16) = 0 then
          begin
            S := '    ';
          end;

          S := S + Format('$%.02X,',[PEAWP^.Planes[Plane].Table[I]]);

          if (I mod 16) = 15 then
          begin
            if I = High(PEAWP^.Planes[Plane].Table) then
            begin
              Delete(S,Length(S),1);
              S := S + '));';
            end
            else
            begin
              S := S + '  ';
            end;
            S := S + Format('  // U+%.4X',[(Plane shl 16) or (I and $FFF0)]);
            Output.Add(S);
            S := '';
          end;
        end;
        PlaneDefault := 0;
      end
      else
      begin
        PlaneDefault := PEAWP^.Planes[Plane].Table[0];
      end;
      Output.Add(Format('  Plane%dDefault = $%.2X;',[Plane,PlaneDefault]));
      Output.Add('');
    end;

    Output.Add('  { Plane data table }');
    Output.Add('  Planes: array [0..16] of TPlane =');
    for Plane := Low(PEAWP^.Planes) to High(PEAWP^.Planes) do
    begin
      if PEAWP^.Planes[Plane].IsAllSame = True then
      begin
        S := Format('     (PlaneDefault: Plane%dDefault; PlaneData: nil),',[Plane]);
      end
      else
      begin
        S := Format('     (PlaneDefault: Plane%dDefault; PlaneData: @Plane%d),',[Plane,Plane]);
      end;

      if Plane = Low(PEAWP^.Planes) then
      begin
        S[5] := '(';
      end
      else if Plane = High(PEAWP^.Planes) then
      begin
        Delete(S,Length(S),1);
        S := S + ');';
      end;
      Output.Add(S);
    end;

  finally
    Dispose(PEAWP);
  end;
end;
レコード型TEastAsianWidthPropertiesはサイズが大きく、デフォルトの設定ではスタックオーバフローするため、New/Disposeでヒープ上に確保するようにしています。読み込んだEastAsianWidth.txtの各行が
0000..001F     ; N  # Cc    [32] <control-0000>..
0020           ; Na # Zs         SPACE
このようになっているものを、正規表現で複数指定、単独指定のどちらかのパターンにマッチングさせて、コードポイント(の範囲)と属性を取り込んでテーブルに格納し、最後にテーブルの内容をDelphiのコードの一部として出力しています。

このConvertEastAsianWidthを使ってEastAsianWidth.txtをEastAsianWidth.incとして変換したら、上記のTPlaneの配列部分を
const
{$I 'EastAsianWidth.inc'}
と置き換えれば完成です。

これで前回のサンプルにチェックボックスを1つ追加して、
procedure TForm1.Button2Click(Sender: TObject);
var
  SkUnicode: ISkUnicode;
  L: Integer;
  TotalL: Integer;
  W: Integer;
  TotalW: Integer;
begin
  TEastAsianWidth.EastAsian := CheckBox1.Checked;
  SkLabel1.Words.Items[0].Caption := Edit1.Text;
  Memo1.Lines.Clear;
  SkLabel2.Words.Clear;
  TotalL := 0;
  TotalW := 0;
  SkUnicode := TSkUnicode.Create;
  for var S in SkUnicode.GetBreaks(Edit1.Text,TSkBreakType.Graphemes) do
  begin
    L := Length(S);
    W := TEastAsianWidth.GetEastAsianWidth(Char.ConvertToUtf32(S,0)).GetWidth;
    Memo1.Lines.Add(S + Format(' (L=%d,W=%d)',[L,W]));
    SkLabel2.Words.Add(S + sLineBreak);
    TotalL := TotalL + L;
    TotalW := TotalW + W;
  end;
  Memo1.Lines.Add(Format('Total: L=%d, W=%d',[L,W]));
end;
こんな感じで全体の文字数を得ることができるようになります。チェックボックスのチェック状態で"á̂̃̄"のWが変化するのがわかりますね。

誰ですか、絵文字が混ざると意味がないじゃないか、とかいう人は!そう、絵文字がZWJ(ゼロ幅接合子)を使ってグリフを増やすようになったあたりから、実際にレンダリングしてみないとどのくらいの表示幅になるのかはわからなくなっているのです。

最終的なプロジェクト全体をGitHubに上げてあります。今後Unicodeのバージョンが上がっても、更新されたEastAsianWidth.txtを取り込むことで最新のものに準拠することができます。

参考: 東アジアの文字幅 - Wikipedia

2023年12月25日

文字列を書記素クラスタで分割する

このアーティクルはDelphi Advent Calendar 2023の25日目の記事です(12日ぶり11回目)。

Unicodeの世界では、1つの"文字"(書記素、grapheme)が1つのコードポイント(code point)で表されるとは限りません。サロゲートペアとか結合文字とか絵文字とか、文字列に入っているものがどれくらいの"文字数"になっているのかを知るのは意外に難しい話です。
現在一般的と考えられる方法として、がありますが、ICUはインタフェースがUTF-8ベースでDelphiからは使いにくく、Delphiの正規表現ライブラリはPCRE(1) 8.45ベースでだいぶ古くてUnicodeの新しいバージョンには対応していません(RSP-42524)。また自前での実装は相当面倒なうえに、Unicodeのバージョンアップに追従していくのが大変です。
ところがDelphi 12で標準サポートされたSkia4Delphiでは簡単に文字列を書記素クラスタで分割できるようになりました(ICUを取り込んでいるようです)。試しに正規表現(PCRE)による分割と比較してみましょう。
なおDelphi 11 Alexandriaおよびそれ以前のバージョンではSkia4Delphiをインストールする必要があります(現時点(2023/12)の最新は6.0.0)。

新規プロジェクトを作成し、フォーム(フォントサイズを大きめにしておくと結果が見やすくなります)にTEditを1つ、TButtonを2つ、結果表示のためのTMemoを1つ配置します。またプロジェクトツールウィンドウでプロジェクトを右クリック→Skiaを有効化を選択して、実行ファイルと同じ場所にsk4d.dllが配置されるようにします。
usesにSystem.Skiaを追加し、フォームのOnShowイベントで
procedure TForm1.FormShow(Sender: TObject);
begin
  Edit1.Text := #$20BB7 + '野屋のコピペ' +
                #$00E5 + #$00E1 + #$0302 + #$0303 + #$0304 +
                #$1F62D +
                #$1F937 + #$1F3FD + #$200D + #$2640 + #$FE0F +
                #$1F468 + #$200D + #$1F469 + #$200D + #$1F467 + #$200D + #$1F466 +
                #$1F469 + #$1F3FD + #$200D + #$1F4BB +
                #$1F1EF + #$1F1F5;
end;
とEdit1.Textにサンプル文字列を設定し、Button1のOnClickイベントで
procedure TForm1.Button1Click(Sender: TObject);
begin
  for var Match in TRegEx.Matches(Edit1.Text,'\X') do
  begin
    Memo1.Lines.Add(Match.Value);
  end;
end;
Button2のOnClickイベントで
procedure TForm1.Button2Click(Sender: TObject);
var
  SkUnicode: ISkUnicode;
begin
  SkUnicode := TSkUnicode.Create;
  for var S in SkUnicode.GetBreaks(Edit1.Text,TSkBreakType.Graphemes) do
  begin
    Memo1.Lines.Add(S);
  end;
end;
とします。では実行してみましょう。まず正規表現です。
𠮷
野
屋
の
コ
ピ
ペ
å
á̂̃̄
😭
🤷
🏽‍
♀️
👨‍
👩‍
👧‍
👦
👩
🏽‍
💻
🇯🇵
(Windows上の表示とは若干異なります)
正規表現による分割では絵文字のZWJ(ゼロ幅接合子)による結合はうまく処理できないようです。これはPCRE 8.45がだいぶ古いバージョンで、最新のUnicodeに対応できていないことが原因と考えられます。

次にSkia4Delphiです。
𠮷
野
屋
の
コ
ピ
ペ
å
á̂̃̄
😭
🤷🏽‍♀️
👨‍👩‍👧‍👦
👩🏽‍💻
🇯🇵
一方でSkia4Delphiによる分割は正しく処理できていますね。ちなみにWindowsでは国旗の絵文字は絵文字としてではなくRegional indicator symbol2文字での表現になるようです(サンプル最後の"🇯🇵"が"JP"となる)。

書記素クラスタによる分割は文字列のレンダリングに必須なためSkia(Skia4Delphi)に実装されていると考えられますが、プログラムで書記素クラスタによる分割が必要になるのは(帳票などで)文字列がどのくらいの幅を占めるかを知りたいときではないでしょうか。そのためには書記素クラスタによる分割だけでなく、Unicode Standard Annex #11 East Asian Widthも必要になります。これはDelphi標準のSystem.CharacterユニットにもSkia4Delphiにも実装されておらず、EastAsianWidth.txtを取り込んで自前で実装する必要があります。これについては後日別のアーティクルで扱うことにします。

Skia4Delphを使って見やすくしたバージョンをGistに上げてあります。

2023年12月13日

TSqidsEncodingで文字列を難読化する

このアーティクルはDelphi Advent Calendar 2023の12日目の記事です(2日ぶり10回目)。

前回はDelphi 12 Athensで導入されたTSqidsEncodingを普通に使ってみましたが、TSqidsEncodingにはTArray<Integer>を扱うoverloadがあり、今回はそれを使って文字列を難読化してみます。
とはいっても、単にDelphiの文字列(UTF-16)の1文字を単純にUInt16(=Word)として扱うだけです。
uses
  ..., System.NetEncoding.Sqids;

type
  TSqidsEncodingHelper = class helper for TSqidsEncoding
  public
    function EncodeFromString(const AStr: String): String;
    function DecodeToString(const AHash: String): String;
  end;

function TSqidsEncodingHelper.EncodeFromString(const AStr: String): String;
var
  Values: TArray;
  I: Integer;
begin
  SetLength(Values,Length(AStr));
  for I := 0 to Length(AStr) - 1 do
  begin
    Values[I] := UInt16(AStr[I + 1]);
  end;
  Result := Encode(Values);
end;

function TSqidsEncodingHelper.DecodeToString(const AHash: String): String;
var
  Values: TArray;
  I: Integer;
begin
  Values := Decode(AHash);

  SetLength(Result,Length(Values));
  for I := 0 to Length(Result) - 1 do
  begin
    Result[I + 1] := Char(Values[I]);
  end;
end;
文字列の難読化としてXORやROT13などがよく使われますが、このほうがまだましな気がしますね。

2023年12月10日

TSqidsEncodingで数値と短縮IDを相互変換する

このアーティクルはDelphi Advent Calendar 2023の10日目の記事です(1年ぶり9回目)。

Delphi 12 Athensで数値と短縮IDを相互変換するSqidsを実装したTSqidsEncodingが追加されました。
Sqidsはあくまで難読化であって暗号化ではないので、内容を隠すことはできませんが、ID番号などをそのまま見せるよりはまし、というような場合に有効です。Sqidsの公式サイトでは、適しているケースとして
  • 短縮リンク
    • URLで安全に使用できる
  • イベントID
    • 衝突しないエンコード/デコード
  • ワンタイムパスワード
    • 短く問題のあるワードを含まない
適していないケースとして
  • 機密データ
    • 暗号化されるわけではない
  • ユーザID
    • デコードすることでユーザ数が漏洩する
を挙げています。

使用方法は簡単で、エンコードするには
uses
  ..., System.NetEncoding.Sqids;

var
  Sqids: TSqidsEncoding;
begin
  Sqids := TSqidsEncoding.Create;
  try
    Edit2.Text := Sqids.Encode(Edit1.Text);

  finally
    Sqids.Free;
  end;
end;
デコードするには
var
  Sqids: TSqidsEncoding;
begin
  Sqids := TSqidsEncoding.Create;
  try
    Edit3.Text := Sqids.DecodeToStr(Edit2.Text);

  finally
    Sqids.Free;
  end;
end;
とするだけです。Sqidsのソースは数値ですが、エンコードではInreger、TArray<Integer>、Stringを受け取るoverloadが用意されています(Stringは単独またはカンマ区切りの数値表現)。
またデコードはTArray<Integer>を返すもの(Decode)、Integerを返すもの(DecodeSingle/TryDecodeSingle)、Stringを返すもの(DecodeToStr)が用意されています。
さらにコンストラクタにエンコード用の文字列を渡すことで生成される文字列をカスタマイズすることもできます。

2023/12/22追記: 公式のblogにもSqidsの使いかたの記事が出ました。
Sqids: RAD Serverとの統合およびスタンドアロンライブラリ (en)

2022年12月22日

ユーザを偽装してSYSTEMサービスからネットワークリソースにアクセスする

このアーティクルはDelphi Advent Calendar 2022の22日目の記事です(20日ぶり8回目)。

以前WNetAddConnection2を使って他のPCのネットワーク共有にアクセスする方法について書きましたが、これをサービスから実行するとWNetAddConnection2が時々エラー1312(ERROR_NO_SUCH_LOGON_SESSION)になる、という現象が発生します。調べてみたところ、サービスの場合はSystemではなくNetworkServiceで動作していないとこのような状態になるようです(常にエラーになるわけではなく、成功したりエラーになったりという感じ)。もちろんサービスをNetworkServiceで実行すればネットワークアクセスでエラーになることはないのですが、ローカルコンピュータに対するアクセスがUsersグループ相当に制限されてしまいます(サービスで使用する(Local)System/LocalService/NetworkServiceアカウントについてはWindowsテクニカルドキュメント(旧MSDN)のService User Accounts、LocalService Account、NetworkService Account、LocalSystem Accountや@ITのWindowsのサービスで使用される「System」「Local Service」「Network Service」アカウントとは?:Tech TIPSを参照)。

そこでSystemアカウントで動作するサービスから実行することを前提に、ネットワークリソースにアクセスするときだけNetworkServiceアカウントに偽装するようにしてみます。
まずLogonUserでNetworkServiceとしてログインし、返されたトークンハンドルでImpersonateLoggedOnUserを呼び出すことでユーザを偽装します。
const
  LOGON32_LOGON_NEW_CREDENTIALS   = 9;
  {$EXTERNALSYM LOGON32_LOGON_NEW_CREDENTIALS}
var
  LogonUserUser: String;
  LogonUserDomain: String;
  LogonUserLogonType: DWORD;
  LogonUserLogonProvider: DWORD;
  hToken: THandle;
begin
  { Logon as 'NetworkService' user }
  LogonUserUser := 'NetworkService';
  LogonUserDomain := 'NT AUTHORITY';
  LogonUserLogonType := LOGON32_LOGON_NEW_CREDENTIALS;
  LogonUserLogonProvider := LOGON32_PROVIDER_DEFAULT;
  if LogonUser(PChar(LogonUserUser),PChar(LogonUserDomain),nil,
               LogonUserLogonType,LogonUserLogonProvider,hToken) = False then
  begin
    RaiseLastOSError;
  end;

  { Impersonate }
  if ImpersonateLoggedOnUser(hToken) = False then
  begin
    RaiseLastOSError;
  end;
これでこの後WNetAddConnection2で接続を試みるときにSystemアカウントではなくNetworkServiceアカウントであるかのように扱われます。

切断するときはまずWNetCancelConnection2を呼び出した後で、RevertToSelfで偽装を解除し、CloseHandleでトークンハンドルをクローズすることでログオフします。
  { Revert impersonation }
  if RevertToSelf() = False then
  begin
    RaiseLastOSError;
  end;

  { Loggoff }
  CloseHandle(hToken);
  hToken := INVALID_HANDLE_VALUE;
なおプロセス上で複数のスレッドが動作している場合(特にサービス)など、同一の共有リソース('\\<computername>\<sharename>')に対してWNetAddConnection2をネストして呼び出すとERROR_ALREADY_ASSIGNEDでエラーになります。これを防ぐには同一の共有リソースに対してWNetAddConnection2/WNetCancelConnection2が1回ずつ呼び出されるように、接続している共有リソースをプロセス全体で適切に管理する必要もあります。

2022年12月2日

レコード型のフィールドのオフセットを取得する

このアーティクルはDelphi Advent Calendar 2022の2日目の記事です(3年ぶり7回目)。

Delphiのレコード型(Cの構造体に相当)は、スタックに配置することができるということ以外にも、特定のメモリレイアウトを定義することができることから、固定長ファイルや指定されたメモリ上のデータを解釈するために使われることがあります。このような場合に、定義したレコード型の特定のフィールドのオフセットが(主にデバッグ用に)欲しくなったりするのですが、Delphiには(SizeOfはあるのに)C/C++のoffsetofマクロ(stddef.h)のようなものが存在しません(RSP-39559)。そこで軽く検索してみたところStack Overflowにそのものずばりな投稿がありました。

delphi - Get Position of a struct var AKA Offset of record field - Stack Overflow
Delphi: Offset of record field - Stack Overflow

ではちょっと試してみましょう。まずレコード型とそのポインタ型を定義します。
type
  TFoo1 = record
    Bar: Boolean;
    Baz: Double;
    Qux: array [0..8] of Byte;
    Quux: Integer;
  end;
  PFoo1 = ^TFoo1;
これで
procedure TForm1.Button1Click(Sender: TObject);
begin
  Memo1.Lines.Add(Format('TFoo1: SizeOf=%d',[SizeOf(TFoo1)]));
  Memo1.Lines.Add(Format('TFoo1.Bar: offset=%d',[NativeUInt(@(PFoo1(nil)^.Bar))]));
  Memo1.Lines.Add(Format('TFoo1.Baz: offset=%d',[NativeUInt(@(PFoo1(nil)^.Baz))]));
  Memo1.Lines.Add(Format('TFoo1.Qux: offset=%d',[NativeUInt(@(PFoo1(nil)^.Qux))]));
  Memo1.Lines.Add(Format('TFoo1.Quux: offset=%d',[NativeUInt(@(PFoo1(nil)^.Quux))]));
end;
のように、nilをレコード型へのポインタにキャスト→フィールドを参照→そのアドレスを取得→整数に変換とすることで、そのフィールドのオフセット値を取得できます(アドレスと同じサイズの符号なし整数はNativeUInt型)。では実行してみましょう。

TFoo1: SizeOf=32
TFoo1.Bar: offset=0
TFoo1.Baz: offset=8
TFoo1.Qux: offset=16
TFoo1.Quux: offset=28
Delphiのレコード型のデフォルトのアライメントマスクに従って配置されていることがわかります(TFoo1.QuuxのオフセットがDelphiのデフォルトのフィールドのアライメント(構造体アライメント)の8バイトに従った32ではなく、型(Integer)のサイズである4バイトで28になっていることに注意)。
しかし最初に書いたように、特定の(外部で規定された)メモリレイアウトに簡単にアクセスできるようにするためにレコード型を使用する、という目的を考えると、レコード型にはpackedを指定して、明示的にパディングするような場合が多いと思われます。ではレコード型をpacked recordにしてみましょう。
type
  TFoo2 = packed record
    Bar: Boolean;
    Baz: Double;
    Qux: array [0..8] of Byte;
    Quux: Integer;
  end;
  PFoo2 = ^TFoo2;

procedure TForm1.Button2Click(Sender: TObject);
begin
  Memo1.Lines.Add(Format('TFoo2: SizeOf=%d',[SizeOf(TFoo2)]));
  Memo1.Lines.Add(Format('TFoo2.Bar: offset=%d',[NativeUInt(@(PFoo2(nil)^.Bar))]));
  Memo1.Lines.Add(Format('TFoo2.Baz: offset=%d',[NativeUInt(@(PFoo2(nil)^.Baz))]));
  Memo1.Lines.Add(Format('TFoo2.Qux: offset=%d',[NativeUInt(@(PFoo2(nil)^.Qux))]));
  Memo1.Lines.Add(Format('TFoo2.Quux: offset=%d',[NativeUInt(@(PFoo2(nil)^.Quux))]));
end;
実行してみます。

TFoo2: SizeOf=22
TFoo2.Bar: offset=0
TFoo2.Baz: offset=1
TFoo2.Qux: offset=9
TFoo2.Quux: offset=18
意図通り、すべてのフィールドがパディングされることなく並んでいることがわかります。

逆アセンブルを見ると、コンパイラは各メンバのオフセットを知っててnil(=0)に加算しているので、最初からこれをもらう方法があれば…とは思います。また上記のStack Overflowの2番目の投稿にはRTTIを使った方法も紹介されていますが、RTTIのテーブルでループを回しながら文字列の比較をする必要があるため、それに比べればnilを使った方法のほうが優れていると考えられます。

ところで、packedを指定せずデフォルトのアライメントマスクに従って配置された場合、順序型はそのサイズでアライメントされる、との記述があります。つまり
type
  TFoo3 = record
    Bar: array [0..8] of Byte;
    Baz: Boolean;
    Qux: array [0..8] of Byte;
  end;
  PFoo3 = ^TFoo3;
のように1バイトアライメントされている配列のフィールドの次に1バイトの順序型のフィールドがあると、デフォルトのアライメントの8バイトに従ったパディングが行われることなく、連続した配置になる、ということになります(逆も同じ)。
procedure TForm1.Button3Click(Sender: TObject);
begin
  Memo1.Lines.Add(Format('TFoo3: SizeOf=%d',[SizeOf(TFoo3)]));
  Memo1.Lines.Add(Format('TFoo3.Bar: offset=%d',[NativeUInt(@(PFoo3(nil)^.Bar))]));
  Memo1.Lines.Add(Format('TFoo3.Baz: offset=%d',[NativeUInt(@(PFoo3(nil)^.Baz))]));
  Memo1.Lines.Add(Format('TFoo3.Qux: offset=%d',[NativeUInt(@(PFoo3(nil)^.Qux))]));
end;
実行してみると、

TFoo3: SizeOf=19
TFoo3.Bar: offset=0
TFoo3.Baz: offset=9
TFoo3.Qux: offset=10
と、確かにその通りになっています。またDelphi 2007までは型仕様が共通のフィールド(A, B: Extended;のように複数のフィールドが","で並べられて同じ型が指定されているフィールド)は暗黙にpackedとなる、という仕様も存在していました(いま知りました)。

このようなことから、レコード型を使用するときは、packedを指定せず完全にコンパイラにお任せにして特定のメモリレイアウトを必要としないようにするか、packedを指定してパディングも明示的に配置して特定のメモリレイアウトになるようにコーディングするか、どちらかにするべきだと考えられます(この結論そのものは当たり前すぎるものですが)。

なおpackedを指定してメモリレイアウトを完全に自分で制御する場合など、定義したレコード型が正しいサイズになっているかどうかは
{$IF SizeOf(TFoo2) <> 22}
{$MESSAGE ERROR 'SizeOf(TFoo2) is not 22 bytes.'}
{$IFEND}
のようにコンパイル時にチェックすることができます(Delphi 11.2 Alexandriaだとこれを書いた瞬間にLSPで判定が行われるため、{$MESSAGE}の行がエラー表示になるか淡色表示になるかでわかりますが)。

2022年6月15日

現在実行している環境(プロセッサアーキテクチャ)を調べる

Windowsの実行環境としては、現時点(2022年06月)でx86(32bit)版、x64(64bit)版、ARM版があります。一方でDelphiがサポートするターゲットプラットフォームにはWindows 32ビット(x86)、Windows 64ビット(x64)があります。組み合わせとして、x86のプログラムはx86、x64、ARMのいずれでも、またx64のプログラムはx64、ARM(Windows 11のみ)で動作します。逆に動作しない組み合わせはx64のプログラムとx86、ARM(Windows 10)ということになります(Delphiではいまのところ作れませんが、ARMのプログラムはx86/x64では動作せず、ARM版でのみ動作します)。これはWindowsのWOW64(エミュレータ)やDynamic Binary Translator(JIT)によるもので、後方互換性を極めて重視するMicrosoftらしいよくできた仕組みです。これによりWindows上で動作するプログラムは実行環境のことをあまり気にしなくてもよいのですが、まれに(ターゲットプラットフォームではなく)実行環境によって動作を変えたい、ということがあります。
実行環境を調べるにはいくつかの方法がありますが、IsWow64Process2() を使わずにWowA64を検出する · GitHubによると、Windows 10 Version 1511以降であればWin32APIのIsWow64Process2を、それ以前(Windows XP/Vista/7/8/8.1/10 Version 1507(RTM))であればWin32APIのGetNativeSystemInfoを使うのがよいようです(Windows 2000ではGetSystemInfo)。それでは実装してみましょう。
type
{$SCOPEDENUMS ON}
  TProcessorArchitecture = (x86,   // Intel x86
                            x64,   // AMD64/Intel 64
                            ARM);  // ARM

  TIsWow64Process2Func = function (hProcess: THandle; var ProcessMachine: USHORT; var NativeMachine: USHORT): BOOL; stdcall;
  TGetSystemInfoFunc = procedure (var lpSystemInfo: TSystemInfo); stdcall;

const
  IMAGE_FILE_MACHINE_ARM64 = $AA64;

function GetProcessorArchitecture: TProcessorArchitecture;
var
  IsWow64Process2Func: TIsWow64Process2Func;
  ProcessMachine: USHORT;
  NativeMachine: USHORT;
  GetSystemInfoFunc: TGetSystemInfoFunc;
  SI: TSystemInfo;
begin

  { Use IsWow64Process2 on Windows 10 Version 1511 or later }
  @IsWow64Process2Func := GetProcAddress(GetModuleHandle(kernel32),'IsWow64Process2');
  if Assigned(IsWow64Process2Func) = True then
  begin
    if IsWow64Process2Func(GetCurrentProcess,ProcessMachine,NativeMachine) = True then
    begin
      case NativeMachine of
        IMAGE_FILE_MACHINE_I386:
        begin
          Result := TProcessorArchitecture.x86;
          Exit;
        end;

        IMAGE_FILE_MACHINE_AMD64:
        begin
          Result := TProcessorArchitecture.x64;
          Exit;
        end;

        IMAGE_FILE_MACHINE_ARM64:
        begin
          Result := TProcessorArchitecture.ARM;
          Exit;
        end;
      end;
    end;
  end;

  { Use GetNativeSystemInfo (Windows XP or later) or GetSystemInfo (Windows 2000) }
  FillChar(SI,SizeOf(SI),0);
  @GetSystemInfoFunc := GetProcAddress(GetModuleHandle(kernel32),'GetNativeSystemInfo');
  if Assigned(GetSystemInfoFunc) = True then
  begin
    GetSystemInfoFunc(SI);
  end
  else
  begin
    GetSystemInfo(SI);
  end;

  if SI.wProcessorArchitecture = PROCESSOR_ARCHITECTURE_AMD64 then
  begin
    Result := TProcessorArchitecture.x64;
  end
  else
  begin
    Result := TProcessorArchitecture.x86;
  end;

end;
IsWow64Process2、GetNativeSystemInfo、GetSystemInfoの順にフォールバックして情報を取得するようになっています。

2021年5月5日

マイナーリリースを区別する新しい標準条件シンボル

Delphi Master Release List · ideasawakened/DelphiKB Wiki · GitHubを見ていて気が付いたのですが、いままで標準条件シンボルの定義やCONDITIONALEXPRESSIONSではできなかった、マイナーリリース間を区別する(たとえば10.4.1と10.4.2を見分ける)ための新しい標準条件シンボルがRAD Studio/Delphi/C++Builder 10.4.2 Sydneyで導入されたようです。

RAD Studio/Delphi/C++Builder 10.4.1 SydneyまではSystem.pasに
const
  RTLVersion = 34.00;
 {$HPPEMIT '#define RTLVersionC 3400'}
とRTLVersionが定義(34.0)されていたものが、10.4.2 Sydneyでは
const
  RTLVersion = 34.00; RTLVersion1041 = True; RTLVersion1042 = True;
 {$HPPEMIT '#define RTLVersionC 3400'}
と、RTLVersion1041/RTLVersion1042(いずれもTrue)の定義が追加されています。10.4/10.4.1ではこれらの定義が存在せず、10.5でもどうなるのかがいまのところわかっていないので使用方法も判然としないのですが、とりあえず
{$IF RTLVersion = 34.0}
{$IF RTLVersion1042}
  Label1.Caption := 'Delphi 10.4.2.';
{$ELSE}
  Label1.Caption := 'Delphi 10.4 or 10.4.1.';
{$ENDIF}

{$ELSE}
  Label1.Caption := 'Not Delphi 10.4.x.';
{$IFEND}
こんな感じになるでしょうか。

2021年3月6日

const修飾されたインタフェース型の引数としてその場で生成したインスタンスをインタフェース型にキャストしないでそのまま渡すとリークする

Dalija PrasnikarさんのDelphi Event-based and Asynchronous Programmingをパラ見していて引っかかったのですが、タイトルを見ても何をいっているのかわからないと思うので、まずコードを。
type
  IFoo = interface
    procedure FooBar;
  end;

  TFoo = class(TInterfacedObject,IFoo)
  public
    procedure FooBar;
  end;

  TBar = class(TObject)
  public
    procedure Baz(const AFoo: IFoo);
  end;

procedure TFoo.FooBar;
begin
// Do something.
end;

procedure TBar.Baz(const AFoo: IFoo);
begin
  AFoo.FooBar;
end;
インタフェースとしてIFooと、その実装としてクラスTFooを用意し、クラスTBarにはconst修飾されたIFooを渡すBazというメソッドがあります。ここで
var
  Bar: TBar;
begin
  Bar := TBar.Create;
  Bar.Baz(TFoo.Create);
  Bar.Free;
end;
とTBar.BazにTFoo.Createで生成したインスタンスを直接渡すと、TFooはIFooとしての参照カウントの制御を受けず、リークしてしまいます。一方で
var
  Bar: TBar;
begin
  Bar := TBar.Create;
  Bar.Baz(TFoo.Create as IFoo);
  Bar.Free;
end;
とIFooにキャストしたものを渡すとリークしなくなります。

これは、インタフェース型の引数がconst修飾されているとメソッド内部で仮引数が変更されないことが保証されているため、仮引数にコピーしたことによる参照カウントの管理を行わない最適化が行われるのに対して、前者のコードでは呼び出し元で生成したインスタンスが(インタフェース型ではなく)クラス型としてしか管理されていないため、やはり参照カウントの管理を受けずに、リークしてしまう、ということのようです。しかし後者ではas IFooとキャストしたことでIFoo型の暗黙のローカル変数が用意され、これによって参照カウントによって正常に解放されます。

メソッド内部で仮引数を別のインタフェース型の変数やフィールドにコピーすると参照カウントの管理が行われて適切に解放が行われますが、これは実装に依存しますし、また引数をconst修飾していなければ大丈夫ですが、既存の実装の変更が必要になる、ということが問題になります。
このためconst修飾されたインタフェース型の引数としてその場で生成したインスタンスを渡す場合はインタフェース型にキャストするか、あるいは
type
  TFoo = class(TInterfacedObject,IFoo)
  public
    class function CreateAsIntf: IFoo;
    procedure FooBar;
  end;

class function TFoo.CreateAsIntf: IFoo;
begin
  Result := TFoo.Create;
end;

var
  Bar: TBar;
begin
  Bar := TBar.Create;
  Bar.Baz(TFoo.CreateAsIntf);
  Bar.Free;
end;
このように生成したインスタンスをインタフェースとして返すようなメソッドを用意して、そちらを経由するか、ということになります。

元ねたはもちろんDalija PrasnikarさんのDelphi Event-based and Asynchronous Programmingの"13.4 In-place construction in a const parameter"。

2019年12月20日

WindowsのNTFSでハードリンクを扱う

このアーティクルはDelphi Advent Calendar 2019の20日目の記事です(1日ぶり6回目)。

Windows上でファイル/ディレクトリに対してリンク(複数のエントリを用意する)する方法にはシンボリックリンク、ジャンクション、ハードリンクがありますが、ここではDelphiからハードリンクを扱います。

ハードリンクはNTFS上のファイル本体に対するディレクトリエントリを複数用意する(あるいはファイル本体に複数のパス名をつける)、というもので、一般のユーザ権限で作れ、NTFS以外にSMB3.0でもサポート(ReFSは不可)されていますが、ディレクトリを扱うことができず、同一ボリューム上にしかリンクを作ることができません。また最大のリンク数が1023に制限されています。

Windowsのシンボリックリンクとジャンクションとハードリンクの違い:Tech TIPS - @IT

普通に(CreateFile関数で)作成したファイルはリンク数が1になっており、ハードリンクを作成する毎にリンク数が増え、逆にハードリンクをDeleteFile関数で削除する毎にリンク数は減っていき、リンク数が0になるとそのファイルの実体も削除されます。

ここではハードリンクの作成と、指定されたファイルのハードリンクの数と一覧の取得をDelphiから行います。以下のコードは(System.)IOUtilsユニットのTPathレコード型や無名メソッドを使っているためにDelphi 2010以降の対応になっていますが、それ以前のバージョンであっても適当に修正すれば動くはずです。

interface

{$IF RTLVersion < 21.0}
{$MESSAGE ERROR 'Delphi 2010 or later is required.'}
{$IFEND}

uses
{$IF RTLVersion < 23.0}
  Windows, SysUtils, Classes, IOUtils;
{$ELSE}
  Winapi.Windows,
  System.SysUtils, System.Classes, System.IOUtils;
{$IFEND}

type
  { THardLink }
  THardLink = record
  private
    class procedure DoGetFileList(const Filename: String; EnumProc: TProc); static;
  public
    class procedure Create(const LinkFile: String; const SourceFile: String); static;
    class function GetFileList(const Filename: String): TArray; overload; static;
    class procedure GetFileList(const Filename: String; Strings: TStrings); overload; static;
    class function GetNumberOfLinks(const Filename: String): Integer; static;
  end;

implementation

{ HANDLE FindFirstFileNameW(LPCWSTR lpFileName, DWORD dwFlags, LPDWORD StringLength, PWSTR LinkName); }
function FindFirstFileNameW(const lpFileName: PWideChar; dwFlags: DWORD; var StringLength: DWORD; LinkName: PWideChar): THandle; stdcall; external kernel32;
{$EXTERNALSYM FindFirstFileNameW}

{ BOOL FindNextFileNameW(HANDLE hFindStream, LPDWORD StringLength, PWSTR LinkName); }
function FindNextFileNameW(hFindStream: THandle; var StringLength: DWORD; LinkName: PWideChar): BOOL; stdcall; external kernel32;
{$EXTERNALSYM FindNextFileNameW}

class procedure THardLink.Create(const LinkFile: String; const SourceFile: String);
begin
  if CreateHardLink(PChar(LinkFile),PChar(SourceFile),nil) = False then
  begin
    RaiseLastOSError;
  end;
end;

class function THardLink.GetFileList(const Filename: String): TArray;
var
  Files: TArray;
begin
  SetLength(Files,0);

  DoGetFileList(Filename,
    procedure (Filename: String)
    begin
{$IF RTLVersion >= 28.0}
      Files := Files + [Filename];
{$ELSE}
      SetLength(Files,Length(Files) + 1);
      Files[Length(Files) - 1] := Filename;
{$IFEND}
    end);

  Result := Files;
end;

class procedure THardLink.GetFileList(const Filename: String; Strings: TStrings);
begin
  Strings.Clear;

  DoGetFileList(Filename,
    procedure (Filename: String)
    begin
      Strings.Add(Filename);
    end);
end;

class function THardLink.GetNumberOfLinks(const Filename: String): Integer;
var
  hFile: THandle;
  FileInformation: TByHandleFileInformation;
begin
  hFile := CreateFile(PChar(Filename),GENERIC_READ,FILE_SHARE_READ,nil,OPEN_EXISTING,FILE_ATTRIBUTE_NORMAL,0);
  if hFile = INVALID_HANDLE_VALUE then
  begin
    RaiseLastOSError;
  end;

  try
    if GetFileInformationByHandle(hFile,FileInformation) = False then
    begin
      RaiseLastOSError;
    end;
    Result := FileInformation.nNumberOfLinks;

  finally
    CloseHandle(hFile);
  end;
end;

class procedure THardLink.DoGetFileList(const Filename: String; EnumProc: TProc);
var
  hFindStream: THandle;
  Len: DWORD;
  Buffer: String;
  Root: String;
begin
  Root := ExcludeTrailingPathDelimiter(TPath.GetPathRoot(Filename));

  { Retrieve buffer size }
  Len := 0;
  FindFirstFilenameW(PWideChar(Filename),0,Len,nil);
  if GetLastError <> ERROR_MORE_DATA then
  begin
    RaiseLastOSError;
  end;
  SetLength(Buffer,Len);

  { Get first filename without drive letter }
  hFindStream := FindFirstFilenameW(PWideChar(Filename),0,Len,PWideChar(Buffer));
  if hFindStream = INVALID_HANDLE_VALUE then
  begin
    RaiseLastOSError;
  end;

  try
    while True do
    begin
      { Adjust buffer size }
      SetLength(Buffer,Len - 1);

      { Callback }
      EnumProc(Root + Buffer);

      { Retrieve buffer size }
      Len := 0;
      FindNextFileNameW(hFindStream,Len,nil);
      case GetLastError of
        ERROR_HANDLE_EOF:
        begin
          Break;
        end;

        ERROR_MORE_DATA:
        begin
        end;

        else
        begin
          RaiseLastOSError;
        end;
      end;

      { Get next filename without drive letter }
      SetLength(Buffer,Len);
      if FindNextFileNameW(hFindStream,Len,PWideChar(Buffer)) = False then
      begin
        RaiseLastOSError;
      end;
    end;

  finally
    { Close }
    {$IF RTLVersion >= 23.0}Winapi.{$IFEND}Windows.FindClose(hFindStream);
  end;
end;

ハードリンクはCreateHardLink関数で作成し、リンク数はGetFileInformationByHandle関数で取得したBY_HANDLE_FILE_INFORMATION構造体のnNumberOfLinksで知ることができます。またハードリンクの一覧はFindFirstFileName関数/FindNextFileName関数/FindClose関数で取得できます。このときFindFirstFilename関数/FindNextFileName関数を一旦LinkName=nilで呼び出して必要なサイズを取得し、ファイル名の格納に必要な領域を確保してからもう一度FindFirstFilename関数/FindNextFileName関数を呼び出しています。

→WindowsのNTFSでハードリンクを扱う(Gist)

2019年12月19日

Windowsのユーザ名とSIDを相互に変換する

このアーティクルはDelphi Advent Calendar 2019の19日目の記事です(2年ぶり5回目)。またDelphi Programming Tipsカテゴリの記念すべき(かどうかは微妙)100本目の記事になります。

Windows上のユーザはそれぞれ固有のSID(Security Identifier/セキュリティ識別子)で管理されています。

オブジェクトを識別するSIDとは?:Tech TIPS - @IT

ユーザ名とSIDを相互に変換するにはWin32APIのLookupAccountName関数とLookupAccountSid関数を使用します。ところがこれらの関数でSIDは文字列ではなくSID構造体で扱う必要があります。ということで文字列表現のSIDとSID構造体を相互に変換する必要がありますが、これを行うのがConvertSidToStringSid関数とConvertStringSidToSid関数になります。

それではまずユーザ名をSIDに変換するほうから。
uses
{$IF RTLVersion < 23.0}
  Windows, SysUtils;
{$ELSE}
  Winapi.Windows, System.SysUtils;
{$IFEND}

{$IF RTLVersion < 28.0}
{ Win32API ConvertSidToStringSid }
{$IFNDEF Unicode}
function ConvertSidToStringSid(Sid: PSID; var StringSid: LPSTR): BOOL; stdcall; external advapi32 name 'ConvertSidToStringSidA';
{$ELSE}
function ConvertSidToStringSid(Sid: PSID; var StringSid: LPWSTR): BOOL; stdcall; external advapi32 name 'ConvertSidToStringSidW';
{$ENDIF}
{$EXTERNALSYM ConvertSidToStringSid}
{$IFEND}

{$IF RTLVersion < 19.0}
{ Win32API LookupAccountName }
{$IFNDEF Unicode}
function LookupAccountName(lpSystemName, lpAccountName: LPCSTR;
  Sid: PSID; var cbSid: DWORD; ReferencedDomainName: LPSTR;
  var cbReferencedDomainName: DWORD; var peUse: SID_NAME_USE): BOOL; stdcall; external advapi32 name 'LookupAccountNameA';
{$ELSE}
function LookupAccountName(lpSystemName, lpAccountName: LPCWSTR;
  Sid: PSID; var cbSid: DWORD; ReferencedDomainName: LPWSTR;
  var cbReferencedDomainName: DWORD; var peUse: SID_NAME_USE): BOOL; stdcall; external advapi32 name 'LookupAccountNameW';
{$ENDIF}
{$EXTERNALSYM LookupAccountName}
{$IFEND}

function UsernameToSid(const AUsername: String): String;
var
  PSID: Pointer;
  SidSize: DWORD;
  Domain: String;
  DomainLen: DWORD;
  SidName: SID_NAME_USE;
  SidStr: PChar;
begin
  PSID := nil;
  SidStr := nil;
  try
    SidSize := 0;
    DomainLen := 0;
    LookupAccountName(nil,PChar(AUsername),nil,SidSize,nil,DomainLen,SidName);
    if GetLastError <> ERROR_INSUFFICIENT_BUFFER then
    begin
      RaiseLastOSError;
    end;

    PSID := Pointer(LocalAlloc(LPTR,SidSize));
    SetLength(Domain,DomainLen);
    if LookupAccountName(nil,PChar(AUsername),PSID,SidSize,PChar(Domain),DomainLen,SidName) = False then
    begin
      RaiseLastOSError;
    end;

    ConvertSidToStringSid(PSID,SidStr);
    SetString(Result,SidStr,StrLen(SidStr));

  finally
    if PSID <> nil then
    begin
{$IF RTLVersion >= 32.0}
      if LocalFree(PSID) <> nil then
{$ELSE}
{$IFNDEF WIN64}
      if LocalFree(DWORD(PSID)) <> 0 then
{$ELSE}
      if LocalFree(UInt64(PSID)) <> 0 then
{$ENDIF}
{$IFEND}
      begin
        RaiseLastOSError;
      end;
    end;

    if SidStr <> nil then
    begin
{$IF RTLVersion >= 32.0}
      if LocalFree(SidStr) <> nil then
{$ELSE}
{$IFNDEF WIN64}
      if LocalFree(DWORD(SidStr)) <> 0 then
{$ELSE}
      if LocalFree(UInt64(SidStr)) <> 0 then
{$ENDIF}
{$IFEND}
      begin
        RaiseLastOSError;
      end;
    end;
  end;
end;
まずLookupAccountName関数でユーザ名に対応するSIDをSID構造体に取得し、これをConvertSidToStringSid関数で文字列に変換します。このときLookupAccountName関数を一旦SID=nil、ReferencedDomainName=nilで呼び出して必要なサイズを取得し、SIDはLocalAlloc関数で、ReferencedDomainNameは(文字列なので)SetLengthで領域を確保して、もう一度LookupAccountName関数を呼ぶようにしているのと、LocalAlloc関数、ConvertSidToStringSid関数で確保された領域はLocalFree関数で解放しなければならない、というところに気をつける必要があります(DelphiのバージョンによってLocalFree関数の宣言に差異があるので$IF RTLVersionと$IFNDEF WIN64で分岐しています)。

次にSIDをユーザ名に変換します。
{$IF RTLVersion < 28.0}
{ Win32API ConvertStringSidToSid }
{$IFNDEF Unicode}
function ConvertStringSidToSid(StringSid: LPCSTR; var Sid: PSID): BOOL; stdcall; external advapi32 name 'ConvertStringSidToSidA';
{$ELSE}
function ConvertStringSidToSid(StringSid: LPCWSTR; var Sid: PSID): BOOL; stdcall; external advapi32 name 'ConvertStringSidToSidW';
{$ENDIF}
{$EXTERNALSYM ConvertStringSidToSid}
{$IFEND}

{$IF RTLVersion < 19.0}
{ Win32API LookupAccountSid }
{$IFNDEF Unicode}
function LookupAccountSid(lpSystemName: LPCSTR; Sid: PSID;
  Name: LPSTR; var cbName: DWORD; ReferencedDomainName: LPSTR;
  var cbReferencedDomainName: DWORD; var peUse: SID_NAME_USE): BOOL; stdcall; external advapi32 name 'LookupAccountSidA';
{$ELSE}
function LookupAccountSid(lpSystemName: LPCWSTR; Sid: PSID;
  Name: LPWSTR; var cbName: DWORD; ReferencedDomainName: LPWSTR;
  var cbReferencedDomainName: DWORD; var peUse: SID_NAME_USE): BOOL; stdcall; external advapi32 name 'LookupAccountSidW';
{$ENDIF}
{$EXTERNALSYM LookupAccountSid}
{$IFEND}

function SidToUsername(const ASID: String): String;
var
  PSID: Pointer;
  UserNameLen: DWORD;
  Domain: String;
  DomainLen: DWORD;
  SidName: SID_NAME_USE;
begin
  PSID := nil;
  try
    if ConvertStringSidToSid(PChar(ASID),PSID) = False then
    begin
      RaiseLastOSError;
    end;

    UserNameLen := 0;
    DomainLen := 0;
    LookupAccountSid(nil,PSID,nil,UserNameLen,nil,DomainLen,SidName);
    if GetLastError <> ERROR_INSUFFICIENT_BUFFER then
    begin
      RaiseLastOSError;
    end;

    SetLength(Result,UserNameLen);
    SetLength(Domain,DomainLen);
    if LookupAccountSid(nil,PSID,PChar(Result),UserNameLen,PChar(Domain),DomainLen,SidName) = False then
    begin
      RaiseLastOSError;
    end;

    SetLength(Result,StrLen(PChar(Result)));

  finally
    if PSID <> nil then
    begin
{$IF RTLVersion >= 32.0}
      if LocalFree(PSID) <> nil then
{$ELSE}
{$IFNDEF WIN64}
      if LocalFree(DWORD(PSID)) <> 0 then
{$ELSE}
      if LocalFree(UInt64(PSID)) <> 0 then
{$ENDIF}
{$IFEND}
      begin
        RaiseLastOSError;
      end;
    end;
  end;
end;
こちらはまずConvertStringSidToSid関数でSIDの文字列をSID構造体に変換し、LookupAccountSid関数でユーザ名に変換します。こちらもLookupAccountSid関数をName=nil、ReferencedDomainName=nilで呼び出して必要なサイズを取得し、SetLengthで領域を確保してからもう一度LookupAccountSid関数を呼び出しています。またConvertStringSidToSid関数で確保したSID構造体はLocalFree関数で解放します。

使用しているWin32APIのうち、LookupAccountSid関数/LookupAccountName関数はDelphi 2009で、ConvertStringSidToSid関数/ConvertSidToStringSid関数はDelphi XE7で(Win32API.)Windowsユニットに関数宣言が追加されたため、それ以前のバージョンでは明示的に定義が必要です。

→Windows上のユーザ名とSIDを相互変換(Gist)

2017年12月5日

JCLでお手軽に例外発生時のスタックトレースを取る

このアーティクルはDelphi Advent Calendar 2017の5日目の記事です(2年ぶり4回目)。またゆるふぁい#0のLTの内容を元にしています。なお以下の説明は基本的にVCLアプリケーションのお話になります。

Delphiで作成したプログラムを実行中にエラーが発生すると例外が送出されます。
procedure TForm1.Button1Click(Sender: TObject);
var
  P: PInteger;
begin
  P := nil;
  P^ := 42;  // EAccessViolation
end;
プログラム上で捕捉されなかった例外(unhandled exception)は、デフォルトの例外の処理としてApplicationオブジェクトで捕捉されてエラーメッセージを表示します。

このとき例外の原因になった処理のアドレスは詳細マップファイルを生成しておけばわかります(後述)。しかしエラーが発生した箇所までの実行経路(呼び出し経路)が複雑だったり、Systemユニットにあるような低レベルの関数のように、どこから呼ばれるのかの選択肢が非常に多い箇所でエラーが発生した場合は、単に例外が発生したアドレスがわかるだけでは不十分です。デバッガ上で動作させているのであればDelphiのIDEで例外発生時の呼び出し履歴を見ればよいのですが、客先環境でしか再現しないような場合などでスタックトレースを取ることができれば問題解決の大きな助けになります。そこで簡単にできる方法として、JCL(JEDI Code Library)のJCL Debugを使って例外送出箇所までのスタックトレースを取得してみます(もちろん商用製品のmadExceptやEurekaLogであればもっといろいろなことができるとは思います)。

JCL(JEDI Code Library)はJEDIプロジェクトによるライブラリ群です。ビジュアルコンポーネントのJVCL(JEDI VCL)とともにインストールされていることも多いのではないでしょうか。新たにインストールする場合は、Delphiの複数バージョンがインストールされている環境ではリポジトリ(JCL、JVCL)から取得してインストール、単一のバージョンのみならGetItパッケージマネージャからインストール、Starter SKUであればCC(JCL、JVCL)からバイナリインストーラをダウンロードしてインストール、ということになります(詳細な手順は省略します)。JCLがインストールされると、"メインメニュー"→"プロジェクト"の一番下あたりに"JCL Debug expert"というアイテムが追加されているはずです。

さて、ここまで来れば、必要な手順はたった4つです。プロジェクトを開いておいて、

ステップ1: "JCL Debug expert"の"Generate .jdbg files"を有効("Always enabled"または"Enabled for this project")にします。

ステップ2: "Insert JDBG data into the binary"を有効("Always enabled"または"Enabled for this project")にします。

ステップ3: "メインメニュー"→"プロジェクト"→"オプション"で"プロジェクトオプション"ダイアログを表示し、必要なターゲットを選択("すべての構成 - すべてのプラットフォーム"でいいと思います)して、"Delphiコンパイラ"→"リンク"の"マップファイル, 64ビット Windows, 32ビット Windows, OS X, iOS シミュレータ プラットフォームのみ"を"詳細"に変更します。

ステップ4: "メインメニュー"→"ファイル"→"新規作成"→"その他"で"新規作成"ダイアログを表示して、"Delphiプロジェクト"→"Delphiファイル"から"JCL Exception dialog for Delphi"を選択すると"New exception dialog..."ウィザードが表示されます。ここでPage 1 of 7の"Unit file name"に例外ダイアログのユニット名を入れ、Page 2 of 7の"Sizeable dialog"にチェックして(他の項目はとりあえずデフォルトのままでOK)、"Finish"ボタンをクリックすると例外ダイアログのユニットが作成されます。ただこのままだと表示フォントが英語環境向けなので、プロジェクトで使用しているフォントに合わせたほうがいいと思います(とりあえずフォームをテキスト表示にして"Font.*"の項目を全部削除すればデフォルトになります)。

これでプロジェクトをコンパイルすると確認ダイアログが表示されますが、これは詳細マップを作る設定に変更しますか?という確認なのでそのまま"OK"とします。これでコンパイルされたプログラムを実行すると例外ダイアログが表示されますが、ここで"Details"ボタンをクリックすると、スタックトレースが表示されます。

------------------------------------------------------------------------------
Exception log with detailed tech info. Generated on 2017/11/09 19:39:30.
You may send it to the application vendor, helping him to understand what had happened.
Application title: Project1
Application file: (省略)\Win32\Debug\Project1.exe
------------------------------------------------------------------------------
Exception class: EAccessViolation
Exception message: モジュール 'Project1.exe' のアドレス 005D908C でアドレス 00000000 に対する書き込み違反がおきました。.
Exception address: 005D908C
------------------------------------------------------------------------------
Main thread ID = 2320
Exception thread ID = 2320
------------------------------------------------------------------------------
Exception stack
Stack list, generated 2017/11/09 19:39:30
[005D908C]{Project1.exe} Unit1.TForm1.Button1Click (Line 31, "Unit1.pas" + 2)
[00522143]{Project1.exe} Vcl.Controls.TControl.Click (Line 7442, "Vcl.Controls.pas" + 9)
[00526749]{Project1.exe} Vcl.Controls.TWinControl.WndProc (Line 10160, "Vcl.Controls.pas" + 158)
[0053B254]{Project1.exe} Vcl.StdCtrls.TButtonControl.WndProc (Line 5278, "Vcl.StdCtrls.pas" + 13)
[005268AF]{Project1.exe} Vcl.Controls.DoControlMsg (Line 10229, "Vcl.Controls.pas" + 12)
[00526749]{Project1.exe} Vcl.Controls.TWinControl.WndProc (Line 10160, "Vcl.Controls.pas" + 158)
[005C3E0D]{Project1.exe} Vcl.Forms.TCustomForm.WndProc (Line 4546, "Vcl.Forms.pas" + 209)
[00525D68]{Project1.exe} Vcl.Controls.TWinControl.MainWndProc (Line 9867, "Vcl.Controls.pas" + 3)
[004C590C]{Project1.exe} System.Classes.StdWndProc (Line 17364, "System.Classes.pas" + 8)
[0052685A]{Project1.exe} Vcl.Controls.TWinControl.DefaultHandler (Line 10201, "Vcl.Controls.pas" + 30)
[00526749]{Project1.exe} Vcl.Controls.TWinControl.WndProc (Line 10160, "Vcl.Controls.pas" + 158)
[0053B254]{Project1.exe} Vcl.StdCtrls.TButtonControl.WndProc (Line 5278, "Vcl.StdCtrls.pas" + 13)
[004C590C]{Project1.exe} System.Classes.StdWndProc (Line 17364, "System.Classes.pas" + 8)
------------------------------------------------------------------------------
Call stack for main thread
Stack list, generated 2017/11/09 19:39:30
[773A0C52]{ntdll.dll } ZwGetContextThread
(以下省略)
------------------------------------------------------------------------------
こんな感じで例外発生までの呼び出し履歴が表示されます。スタックトレースの表示項目はこの場合、左からアドレス、実行ファイル、メソッド、ソースコード内の当該行番号、ユニット名、メソッド先頭からの行オフセットとなっています(リンクされたユニットのデバッグ情報によって表示される項目が異なります)。

JCL Debugを有効にするとプロジェクトファイル(.dpr)の先頭に
// JCL_DEBUG_EXPERT_GENERATEJDBG ON
// JCL_DEBUG_EXPERT_INSERTJDBG ON
の2行が追加され、リンク時に.mapファイルから.jdbgファイルを生成して、これを実行ファイルに埋め込んでくれます。一方で例外ダイアログではこの.jdbgファイルの情報からスタックトレースに必要な情報を取り出して上記のような表示を行ってくれる、という仕組みです。

また例外ダイアログを使わずログなどに記録するような場合は、
unit DumpExceptionStack;

interface

uses
  Winapi.Windows,
  System.SysUtils,
  JclBase, JclDebug;

function DumpLastExceptStackInfoList(const Separator: String = '|'): String;


implementation

function GetStackInfoDescription(const Addr: Pointer): String;
var
  Info: TJclLocationInfo;
  StartProcInfo: TJclLocationInfo;
  OffsetStr: String;
  StartProcOffsetStr: String;
  FixedProcedureName: String;
  UnitNameWithoutUnitscope: String;
begin

  OffsetStr := '';

  if GetLocationInfo(Addr, Info) = True then
  begin
    with Info do
    begin
      FixedProcedureName := ProcedureName;
      if Pos(UnitName + '.', FixedProcedureName) = 1 then
      begin
        FixedProcedureName := Copy(FixedProcedureName,
                                   Length(UnitName) + 2,
                                   Length(FixedProcedureName) - Length(UnitName) - 1);
      end
      else if Pos('.', UnitName) > 1 then
      begin
        UnitNameWithoutUnitscope := UnitName;
        Delete(UnitNameWithoutUnitscope, 1, Pos('.', UnitNameWithoutUnitscope));
        if Pos(UnitNameWithoutUnitscope + '.', FixedProcedureName) = 1 then
        begin
          FixedProcedureName := Copy(FixedProcedureName, Length(UnitNameWithoutUnitscope) + 2, Length(FixedProcedureName) - Length(UnitNameWithoutUnitscope) - 1);
        end;
      end;

      if LineNumber > 0 then
      begin
        if (GetLocationInfo(Pointer(TJclAddr(Info.Address) - Cardinal(Info.OffsetFromProcName)), StartProcInfo) = True) and
           (StartProcInfo.LineNumber > 0) then
        begin
          StartProcOffsetStr := Format(' + %d', [LineNumber - StartProcInfo.LineNumber]);
        end
        else
        begin
          StartProcOffsetStr := '';
        end;

        if OffsetFromLineNumber >= 0 then
        begin
          OffsetStr := Format(' +0x%x', [OffsetFromLineNumber]);
        end
        else
        begin
          OffsetStr := Format(' -0x%x', [-OffsetFromLineNumber]);
        end;

        Result := Format('[0x%p] %s.%s (Line %u, "%s"%s)%s',
                         [Addr, UnitName, FixedProcedureName, LineNumber, SourceName, StartProcOffsetStr, OffsetStr]);
      end
      else
      begin
        OffsetStr := Format(' +0x%x', [OffsetFromProcName]);
        if UnitName <> '' then
        begin
          Result := Format('[0x%p] %s.%s%s', [Addr, UnitName, FixedProcedureName, OffsetStr]);
        end
        else
        begin
          Result := Format('[0x%p] %s%s', [Addr, FixedProcedureName, OffsetStr]);
        end;
      end;
    end;
  end
  else
  begin
    Result := Format('[0x%p]', [Addr]);
  end;

end;

function DumpLastExceptStackInfoList(const Separator: String = '|'): String;
var
  I: Integer;
begin

  Result := '';

  with JclLastExceptStackList do
  begin
    ForceStackTracing;
    for I := 0 to Count - 1 do
    begin
      Result := Result + GetStackInfoDescription(Items[I].CallerAddr) + Separator;
    end;
  end;

  if Result <> '' then
  begin
    Delete(Result,Length(Result) - Length(Separator) + 1,Length(Separator));
  end;

end;

initialization
//  Include(JclStackTrackingOptions, stRawMode);
  Include(JclStackTrackingOptions, stStaticModuleList);
  JclStartExceptionTracking;

finalization
  JclStopExceptionTracking;

end.
このようなユニットをプロジェクトファイルのなるべく先頭のほうでusesしておき、TApplicationEventsコンポーネントのOnExceptionイベントで
procedure TForm1.ApplicationEvents1Exception(Sender: TObject; E: Exception);
begin
  Memo1.Lines.Add(DumpLastExceptStackInfoList(sLineBreak));
end;
というように処理させることもできます。

JCL Debugのいいところとしては、無料であること、またJCL/JVCLを入れてあればそれだけで使えることがあげられます。一方でいまいちなところとしては、メインスレッド以外のスレッドを扱うときはTThreadからではなくTJclDebugThreadから派生していないとスタックトレースがとれないこと、リソースDLLで言語切り替えをするプロジェクトでは、言語リソースDLLのコンパイルでいちいちエラーになってJCLの例外ダイアログが表示されること、それ以外にもJCL Debugを有効にしているとIDEでJCLの例外ダイアログが頻繁に表示されること、などがあります。

ところで例外時の(通常の)アドレス表示からソースコードの場所を特定するには、マップファイルを参照します(こちらも詳細がお勧めです)。表示されたアドレスから、マップファイルの先頭にある

Start Length Name Class
0001:00401000 001D3B24H .text CODE
0002:005D5000 0000155CH .itext ICODE
...
のCODEの値、通常は0x00401000を引きます。この値がマップファイル上のアドレス表示の"0001:XXXXXXXX"のXXXXXXXXに相当します。次にマップファイルの"Publics by Value"のリストの"0001:"の部分を上から順に、このアドレスと同じか、より小さく最も近い行を探します。見つかった行が例外を発生させたメソッドになります。さらに詳細マップであれば"Line numbers for"でこのアドレスを探していき、見つかったらそこに書かれているのがユニット(ソースコード)の名前と、行番号になります。

→JclDebugでスタックトレースを取得する(Gist)

2017年3月22日

ジェネリックスのリストをアルゴリズムを指定してソートする

Delphi 2009で導入されたジェネリックスのコンテナの一つであるTList<T>にはSortメソッドがあり、比較関数としてデフォルト以外のComparer(コンペアラ)も渡すことができるのですが、ソートアルゴリズムそのものはクイックソートしかありません。一般的には平均して性能が出るとされるクイックソートですが、安定ではないこと、苦手な状況が存在することなど、決して万能というわけではありません。ところがTList<T>.Sortは内部で保持しているTArray.Sortにソートを丸投げしており、ソートアルゴリズムを変更することができません。そこでアルゴリズムを指定してTList<T>(およびTObjectList<T: class>)をソートする方法を考えてみました。ただしDelphi 2009のTList<T>にはExchangeメソッドもMoveメソッドも存在していないため、Delphi 2010以降の対応になります。

まずソートを行うためのレコード型と、ソートアルゴリズムを実装するクラスの継承元クラスの宣言です。
{$IF RTLVersion <= 20.00}
{$MESSAGE ERROR 'Need Delphi 2010 or later'}
{$IFEND}

uses
{$IF RTLVersion >= 23.00}
  System.Rtti, System.Generics.Defaults, System.Generics.Collections;
{$ELSE}
  Rtti, Generics.Defaults, Generics.Collections;
{$IFEND}

type
  { Forward declarations }
  TSortAlgorithm<T> = class;

  { TGenericListSorter }
  TGenericListSorter = record
  private
    class function  GetComparer<T>(List: TList<T>; const AComparer: IComparer<T>): IComparer<T>; static;
  public
    class procedure Sort<T: record>(List: TList<T>; Algorithm: TSortAlgorithm<T>;
                                    const AComparer: IComparer<T>{$IF CompilerVersion >= 24.00} = nil{$IFEND}); overload; static;
{$IF CompilerVersion < 24.00}
    class procedure Sort<T: record>(List: TList<T>; Algorithm: TSortAlgorithm<T>); overload; static;
{$IFEND}
    class procedure Sort<T: class>(List: TObjectList<T>; Algorithm: TSortAlgorithm<T>;
                                   const AComparer: IComparer<T>{$IF CompilerVersion >= 24.00} = nil{$IFEND}); overload; static;
{$IF CompilerVersion < 24.00}
    class procedure Sort<T: class>(List: TObjectList<T>; Algorithm: TSortAlgorithm<T>); overload; static;
{$IFEND}
    class procedure Sort(List: TList<String>; Algorithm: TSortAlgorithm<String>;
                         const AComparer: IComparer<String>{$IF CompilerVersion >= 24.00} = nil{$IFEND}); overload; static;
{$IF CompilerVersion < 24.00}
    class procedure Sort(List: TList<String>; Algorithm: TSortAlgorithm<String>); overload; static;
{$IFEND}
  end;

  { TSortAlgorithm (abstract) }
  TSortAlgorithm<T> = class(TObject)
  public
    class function  Instance: TSortAlgorithm<T>; virtual; abstract;
    class procedure Sort(List: TList<T>; const AComparer: IComparer<T>); virtual; abstract;
  end;
TGenericListSorterはソートを行うためのレコード型で、overloadされたpublicな3つ(XE2およびそれ以前は6つ、後述)のSortメソッドと、比較を行うコンペアラを決定するためのprivateなGetComparerメソッドを持ちます。Sortメソッドの1つめは値型用(レコード制約)、2つめはクラス型用(クラス制約)、3つめはこのどちらにも含まれない文字列型用です。IComparer<T>にデフォルトパラメータを指定できるのはDelphi XE3以降のため、それ以前のバージョンではコンペアラを指定しないオーバロードをさらに3つ用意しました。またTSortAlgorithm<T>はソートアルゴリズムを実装するためのクラスの継承元になります。実際にソートを行うSortメソッドと、シングルトンなインスタンスを取得するためのInstanceメソッドを持ちます。TGenericListSorterの実装は次のようになります。
class procedure TGenericListSorter.Sort<T>(List: TList<T>; Algorithm: TSortAlgorithm<T>;
                                           const AComparer: IComparer<T>);
var
  Comparer: IComparer<T>;
begin

  if (List = nil) or (List.Count <= 1) then
  begin
    Exit;
  end;

  Comparer := GetComparer<T>(List,AComparer);

  Algorithm.Sort(List,Comparer);

end;

{$IF CompilerVersion < 24.00}
class procedure TGenericListSorter.Sort<T>(List: TList<T>; Algorithm: TSortAlgorithm<T>);
var
  Comparer: IComparer<T>;
begin

  if (List = nil) or (List.Count <= 1) then
  begin
    Exit;
  end;

  Comparer := GetComparer<T>(List,nil);

  Algorithm.Sort(List,Comparer);

end;
{$IFEND}

class procedure TGenericListSorter.Sort<T>(List: TObjectList<T>; Algorithm: TSortAlgorithm<T>;
                                           const AComparer: IComparer<T>);
var
  Comparer: IComparer<T>;
  OwnsObjects: Boolean;
begin

  if (List = nil) or (List.Count <= 1) then
  begin
    Exit;
  end;

  Comparer := GetComparer<T>(List,AComparer);

  OwnsObjects := List.OwnsObjects;
  try
    List.OwnsObjects := False;
    Algorithm.Sort(List,Comparer);

  finally
    List.OwnsObjects := OwnsObjects;
  end;

end;

{$IF CompilerVersion < 24.00}
class procedure TGenericListSorter.Sort<T>(List: TObjectList<T>; Algorithm: TSortAlgorithm<T>);
var
  Comparer: IComparer<T>;
  OwnsObjects: Boolean;
begin

  if (List = nil) or (List.Count <= 1) then
  begin
    Exit;
  end;

  Comparer := GetComparer<T>(List,nil);

  OwnsObjects := List.OwnsObjects;
  try
    List.OwnsObjects := False;
    Algorithm.Sort(List,Comparer);

  finally
    List.OwnsObjects := OwnsObjects;
  end;

end;
{$IFEND}

class procedure TGenericListSorter.Sort(List: TList<String>; Algorithm: TSortAlgorithm<String>;
                                        const AComparer: IComparer<String>);
var
  Comparer: IComparer<String>;
begin

  if (List = nil) or (List.Count <= 1) then
  begin
    Exit;
  end;

  Comparer := GetComparer<String>(List,AComparer);

  Algorithm.Sort(List,Comparer);

end;

{$IF CompilerVersion < 24.00}
class procedure TGenericListSorter.Sort(List: TList<String>; Algorithm: TSortAlgorithm<String>);
var
  Comparer: IComparer<String>;
begin

  if (List = nil) or (List.Count <= 1) then
  begin
    Exit;
  end;

  Comparer := GetComparer<String>(List,nil);

  Algorithm.Sort(List,Comparer);

end;
{$IFEND}

class function TGenericListSorter.GetComparer<T>(List: TList<T>; const AComparer: IComparer<T>): IComparer<T>;
var
  ctx: TRttiContext;
begin

  Result := AComparer;
  if Result = nil then
  begin
    Result := ctx.GetType(List.ClassType).GetField('FComparer').GetValue(List).AsType<IComparer<T>>;
  end;

end;
Sortメソッドはいずれもコンペアラを確定し、指定されたソートアルゴリズムのインスタンスのSortメソッドを呼び出しています。ただしTObjectList<T>用のオーバロードはソートを行っている間、一時的にOwnsObjectsをFalseに変更しています。これはOwnsObjectsがTrueだと(以下の例のマージソートのように)Items[]に代入を行ったときに、もともと格納されているTのインスタンスを解放してしまうためで、ソートアルゴリズムのクラスで直接ソートを行うのではなく、レコード型TGenericListSorterの3つのオーバロードに処理を分けて、そこから間接的に呼び出すようになっているのはこれが理由です。またGetComparerメソッドはコンペアラが指定されていない(=nil)ときに、TList<T>の持つデフォルトのコンペアラを(RTTIを使って)取得します。 次に実際のソートアルゴリズムを実装したクラスですが、まずコムソートを実装してみます。
type
  TCombSort<T> = class(TSortAlgorithm<T>)
  protected
    class var
      FInstance: TSortAlgorithm<T>;
  public
    class destructor Destroy;
    class function   Instance: TSortAlgorithm<T>; override;
    class procedure  Sort(List: TList<T>; const AComparer: IComparer<T>); override;
  end;

class destructor TCombSort<T>.Destroy;
begin

  FInstance.Free;

end;

class function TCombSort<T>.Instance: TSortAlgorithm<T>;
begin

  if FInstance = nil then
  begin
    FInstance := Self.Create;
  end;

  Result := FInstance;

end;

class procedure TCombSort<T>.Sort(List: TList<T>; const AComparer: IComparer<T>);
const
  SHRINK_FACTOR = 1.247330950103979;
var
  Index: Integer;
  Gap: Integer;
  Swapped: Boolean;
begin

  Gap := List.Count;
  Swapped := True;

  while (Gap > 1) or (Swapped = True) do
  begin
    if Gap > 1 then
    begin
      Gap := Trunc(Gap / SHRINK_FACTOR);
    end;

    if Gap < 1 then
    begin
      Gap := 1;
    end;

    Swapped := False;
    Index := 0;

    while (Gap + Index) < List.Count do
    begin
      if AComparer.Compare(List.Items[Index],List.Items[Index + Gap]) > 0 then
      begin
        List.Exchange(Index,Index + Gap);
        Swapped := True;
      end;
      Index := Index + 1;
    end;
  end;

end;
前述の通り(TGenericListSorterとは異なり)1種類の<T>に対してのみSortを実装すればよいようになっています。またSortメソッド以外にシングルトンなインスタンスを取得するためのInstanceメソッドと、そのインスタンスを解放するためのクラスデストラクタを用意します。これで例えばInteger型のリストに対しては
var
  I: Integer;
  Value: Integer;
  List: TList<Integer>;
begin
  List := TList<Integer>.Create;
  try
    for I := 0 to 999 do
    begin
      List.Add(Random(100000));
    end;

    TGenericListSorter.Sort<Integer>(List,TCombSort<Integer>.Instance,TComparer<Integer>.Construct(
      function(const Left, Right: Integer): Integer
      begin
        Result := Left - Right;
      end));

    for Value in List do
    begin
      Memo1.Lines.Add(IntToStr(Value));
    end;

  finally
    List.Free;
  end
end;
このような形でソートを呼び出すことができます。 同じようにその他のソートアルゴリズムを実装していきます。ノームソートです。
type
  TGnomeSort<T> = class(TSortAlgorithm<T>)
  protected
    class var
      FInstance: TSortAlgorithm<T>;
  public
    class destructor Destroy;
    class function   Instance: TSortAlgorithm<T>; override;
    class procedure  Sort(List: TList<T>; const AComparer: IComparer<T>); override;
  end;

class destructor TGnomeSort<T>.Destroy;
begin

  FInstance.Free;

end;

class function TGnomeSort<T>.Instance: TSortAlgorithm<T>;
begin

  if FInstance = nil then
  begin
    FInstance := Self.Create;
  end;

  Result := FInstance;

end;

class procedure TGnomeSort<T>.Sort(List: TList<T>; const AComparer: IComparer<T>);
var
  Index: Integer;
begin

  Index := 0;
  while Index < List.Count do
  begin
    if (Index = 0) or (AComparer.Compare(List.Items[Index],List.Items[Index - 1]) >= 0) then
    begin
      Index := Index + 1;
    end
    else
    begin
      List.Exchange(Index,Index - 1);
      Index := Index - 1;
    end;
  end;

end;
選択ソートです。
type
  TSelectionSort<T> = class(TSortAlgorithm<T>)
  protected
    class var
      FInstance: TSortAlgorithm<T>;
  public
    class destructor Destroy;
    class function   Instance: TSortAlgorithm<T>; override;
    class procedure  Sort(List: TList<T>; const AComparer: IComparer<T>); override;
  end;

class destructor TSelectionSort<T>.Destroy;
begin

  FInstance.Free;

end;

class function TSelectionSort<T>.Instance: TSortAlgorithm<T>;
begin

  if FInstance = nil then
  begin
    FInstance := Self.Create;
  end;

  Result := FInstance;

end;

class procedure TSelectionSort<T>.Sort(List: TList<T>; const AComparer: IComparer<T>);
var
  Index1: Integer;
  Index2: Integer;
  MinIndex: Integer;
  Temp: T;
begin

  for Index1 := 0 to List.Count - 2 do
  begin
    MinIndex := Index1;
    Temp := List.Items[MinIndex];

    for Index2 := Index1 + 1 to List.Count - 1 do
    begin
      if AComparer.Compare(List.Items[Index2],Temp) < 0 then
      begin
        MinIndex := Index2;
        Temp := List.Items[MinIndex];
      end;
    end;

    if MinIndex <> Index1 then
    begin
      List.Move(MinIndex,Index1);
    end;
  end;

end;
挿入ソートです。
type
  TInsertionSort<T> = class(TSortAlgorithm<T>)
  protected
    class var
      FInstance: TSortAlgorithm<T>;
  public
    class destructor Destroy;
    class function   Instance: TSortAlgorithm<T>; override;
    class procedure  Sort(List: TList<T>; const AComparer: IComparer<T>); override;
  end;

class destructor TInsertionSort<T>.Destroy;
begin

  FInstance.Free;

end;

class function TInsertionSort<T>.Instance: TSortAlgorithm<T>;
begin

  if FInstance = nil then
  begin
    FInstance := Self.Create;
  end;

  Result := FInstance;

end;

class procedure TInsertionSort<T>.Sort(List: TList<T>; const AComparer: IComparer<T>);
var
  Comparer: IComparer<T>;
  Index1: Integer;
  Index2: Integer;
  Temp: T;
begin

  for Index1 := 1 to List.Count - 1 do
  begin
    Temp := List.Items[Index1];
    Index2 := Index1 - 1;

    while (Index2 >= 0) and (AComparer.Compare(List.Items[Index2],Temp) > 0) do
    begin
      Index2 := Index2 - 1;
    end;

    List.Move(Index1,Index2 + 1);
  end;

end;
クイックソートです。
type
  TQuickSort<T> = class(TSortAlgorithm<T>)
  protected
    class var
      FInstance: TSortAlgorithm<T>;
    class procedure  InternalSort(List: TList<T>; Left: Integer; Right: Integer;
                                  const AComparer: IComparer<T>);
    class function   Partition(List: TList<T>; Left: Integer; Right: Integer;
                               const AComparer: IComparer<T>): Integer;
  public
    class destructor Destroy;
    class function   Instance: TSortAlgorithm<T>; override;
    class procedure  Sort(List: TList<T>; const AComparer: IComparer<T>); override;
  end;

class destructor TQuickSort<T>.Destroy;
begin

  FInstance.Free;

end;

class function TQuickSort<T>.Instance: TSortAlgorithm<T>;
begin

  if FInstance = nil then
  begin
    FInstance := Self.Create;
  end;

  Result := FInstance;

end;

class procedure TQuickSort<T>.Sort(List: TList<T>; const AComparer: IComparer<T>);
var
  Comparer: IComparer<T>;
begin

  InternalSort(List,0,List.Count - 1,AComparer);

end;

class procedure TQuickSort<T>.InternalSort(List: TList<T>; Left: Integer; Right: Integer;
                                           const AComparer: IComparer<T>);
var
  Pivot: Integer;
begin

  if Left < Right then
  begin
    Pivot := Partition(List,Left,Right,AComparer);

    InternalSort(List,Left,     Pivot,AComparer);
    InternalSort(List,Pivot + 1,Right,AComparer);
  end;

end;

class function TQuickSort<T>.Partition(List: TList<T>; Left: Integer; Right: Integer;
                                       const AComparer: IComparer<T>): Integer;
var
  Index1: Integer;
  Index2: Integer;
  Pivot: T;
begin

  Pivot := List.Items[(Left + Right) div 2];
  Index1 := Left  - 1;
  Index2 := Right + 1;

  while True do
  begin
    repeat
      Index1 := Index1 + 1;
    until (AComparer.Compare(List.Items[Index1],Pivot) >= 0);

    repeat
      Index2 := Index2 - 1;
    until (AComparer.Compare(List.Items[Index2],Pivot) <= 0);

    if Index1 >= Index2 then
    begin
      Result := Index2;
      Exit;
    end;

    List.Exchange(Index1,Index2);
  end;

end;
ヒープソートです。
type
  THeapSort<T> = class(TSortAlgorithm<T>)
  protected
    class var
      FInstance: TSortAlgorithm<T>;
    class procedure  BuildHeap(List: TList<T>; const AComparer: IComparer<T>);
    class procedure  Heapify(List: TList<T>; Index: Integer; Max: Integer;
                             const AComparer: IComparer<T>);
  public
    class destructor Destroy;
    class function   Instance: TSortAlgorithm<T>; override;
    class procedure  Sort(List: TList<T>; const AComparer: IComparer<T>); override;
  end;

class destructor THeapSort<T>.Destroy;
begin

  FInstance.Free;

end;

class function THeapSort<T>.Instance: TSortAlgorithm<T>;
begin

  if FInstance = nil then
  begin
    FInstance := Self.Create;
  end;

  Result := FInstance;

end;

class procedure THeapSort<T>.Sort(List: TList<T>; const AComparer: IComparer<T>);
var
  Index: Integer;
begin

  BuildHeap(List,AComparer);

  for Index := List.Count - 1 downto 1 do
  begin
    List.Exchange(0,Index);

    Heapify(List,0,Index,AComparer);
  end;

end;

class procedure THeapSort<T>.BuildHeap(List: TList<T>; const AComparer: IComparer<T>);
var
  Index: Integer;
begin

  for Index := (List.Count div 2) - 1 downto 0 do
  begin
    Heapify(List,Index,List.Count,AComparer);
  end;

end;

class procedure THeapSort<T>.Heapify(List: TList<T>; Index: Integer; Max: Integer;
                                     const AComparer: IComparer<T>);
var
  Left: Integer;
  Right: Integer;
  Largest: Integer;
begin

  Left  := Index * 2 + 1;
  Right := Index * 2 + 2;

  if (Left < Max) and (AComparer.Compare(List.Items[Left],List.Items[Index]) > 0) then
  begin
    Largest := Left;
  end
  else
  begin
    Largest := Index;
  end;

  if (Right < Max) and (AComparer.Compare(List.Items[Right],List.Items[Largest]) > 0) then
  begin
    Largest := Right;
  end;

  if Largest <> Index then
  begin
    List.Exchange(Index,Largest);

    Heapify(List,Largest,Max,AComparer);
  end;

end;
マージソートです。
type
  TMergeSort<T> = class(TSortAlgorithm<T>)
  protected
    class var
      FInstance: TSortAlgorithm<T>;
    class procedure  InternalSort(List: TList<T>; var Work: array of T;
                                  Left: Integer; Right: Integer;
                                  const AComparer: IComparer<T>);
  public
    class destructor Destroy;
    class function   Instance: TSortAlgorithm<T>; override;
    class procedure  Sort(List: TList<T>; const AComparer: IComparer<T>); override;
  end;

class destructor TMergeSort<T>.Destroy;
begin

  FInstance.Free;

end;

class function TMergeSort<T>.Instance: TSortAlgorithm<T>;
begin

  if FInstance = nil then
  begin
    FInstance := Self.Create;
  end;

  Result := FInstance;

end;

class procedure TMergeSort<T>.Sort(List: TList<T>; const AComparer: IComparer<T>);
var
  WorkArea: array of T;
begin

  SetLength(WorkArea,List.Count);
  try
    InternalSort(List,WorkArea,0,List.Count - 1,AComparer);

  finally
    SetLength(WorkArea,0);
  end;

end;

class procedure TMergeSort<T>.InternalSort(List: TList<T>; var Work: array of T;
                                           Left: Integer; Right: Integer;
                                           const AComparer: IComparer<T>);
var
  Index1: Integer;
  Index2: Integer;
  Index3: Integer;
  Mid: Integer;
begin

  if Left >= Right then
  begin
    Exit;
  end;

  Mid := (Left + Right) div 2;
  InternalSort(List,Work,Left,   Mid,  AComparer);
  InternalSort(List,Work,Mid + 1,Right,AComparer);

  for Index1 := Left to Mid do
  begin
    Work[Index1] := List.Items[Index1];
  end;

  Index2 := Right;
  for Index1 := Mid + 1 to Right do
  begin
    Work[Index1] := List.Items[Index2];
    Index2 := Index2 - 1;
  end;

  Index1 := Left;
  Index2 := Right;
  for Index3 := Left to Right do
  begin
    if AComparer.Compare(Work[Index1],Work[Index2]) > 0 then
    begin
      List.Items[Index3] := Work[Index2];
      Index2 := Index2 - 1;
    end
    else
    begin
      List.Items[Index3] := Work[Index1];
      Index1 := Index1 + 1;
    end;
  end;

end;
シェルソートです。
type
  TShellSort<T> = class(TSortAlgorithm<T>)
  protected
    class var
      FInstance: TSortAlgorithm<T>;
    class procedure  InternalSort(List: TList<T>; Gap: Integer;
                                  const AComparer: IComparer<T>);
  public
    class destructor Destroy;
    class function   Instance: TSortAlgorithm<T>; override;
    class procedure  Sort(List: TList<T>; const AComparer: IComparer<T>); override;
  end;

class destructor TShellSort<T>.Destroy;
begin

  FInstance.Free;

end;

class function TShellSort<T>.Instance: TSortAlgorithm<T>;
begin

  if FInstance = nil then
  begin
    FInstance := Self.Create;
  end;

  Result := FInstance;

end;

class procedure TShellSort<T>.Sort(List: TList<T>; const AComparer: IComparer<T>);
var
  Gap: Integer;
begin

  Gap := List.Count div 2;
  while Gap > 0 do
  begin
    InternalSort(List,Gap,AComparer);

    Gap := Gap div 2;
  end;

end;

class procedure TShellSort<T>.InternalSort(List: TList<T>; Gap: Integer;
                                           const AComparer: IComparer<T>);
var
  Index1: Integer;
  Index2: Integer;
begin

  for Index1 := Gap to List.Count - 1 do
  begin
    Index2 := Index1 - Gap;
    while Index2 >= 0 do
    begin
      if AComparer.Compare(List.Items[Index2 + Gap],List.Items[Index2]) > 0 then
      begin
        Break;
      end;

      List.Exchange(Index2,Index2 + Gap);
      Index2 := Index2 - Gap;
    end;
  end;

end;
Instanceメソッドとクラスデストラクタを毎回書かなければならないことを除けば、ソートのコードを1つ書くだけで値型に対するTList<T>(TList<String>を含む)、クラスに対するTObjectList<T>のどちらであってもソートを行うことができます。

→ジェネリックスのリストをアルゴリズムを指定してソートする(Gist)

2017年3月7日

Adobe Reader(X以降)で指定したファイルの指定したページを開く

以前Adobe Acrobat/Readerで指定したPDFファイルの指定したページを開く方法について書きましたが、コメントでおかぽんさんからAdobe Reader X以降ではこの方法が使えなくなっているとの指摘をいただきました。

...DDEを使った方法ですが、Acrobat X から、DDEのサービス名が変更されています。...
調べてみると、Actobat/ReaderのVersion 10(X)以降で、DDEのサービス名が Acroview + [A|R] + <MajorVersion> に変更されたことが原因とのことです。というわけでこれに対応してみました。
uses
{$IF RTLVersion >= 23.00}
  Winapi.Windows, System.SysUtils, System.Win.Registry, System.AnsiStrings,
  Vcl.DdeMan;
{$ELSE}
  Windows, SysUtils, Registry, {$IFDEF UNICODE}AnsiStrings, {$ENDIF}DdeMan;
{$IFEND}

function GetAcrobatPathname: String;
begin

  with TRegistry.Create do
  begin
    try
      RootKey := HKEY_CLASSES_ROOT;
      OpenKeyReadOnly('Software\Adobe\Acrobat\Exe');
      try
        Result := AnsiDequotedStr(ReadString(''),'"');

      finally
        CloseKey;
      end;

    finally
      Free;
    end;
  end;

end;

procedure OpenPDF(const Filename: String; Page: Integer);
const
  CDdeCommand: AnsiString = '[DocOpen("%s")][DocGoTo(NULL,%d)]';
var
  Macro: AnsiString;
  Pathname: String;
  ServiceName: String;
  MajorVersion: Integer;
  AcrobatType: String;
begin

  Macro := {$IFDEF UNICODE}{$IF RTLVersion >= 23.00}System.{$IFEND}AnsiStrings.{$ENDIF}
           Format(CDdeCommand,[Filename,Page - 1]);

  Pathname := GetAcrobatPathname;

  ServiceName := 'Acroview';
  MajorVersion := GetFileVersion(Pathname) shr 16;
  if MajorVersion >= 10 then
  begin
    if CompareText(ExtractFileName(Pathname),'AcroRd32.exe') = 0 then
    begin
      AcrobatType := 'R';
    end
    else
    begin
      AcrobatType := 'A';
    end;

    ServiceName := ServiceName + Format('%s%d',[AcrobatType,MajorVersion]);
  end;

  with TDdeClientConv.Create(nil) do
  begin
    try
      ConnectMode := ddeManual;
      ServiceApplication := ChangeFileExt(Pathname,'');
      SetLink(ServiceName,'Control');
      if (OpenLink or ((MajorVersion >= 15) and OpenLink)) = True then
      begin
        ExecuteMacro(PAnsiChar(Macro),False);
        CloseLink;
      end;

    finally
      Free;
    end;
  end;

end;
Acrobat/Readerの実行ファイルの場所をレジストリの"HKEY_CLASSES_ROOT\Software\Adobe\Acrobat\Exe"から取得し、SysUtils.GetFileVersionで問い合わせたバージョン情報の上位16ビット(メジャーバージョン)とファイル名からサービス名を組み立て、DDEをTDdeClientConv.OpenLinkで呼び出してTDdeClientConv.ExecuteMacroでマクロ実行することでファイルを開きページを移動する、という手順になります。またAcrobat/Reader DCの場合TDdeClientConv.OpenLinkの内部でWinExec(en)を使用して起動した直後にDdeConnect(en)を呼び出すと失敗するようなので、リトライするようにしています。

おかぽんさん、情報ありがとうございました。

→Adobe Reader(X以降)で指定したファイルの指定したページを開く(Gist)