merged trunk into lua branch

plugin loading is disabled atm because of a bug reading the files (lua may be the reason). Reading the files in usdx and passing the contents to lua may solve this git-svn-id: svn://svn.code.sf.net/p/ultrastardx/svn/branches/experimental@2019 b956fd51-792f-4845-bead-9b4dfca2ff2c
author: whiteshark0 <whiteshark0@b956fd51-792f-4845-bead-9b4dfca2ff2c> 2009-12-11 17:34:54 +0000
committer: whiteshark0 <whiteshark0@b956fd51-792f-4845-bead-9b4dfca2ff2c> 2009-12-11 17:34:54 +0000
commit: 1ab628e8ad6c85c8f1b562f10480253ee3e622b7 (patch)
tree: d21621f68850ecd7762137e1c4387fa15731a811 /Lua/src/lib
parent: 6ec275387c320d3d9a8f5b6fe185687643565b8c (diff)
download: usdx-1ab628e8ad6c85c8f1b562f10480253ee3e622b7.tar.gz
usdx-1ab628e8ad6c85c8f1b562f10480253ee3e622b7.tar.xz
usdx-1ab628e8ad6c85c8f1b562f10480253ee3e622b7.zip
57 files changed, 24296 insertions, 1754 deletions
diff --git a/Lua/src/lib/FreeImage/FreeBitmap.pas b/Lua/src/lib/FreeImage/FreeBitmap.pas
index 4e5f50a4..d32fb5cb 100644
--- a/Lua/src/lib/FreeImage/FreeBitmap.pas
+++ b/Lua/src/lib/FreeImage/FreeBitmap.pas
@@ -33,7 +33,7 @@ unit FreeBitmap;
 
 {$IFDEF FPC}
   {$MODE Delphi}
-  {$H+} // use AnsiString
+  {$H+} // use long strings
 {$ENDIF}
 
 interface
diff --git a/Lua/src/lib/JEDI-SDL/OpenGL/Pas/glext.pas b/Lua/src/lib/JEDI-SDL/OpenGL/Pas/glext.pas
index 1fc70f8a..871247a9 100644
--- a/Lua/src/lib/JEDI-SDL/OpenGL/Pas/glext.pas
+++ b/Lua/src/lib/JEDI-SDL/OpenGL/Pas/glext.pas
@@ -4282,32 +4282,33 @@ begin
 
   if (Pos(' ', extension) <> 0) or (extension = '') then
   begin
-    Result := FALSE;
+    Result := false;
     Exit;
   end;
 
   if searchIn = '' then
     extensions := glGetString(GL_EXTENSIONS)
   else
-    //StrLCopy( extensions, searchIn, StrLen(searchIn)+1 );
+    //StrLCopy(extensions, searchIn, StrLen(searchIn) + 1);
     extensions := searchIn;
   start := extensions;
-  while TRUE do
+  while true do
   begin
-    where := StrPos(start, extension );
-    if where = nil then Break;
-    terminator := Pointer(Integer(where) + Integer( strlen( extension ) ) );
-    if (where = start) or (PChar(Integer(where) - 1)^ = ' ') then
+    where := StrPos(start, extension);
+    if where = nil then
+      Break;
+    terminator := where + Length(extension);
+    if (where = start) or ((where - 1)^ = ' ') then
     begin
       if (terminator^ = ' ') or (terminator^ = #0) then
       begin
-	Result := TRUE;
+	Result := true;
 	Exit;
       end;
     end;
     start := terminator;
   end;
-  Result := FALSE;
+  Result := false;
 
 end;
 
diff --git a/Lua/src/lib/SQLite/SQLite3.pas b/Lua/src/lib/SQLite/SQLite3.pas
index 9537606c..7b7207c4 100644
--- a/Lua/src/lib/SQLite/SQLite3.pas
+++ b/Lua/src/lib/SQLite/SQLite3.pas
@@ -10,7 +10,7 @@ unit SQLite3;
 
 {$IFDEF FPC}
   {$MODE DELPHI}
-  {$H+}            (* use AnsiString *)
+  {$H+}            (* use long strings *)
   {$PACKENUM 4}    (* use 4-byte enums *)
   {$PACKRECORDS C} (* C/C++-compatible record packing *)
 {$ELSE}
diff --git a/Lua/src/lib/SQLite/SQLiteTable3.pas b/Lua/src/lib/SQLite/SQLiteTable3.pas
index 7df76363..3aed54a4 100644
--- a/Lua/src/lib/SQLite/SQLiteTable3.pas
+++ b/Lua/src/lib/SQLite/SQLiteTable3.pas
@@ -139,6 +139,7 @@ type
     procedure Commit;
     procedure Rollback;
     function TableExists(TableName: string): boolean;
+    function ContainsColumn(Table: String; Column: String) : boolean;
     function GetLastInsertRowID: int64;
     function GetLastChangedRows: int64;
     procedure SetTimeout(Value: integer);
@@ -759,6 +760,26 @@ begin
   end;
 end;
 
+function TSQLiteDatabase.ContainsColumn(Table: String; Column: String) : boolean;
+var
+  sql: string;
+  ds: TSqliteTable;
+  i : integer;
+begin
+  sql := 'PRAGMA TABLE_INFO('+Table+');';
+  ds := self.GetTable(sql);
+  try
+    Result := false;
+    while (ds.Next() and not Result and not ds.EOF)  do
+    begin
+      if ds.FieldAsString(1) = Column then
+        Result := true;
+    end;
+  finally
+    ds.Free;
+  end;
+end;
+
 procedure TSQLiteDatabase.SetTimeout(Value: integer);
 begin
   SQLite3_BusyTimeout(self.fDB, Value);
diff --git a/Lua/src/lib/TntUnicodeControls/License.txt b/Lua/src/lib/TntUnicodeControls/License.txt
new file mode 100644
index 00000000..8ac7f75b
--- /dev/null
+++ b/Lua/src/lib/TntUnicodeControls/License.txt
@@ -0,0 +1,11 @@
+TntWare Delphi Unicode Controls
+      http://www.tntware.com/delphicontrols/unicode/
+
+Copyright (c) 2002-2007, Troy Wolbrink (www.tntware.com) 
+
+License
+Redistribution and use in binary forms, with or without modification, are permitted.  Redistribution and use in source forms, with or without modification, are permitted provided that the redistributions of source code retain the above copyright.
+
+Disclaimer
+This software is provided by the author "as is" and any express or implied warranties, including, but not limited to, the implied warranties of merchantability and fitness for a particular purpose are disclaimed. In no event shall the author be liable for any direct, indirect, incidental, special, exemplary, or consequential damages (including, but not limited to, procurement of substitute goods or services; loss of use, data, or profits; or business interruption) however caused and on any theory of liability, whether in contract, strict liability, or tort (including negligence or otherwise) arising in any way out of the use of this software, even if advised of the possibility of such damage.
+
diff --git a/Lua/src/lib/TntUnicodeControls/Readme.txt b/Lua/src/lib/TntUnicodeControls/Readme.txt
new file mode 100644
index 00000000..a2d8f799
--- /dev/null
+++ b/Lua/src/lib/TntUnicodeControls/Readme.txt
@@ -0,0 +1,53 @@
+  ** Tnt Delphi UNICODE Controls Project **
+
+Website: http://tnt.ccci.org/delphi_unicode_controls/
+Email: troy.wolbrink@ccci.org
+
+These controls are provided as-is, with no implied warranty.  They are freely available for you to use in your own projects.  Please let me know if you have found them helpful.  Also, please let me know if you find any bugs or other areas of needed improvement.
+
+
+---Delphi Installation--------------------------
+
+The most simple way to install these components is by opening the appropriate design package in Delphi and clicking on the big "Install" button.  For instance, Delphi 5's design package is TntUnicodeVcl_D50.dpk.
+
+For BCB 2006 and newer, open the appropriate design package in the packages\bcbx\ folder using the Delphi personality.  After compiling and installing, you should be able to use the components in both the Delphi and BCB personality.  Remember to set the library path in menu "Tools->Options" for both the C++ Builder and the Delphi.
+
+
+---A note on fonts----------------------
+
+The default TFont uses "MS Sans Serif" which doesn't work well with most non-ANSI characters.  I'd recommend using a TrueType font such as "Tahoma" if it is installed on the machine.  To make TFont use a different font like "Tahoma" add this to the first line in the project:
+
+  Graphics.DefFontData.Name := 'Tahoma';
+
+You might have to include "Graphics" in the file's uses clauses.  Furthermore, adding this line of code to the project will cause the changed setting to only be applied at runtime, not at design time.  To make a designtime change, you'd have to add this line to the initialization section of a unit in a design package.
+
+Regarding the IDE, I use GExperts to change the font of the Object Inspector.  The Wide String List editor uses the font used by the object inspector.
+
+Also keep in mind that the font used by certain message boxes come from that set by Windows' Display properties.
+
+
+---Background----------------------------
+
+Designing software for an international audience, I've always wanted to write a full UNICODE application.  My approach so far, has been to write Unicode on the inside, and MBCS on the outside.  This has always been frustrating, because (even on Windows NT/2000/XP which provide native Unicode window controls) the WideStrings inside my application and databases were always confined to an ANSI VCL.  And, since the VCL was designed to wrap the low-level Windows details, why shouldn't the VCL hide the fact that sometimes native Unicode controls are not possible on the given version of Windows.  I believe the VCL should be written with a Unicode interface, even if it must (at times) deal with an ANSI operating system.  For example, TEdit should expose Text as a WideString, even if it has to convert the WideString to an AnsiString on the Windows 9X platform.
+
+In the past, the ANSI VCL may have made a little sense, considering that there were many more users of Windows 9X, than Windows NT.  There would have been some performance penalty to use WideStrings on the Windows 9X platform.  But with the faster computers of today, and with more people using platforms such as Windows 2000 and Windows XP, the ANSI VCL just doesn't make sense anymore.  In fact, having to use the the ANSI VCL on Windows NT/2000/XP is slower because of the constant conversion to and from UNICODE inside Windows.
+
+My coding signature is Tnt.  I will use this to denote my classes from others.
+
+For more information about me: <http://home.ccci.org/wolbrink/>
+Some of my software projects (all written in Delphi).
+    TntMPD (contact manager for missionaries)
+      <http://www.tntmpd.com/>
+    Jesus Film Screen Saver
+      <http://home.ccci.org/wolbrink/screensaver.htm>
+    ActiveX SCR control
+      <http://tnt.ccci.org/download/activex_scr/ActiveXSCR.exe>
+
+---Design Goals----------------------------
+
+I want the controls to work on Windows 95, 98, ME, NT, 2000, XP, etc.  I want a single EXE for all platforms.  Of course, full UNICODE support is only truly available on NT/2000/XP.  In other words, the controls should automatically scale to take advantage of native Unicode support when possible.
+
+I want the controls to inherit from the Delphi VCL.  I want to reuse as much code as possible.  For the most part this makes sense.  The only sticky part is where text messages get passed around.  But I believe I've gotten past this through strategic subclassing at various points in the message flow chain.  To give a rough comparison of why this is so important, check out the following chart which compares the lines of code in the VCL for a given control (4,397 in all), and the lines of code required in my descendent controls (655 in all).  Besides saving lines of code, I get the advantage of automatically inheriting new features as new versions of Delphi come out.  One such example is the AlphaBlending feature in the Delphi 6 TForm.  Even though I use Delphi 5 now, I won't have to add any code to get this new feature.
+
+---More Interesting Information----------------------------
+Case Study: Porting an MFC Application to Unicode:  It looks like the FrontPage 2002 team did the roughly the same thing to MFC as what I'm doing to the VCL.  They did this with the same goal in mind: to support Unicode as much as possible depending on the support offered by Windows.  Another goal was "Don�t abandon MFC; don�t rewrite app".  Because they still want to support Windows 9X using the same worldwide EXE used everywhere.  They couldn't just compile with the _UNICODE directive.  They had to start with the ANSI MFC, strategically subclassing window procedures at just the right places.  Hmmm... sounds familiar.
+\ No newline at end of file
diff --git a/Lua/src/lib/TntUnicodeControls/TntClasses.pas b/Lua/src/lib/TntUnicodeControls/TntClasses.pas
new file mode 100644
index 00000000..be043421
--- /dev/null
+++ b/Lua/src/lib/TntUnicodeControls/TntClasses.pas
@@ -0,0 +1,1799 @@
+
+{*****************************************************************************}
+{                                                                             }
+{    Tnt Delphi Unicode Controls                                              }
+{      http://www.tntware.com/delphicontrols/unicode/                         }
+{        Version: 2.3.0                                                       }
+{                                                                             }
+{    Copyright (c) 2002-2007, Troy Wolbrink (troy.wolbrink@tntware.com)       }
+{                                                                             }
+{*****************************************************************************}
+
+unit TntClasses;
+
+{$IFDEF FPC}
+  {$MODE Delphi}
+{$ENDIF}
+
+{$INCLUDE TntCompilers.inc}
+
+interface
+
+{ TODO: Consider: TTntRegIniFile, TTntMemIniFile (consider if UTF8 fits into this solution). }
+
+{***********************************************}
+{  WideChar-streaming implemented by Ma�l H�rz  }
+{***********************************************}
+
+uses
+  Classes, SysUtils, Windows,
+  {$IFNDEF COMPILER_10_UP}
+  TntWideStrings,
+  {$ELSE}
+  WideStrings,
+  {$ENDIF}
+  ActiveX, Contnrs;
+
+// ......... introduced .........
+type
+  TTntStreamCharSet = (csAnsi, csUnicode, csUnicodeSwapped, csUtf8);
+
+function AutoDetectCharacterSet(Stream: TStream): TTntStreamCharSet;
+
+//---------------------------------------------------------------------------------------------
+//                                 Tnt - Classes
+//---------------------------------------------------------------------------------------------
+
+{TNT-WARN ExtractStrings}
+{TNT-WARN LineStart}
+{TNT-WARN TStringStream}   // TODO: Implement a TWideStringStream
+
+// A potential implementation of TWideStringStream can be found at:
+//   http://kdsxml.cvs.sourceforge.net/kdsxml/Global/KDSClasses.pas?revision=1.10&view=markup
+
+procedure TntPersistent_AfterInherited_DefineProperties(Filer: TFiler; Instance: TPersistent);
+
+type
+{TNT-WARN TFileStream}
+  TTntFileStream = class(THandleStream)
+  public
+    constructor Create(const FileName: WideString; Mode: Word);
+    destructor Destroy; override;
+  end;
+
+{TNT-WARN TMemoryStream}
+  TTntMemoryStream = class(TMemoryStream{TNT-ALLOW TMemoryStream})
+  public
+    procedure LoadFromFile(const FileName: WideString);
+    procedure SaveToFile(const FileName: WideString);
+  end;
+
+{TNT-WARN TResourceStream}
+  TTntResourceStream = class(TCustomMemoryStream)
+  private
+    HResInfo: HRSRC;
+    HGlobal: THandle;
+    procedure Initialize(Instance: THandle; Name, ResType: PWideChar);
+  public
+    constructor Create(Instance: THandle; const ResName: WideString; ResType: PWideChar);
+    constructor CreateFromID(Instance: THandle; ResID: Word; ResType: PWideChar);
+    destructor Destroy; override;
+    function Write(const Buffer; Count: Longint): Longint; override;
+    procedure SaveToFile(const FileName: WideString);
+  end;
+
+  TTntStrings = class;
+
+{TNT-WARN TAnsiStrings}
+  TAnsiStrings{TNT-ALLOW TAnsiStrings} = class(TStrings{TNT-ALLOW TStrings})
+  public
+    procedure LoadFromFile(const FileName: WideString); reintroduce;
+    procedure SaveToFile(const FileName: WideString); reintroduce;
+    procedure LoadFromFileEx(const FileName: WideString; CodePage: Cardinal);
+    procedure SaveToFileEx(const FileName: WideString; CodePage: Cardinal);
+    procedure LoadFromStreamEx(Stream: TStream; CodePage: Cardinal); virtual; abstract;
+    procedure SaveToStreamEx(Stream: TStream; CodePage: Cardinal); virtual; abstract;
+  end;
+
+  TAnsiStringsForWideStringsAdapter = class(TAnsiStrings{TNT-ALLOW TAnsiStrings})
+  private
+    FWideStrings: TTntStrings;
+    FAdapterCodePage: Cardinal;
+  protected
+    function Get(Index: Integer): AnsiString; override;
+    procedure Put(Index: Integer; const S: AnsiString); override;
+    function GetCount: Integer; override;
+    function GetObject(Index: Integer): TObject; override;
+    procedure PutObject(Index: Integer; AObject: TObject); override;
+    procedure SetUpdateState(Updating: Boolean); override;
+    function AdapterCodePage: Cardinal; dynamic;
+  public
+    constructor Create(AWideStrings: TTntStrings; _AdapterCodePage: Cardinal = 0);
+    procedure Clear; override;
+    procedure Delete(Index: Integer); override;
+    procedure Insert(Index: Integer; const S: AnsiString); override;
+    procedure LoadFromStreamEx(Stream: TStream; CodePage: Cardinal); override;
+    procedure SaveToStreamEx(Stream: TStream; CodePage: Cardinal); override;
+  end;
+
+{TNT-WARN TStrings}
+  TTntStrings = class(TWideStrings)
+  private
+    FLastFileCharSet: TTntStreamCharSet;
+    FAnsiStrings: TAnsiStrings{TNT-ALLOW TAnsiStrings};
+    procedure SetAnsiStrings(const Value: TAnsiStrings{TNT-ALLOW TAnsiStrings});
+    procedure ReadData(Reader: TReader);
+    procedure ReadDataUTF7(Reader: TReader);
+    procedure ReadDataUTF8(Reader: TReader);
+    procedure WriteDataUTF7(Writer: TWriter);
+  protected
+    procedure DefineProperties(Filer: TFiler); override;
+  public
+    constructor Create;
+    destructor Destroy; override;
+
+    procedure LoadFromFile(const FileName: WideString); override;
+    procedure LoadFromStream(Stream: TStream); override;
+    procedure LoadFromStream_BOM(Stream: TStream; WithBOM: Boolean); virtual;
+
+    procedure SaveToFile(const FileName: WideString); override;
+    procedure SaveToStream(Stream: TStream); override;
+    procedure SaveToStream_BOM(Stream: TStream; WithBOM: Boolean); virtual;
+
+    property LastFileCharSet: TTntStreamCharSet read FLastFileCharSet;
+  published
+    property AnsiStrings: TAnsiStrings{TNT-ALLOW TAnsiStrings} read FAnsiStrings write SetAnsiStrings stored False;
+  end;
+
+{ TTntStringList class }
+
+  TTntStringList = class;
+  TWideStringListSortCompare = function(List: TTntStringList; Index1, Index2: Integer): Integer;
+
+{TNT-WARN TStringList}
+  TTntStringList = class(TTntStrings)
+  private
+    FUpdating: Boolean;
+    FList: PWideStringItemList;
+    FCount: Integer;
+    FCapacity: Integer;
+    FSorted: Boolean;
+    FDuplicates: TDuplicates;
+    FCaseSensitive: Boolean;
+    FOnChange: TNotifyEvent;
+    FOnChanging: TNotifyEvent;
+    procedure ExchangeItems(Index1, Index2: Integer);
+    procedure Grow;
+    procedure QuickSort(L, R: Integer; SCompare: TWideStringListSortCompare);
+    procedure SetSorted(Value: Boolean);
+    procedure SetCaseSensitive(const Value: Boolean);
+  protected
+    procedure Changed; virtual;
+    procedure Changing; virtual;
+    function Get(Index: Integer): WideString; override;
+    function GetCapacity: Integer; override;
+    function GetCount: Integer; override;
+    function GetObject(Index: Integer): TObject; override;
+    procedure Put(Index: Integer; const S: WideString); override;
+    procedure PutObject(Index: Integer; AObject: TObject); override;
+    procedure SetCapacity(NewCapacity: Integer); override;
+    procedure SetUpdateState(Updating: Boolean); override;
+    function CompareStrings(const S1, S2: WideString): Integer; override;
+    procedure InsertItem(Index: Integer; const S: WideString; AObject: TObject); virtual;
+  public
+    destructor Destroy; override;
+    function Add(const S: WideString): Integer; override;
+    function AddObject(const S: WideString; AObject: TObject): Integer; override;
+    procedure Clear; override;
+    procedure Delete(Index: Integer); override;
+    procedure Exchange(Index1, Index2: Integer); override;
+    function Find(const S: WideString; var Index: Integer): Boolean; virtual;
+    function IndexOf(const S: WideString): Integer; override;
+    function IndexOfName(const Name: WideString): Integer; override;
+    procedure Insert(Index: Integer; const S: WideString); override;
+    procedure InsertObject(Index: Integer; const S: WideString;
+      AObject: TObject); override;
+    procedure Sort; virtual;
+    procedure CustomSort(Compare: TWideStringListSortCompare); virtual;
+    property Duplicates: TDuplicates read FDuplicates write FDuplicates;
+    property Sorted: Boolean read FSorted write SetSorted;
+    property CaseSensitive: Boolean read FCaseSensitive write SetCaseSensitive;
+    property OnChange: TNotifyEvent read FOnChange write FOnChange;
+    property OnChanging: TNotifyEvent read FOnChanging write FOnChanging;
+  end;
+
+// ......... introduced .........
+type
+  TListTargetCompare = function (Item, Target: Pointer): Integer;
+
+function FindSortedListByTarget(List: TList; TargetCompare: TListTargetCompare;
+  Target: Pointer; var Index: Integer): Boolean;
+
+function ClassIsRegistered(const clsid: TCLSID): Boolean;
+
+var
+  RuntimeUTFStreaming: Boolean;
+
+type
+  TBufferedAnsiString = class(TObject)
+  private
+    FStringBuffer: AnsiString;
+    LastWriteIndex: Integer;
+  public
+    procedure Clear;
+    procedure AddChar(const wc: AnsiChar);
+    procedure AddString(const s: AnsiString);
+    procedure AddBuffer(Buff: PAnsiChar; Chars: Integer);
+    function Value: AnsiString;
+    function BuffPtr: PAnsiChar;
+  end;
+
+  TBufferedWideString = class(TObject)
+  private
+    FStringBuffer: WideString;
+    LastWriteIndex: Integer;
+  public
+    procedure Clear;
+    procedure AddChar(const wc: WideChar);
+    procedure AddString(const s: WideString);
+    procedure AddBuffer(Buff: PWideChar; Chars: Integer);
+    function Value: WideString;
+    function BuffPtr: PWideChar;
+  end;
+
+  TBufferedStreamReader = class(TStream)
+  private
+    FStream: TStream;
+    FStreamSize: Integer;
+    FBuffer: array of Byte;
+    FBufferSize: Integer;
+    FBufferStartPosition: Integer;
+    FVirtualPosition: Integer;
+    procedure UpdateBufferFromPosition(StartPos: Integer);
+  public
+    constructor Create(Stream: TStream; BufferSize: Integer = 1024);
+    function Read(var Buffer; Count: Longint): Longint; override;
+    function Write(const Buffer; Count: Longint): Longint; override;
+    function Seek(Offset: Longint; Origin: Word): Longint; override;
+  end;
+
+// "synced" wide string
+type TSetAnsiStrEvent = procedure(const Value: AnsiString) of object;
+function GetSyncedWideString(var WideStr: WideString; const AnsiStr: AnsiString): WideString;
+procedure SetSyncedWideString(const Value: WideString; var WideStr: WideString;
+  const AnsiStr: AnsiString; SetAnsiStr: TSetAnsiStrEvent);
+
+type
+  TWideComponentHelper = class(TComponent)
+  private
+    FComponent: TComponent;
+  protected
+    procedure Notification(AComponent: TComponent; Operation: TOperation); override;
+  public
+    constructor Create(AOwner: TComponent); override;
+    constructor CreateHelper(AOwner: TComponent; ComponentHelperList: TComponentList);
+  end;
+
+function FindWideComponentHelper(ComponentHelperList: TComponentList; Component: TComponent): TWideComponentHelper;
+
+implementation
+
+uses
+  RTLConsts, ComObj, Math,
+  Registry, TypInfo, TntSystem, TntSysUtils;
+
+{ TntPersistent }
+
+//===========================================================================
+//   The Delphi 5 Classes.pas never supported the streaming of WideStrings.
+//   The Delphi 6 Classes.pas supports WideString streaming.  But it's too bad that
+//     the Delphi 6 IDE doesn't use the updated Classes.pas.  Switching between Form/Text
+//       mode corrupts extended characters in WideStrings even under Delphi 6.
+//   Delphi 7 seems to finally get right.  But let's keep the UTF7 support at design time
+//     to enable sharing source code with previous versions of Delphi.
+//
+//   The purpose of this solution is to store WideString properties which contain
+//     non-ASCII chars in the form of UTF7 under the old property name + '_UTF7'.
+//
+//   Special thanks go to Francisco Leong for helping to develop this solution.
+//
+
+{ TTntWideStringPropertyFiler }
+type
+  TTntWideStringPropertyFiler = class
+  private
+    FInstance: TPersistent;
+    FPropInfo: PPropInfo;
+    procedure ReadDataUTF8(Reader: TReader);
+    procedure ReadDataUTF7(Reader: TReader);
+    procedure WriteDataUTF7(Writer: TWriter);
+  public
+    procedure DefineProperties(Filer: TFiler; Instance: TPersistent; PropName: AnsiString);
+  end;
+
+function ReaderNeedsUtfHelp(Reader: TReader): Boolean;
+begin
+  if Reader.Owner = nil then
+    Result := False { designtime - visual form inheritance ancestor }
+  else if csDesigning in Reader.Owner.ComponentState then
+    {$IFDEF COMPILER_7_UP}
+    Result := False { Delphi 7+: designtime - doesn't need UTF help. }
+    {$ELSE}
+    Result := True { Delphi 6: designtime - always needs UTF help. }
+    {$ENDIF}
+  else
+    Result := RuntimeUTFStreaming; { runtime }
+end;
+
+procedure TTntWideStringPropertyFiler.ReadDataUTF8(Reader: TReader);
+begin
+  if ReaderNeedsUtfHelp(Reader) then
+    SetWideStrProp(FInstance, FPropInfo, UTF8ToWideString(Reader.ReadString))
+  else
+    Reader.ReadString; { do nothing with Result }
+end;
+
+procedure TTntWideStringPropertyFiler.ReadDataUTF7(Reader: TReader);
+begin
+  if ReaderNeedsUtfHelp(Reader) then
+    SetWideStrProp(FInstance, FPropInfo, UTF7ToWideString(Reader.ReadString))
+  else
+    Reader.ReadString; { do nothing with Result }
+end;
+
+procedure TTntWideStringPropertyFiler.WriteDataUTF7(Writer: TWriter);
+begin
+  Writer.WriteString(WideStringToUTF7(GetWideStrProp(FInstance, FPropInfo)));
+end;
+
+procedure TTntWideStringPropertyFiler.DefineProperties(Filer: TFiler; Instance: TPersistent;
+  PropName: AnsiString);
+
+  {$IFNDEF COMPILER_7_UP}
+  function HasData: Boolean;
+  var
+    CurrPropValue: WideString;
+  begin
+    // must be stored
+    Result := IsStoredProp(Instance, FPropInfo);
+    if Result
+    and (Filer.Ancestor <> nil)
+    and (GetPropInfo(Filer.Ancestor, PropName, [tkWString]) <> nil) then
+    begin
+      // must be different than ancestor
+      CurrPropValue := GetWideStrProp(Instance, FPropInfo);
+      Result := CurrPropValue <> GetWideStrProp(Filer.Ancestor, GetPropInfo(Filer.Ancestor, PropName));
+    end;
+    if Result then begin
+      // must be non-blank and different than UTF8 (implies all ASCII <= 127)
+      CurrPropValue := GetWideStrProp(Instance, FPropInfo);
+      Result := (CurrPropValue <> '') and (WideStringToUTF8(CurrPropValue) <> CurrPropValue);
+    end;
+  end;
+  {$ENDIF}
+
+begin
+  FInstance := Instance;
+  FPropInfo := GetPropInfo(Instance, PropName, [tkWString]);
+  if FPropInfo <> nil then begin
+    // must be published (and of type WideString)
+    Filer.DefineProperty(PropName + 'W', ReadDataUTF8, nil, False);
+    {$IFDEF COMPILER_7_UP}
+    Filer.DefineProperty(PropName + '_UTF7', ReadDataUTF7, WriteDataUTF7, False);
+    {$ELSE}
+    Filer.DefineProperty(PropName + '_UTF7', ReadDataUTF7, WriteDataUTF7, HasData);
+    {$ENDIF}
+  end;
+  FInstance := nil;
+  FPropInfo := nil;
+end;
+
+{ TTntWideCharPropertyFiler }
+type
+  TTntWideCharPropertyFiler = class
+  private
+    FInstance: TPersistent;
+    FPropInfo: PPropInfo;
+    {$IFNDEF COMPILER_9_UP}
+    FWriter: TWriter;
+    procedure GetLookupInfo(var Ancestor: TPersistent;
+      var Root, LookupRoot, RootAncestor: TComponent);
+    {$ENDIF}
+    procedure ReadData_W(Reader: TReader);
+    procedure ReadDataUTF7(Reader: TReader);
+    procedure WriteData_W(Writer: TWriter);
+    function ReadChar(Reader: TReader): WideChar;
+  public
+    procedure DefineProperties(Filer: TFiler; Instance: TPersistent; PropName: AnsiString);
+  end;
+
+{$IFNDEF COMPILER_9_UP}
+type
+  TGetLookupInfoEvent = procedure(var Ancestor: TPersistent;
+    var Root, LookupRoot, RootAncestor: TComponent) of object;
+
+function AncestorIsValid(Ancestor: TPersistent; Root, RootAncestor: TComponent): Boolean;
+begin
+  Result := (Ancestor <> nil) and (RootAncestor <> nil) and
+            Root.InheritsFrom(RootAncestor.ClassType);
+end;
+
+function IsDefaultOrdPropertyValue(Instance: TObject; PropInfo: PPropInfo;
+  OnGetLookupInfo: TGetLookupInfoEvent): Boolean;
+var
+  Ancestor: TPersistent;
+  LookupRoot: TComponent;
+  RootAncestor: TComponent;
+  Root: TComponent;
+  AncestorValid: Boolean;
+  Value: Longint;
+  Default: LongInt;
+begin
+  Ancestor := nil;
+  Root := nil;
+  LookupRoot := nil;
+  RootAncestor := nil;
+
+  if Assigned(OnGetLookupInfo) then
+    OnGetLookupInfo(Ancestor, Root, LookupRoot, RootAncestor);
+
+  AncestorValid := AncestorIsValid(Ancestor, Root, RootAncestor);
+
+  Result := True;
+  if (PropInfo^.GetProc <> nil) and (PropInfo^.SetProc <> nil) then
+  begin
+    Value := GetOrdProp(Instance, PropInfo);
+    if AncestorValid then
+      Result := Value = GetOrdProp(Ancestor, PropInfo)
+    else
+    begin
+      Default := PPropInfo(PropInfo)^.Default;
+      Result :=  (Default <> LongInt($80000000)) and (Value = Default);
+    end;
+  end;
+end;
+
+procedure TTntWideCharPropertyFiler.GetLookupInfo(var Ancestor: TPersistent;
+  var Root, LookupRoot, RootAncestor: TComponent);
+begin
+  Ancestor := FWriter.Ancestor;
+  Root := FWriter.Root;
+  LookupRoot := FWriter.LookupRoot;
+  RootAncestor := FWriter.RootAncestor;
+end;
+{$ENDIF}
+
+function TTntWideCharPropertyFiler.ReadChar(Reader: TReader): WideChar;
+var
+  Temp: WideString;
+begin
+  case Reader.NextValue of
+    vaWString:
+      Temp := Reader.ReadWideString;
+    vaString:
+      Temp := Reader.ReadString;
+    else
+      raise EReadError.Create(SInvalidPropertyValue);
+  end;
+
+  if Length(Temp) > 1 then
+    raise EReadError.Create(SInvalidPropertyValue);
+  Result := Temp[1];
+end;
+
+procedure TTntWideCharPropertyFiler.ReadData_W(Reader: TReader);
+begin
+  SetOrdProp(FInstance, FPropInfo, Ord(ReadChar(Reader)));
+end;
+
+procedure TTntWideCharPropertyFiler.ReadDataUTF7(Reader: TReader);
+var
+  S: WideString;
+begin
+  S := UTF7ToWideString(Reader.ReadString);
+  if S = '' then
+    SetOrdProp(FInstance, FPropInfo, 0)
+  else
+    SetOrdProp(FInstance, FPropInfo, Ord(S[1]))
+end;
+
+type TAccessWriter = class(TWriter);
+
+procedure TTntWideCharPropertyFiler.WriteData_W(Writer: TWriter);
+var
+  L: Integer;
+  Temp: WideString;
+begin
+  Temp := WideChar(GetOrdProp(FInstance, FPropInfo));
+
+  {$IFNDEF FPC}
+  TAccessWriter(Writer).WriteValue(vaWString);
+  {$ELSE}
+  TAccessWriter(Writer).Write(vaWString, SizeOf(vaWString));
+  {$ENDIF}
+  L := Length(Temp);
+  Writer.Write(L, SizeOf(Integer));
+  Writer.Write(Pointer(@Temp[1])^, L * 2);
+end;
+
+procedure TTntWideCharPropertyFiler.DefineProperties(Filer: TFiler;
+  Instance: TPersistent; PropName: AnsiString);
+
+  {$IFNDEF COMPILER_9_UP}
+  function HasData: Boolean;
+  var
+    CurrPropValue: Integer;
+  begin
+    // must be stored
+    Result := IsStoredProp(Instance, FPropInfo);
+    if Result and (Filer.Ancestor <> nil) and
+      (GetPropInfo(Filer.Ancestor, PropName, [tkWChar]) <> nil) then
+    begin
+      // must be different than ancestor
+      CurrPropValue := GetOrdProp(Instance, FPropInfo);
+      Result := CurrPropValue <> GetOrdProp(Filer.Ancestor, GetPropInfo(Filer.Ancestor, PropName));
+    end;
+    if Result and (Filer is TWriter) then
+    begin
+      FWriter := TWriter(Filer);
+      Result := not IsDefaultOrdPropertyValue(Instance, FPropInfo, GetLookupInfo);
+    end;
+  end;
+  {$ENDIF}
+
+begin
+  FInstance := Instance;
+  FPropInfo := GetPropInfo(Instance, PropName, [tkWChar]);
+  if FPropInfo <> nil then
+  begin
+    // must be published (and of type WideChar)
+    {$IFDEF COMPILER_9_UP}
+    Filer.DefineProperty(PropName + 'W', ReadData_W, WriteData_W, False);
+    {$ELSE}
+    Filer.DefineProperty(PropName + 'W', ReadData_W, WriteData_W, HasData);
+    {$ENDIF}
+    Filer.DefineProperty(PropName + '_UTF7', ReadDataUTF7, nil, False);
+  end;
+  FInstance := nil;
+  FPropInfo := nil;
+end;
+
+procedure TntPersistent_AfterInherited_DefineProperties(Filer: TFiler; Instance: TPersistent);
+var
+  I, Count: Integer;
+  PropInfo: PPropInfo;
+  PropList: PPropList;
+  WideStringFiler: TTntWideStringPropertyFiler;
+  WideCharFiler: TTntWideCharPropertyFiler;
+begin
+  Count := GetTypeData(Instance.ClassInfo)^.PropCount;
+  if Count > 0 then
+  begin
+    WideStringFiler := TTntWideStringPropertyFiler.Create;
+    try
+      WideCharFiler := TTntWideCharPropertyFiler.Create;
+      try
+        GetMem(PropList, Count * SizeOf(Pointer));
+        try
+          GetPropInfos(Instance.ClassInfo, PropList);
+          for I := 0 to Count - 1 do
+          begin
+            PropInfo := PropList^[I];
+            if (PropInfo = nil) then
+              break;
+            if (PropInfo.PropType^.Kind = tkWString) then
+              WideStringFiler.DefineProperties(Filer, Instance, PropInfo.Name)
+            else if (PropInfo.PropType^.Kind = tkWChar) then
+              WideCharFiler.DefineProperties(Filer, Instance, PropInfo.Name)
+          end;
+        finally
+          FreeMem(PropList, Count * SizeOf(Pointer));
+        end;
+      finally
+        WideCharFiler.Free;
+      end;
+    finally
+      WideStringFiler.Free;
+    end;
+  end;
+end;
+
+{ TTntFileStream }
+
+{$IFDEF FPC}
+  {$DEFINE HAS_SFCREATEERROREX}
+{$ENDIF}
+{$IFDEF DELPHI_7_UP}
+  {$DEFINE HAS_SFCREATEERROREX}
+{$ENDIF}
+
+constructor TTntFileStream.Create(const FileName: WideString; Mode: Word);
+var
+  CreateHandle: Integer;
+  {$IFDEF HAS_SFCREATEERROREX}
+  ErrorMessage: WideString;
+  {$ENDIF}
+begin
+  if Mode = fmCreate then
+  begin
+    CreateHandle := WideFileCreate(FileName);
+    if CreateHandle < 0 then begin
+      {$IFDEF HAS_SFCREATEERROREX}
+      ErrorMessage := WideSysErrorMessage(GetLastError);
+      raise EFCreateError.CreateFmt(SFCreateErrorEx, [WideExpandFileName(FileName), ErrorMessage]);
+      {$ELSE}
+      raise EFCreateError.CreateFmt(SFCreateError, [WideExpandFileName(FileName)]);
+      {$ENDIF}
+    end;
+  end else
+  begin
+    CreateHandle := WideFileOpen(FileName, Mode);
+    if CreateHandle < 0 then begin
+      {$IFDEF HAS_SFCREATEERROREX}
+      ErrorMessage := WideSysErrorMessage(GetLastError);
+      raise EFOpenError.CreateFmt(SFOpenErrorEx, [WideExpandFileName(FileName), ErrorMessage]);
+      {$ELSE}
+      raise EFOpenError.CreateFmt(SFOpenError, [WideExpandFileName(FileName)]);
+      {$ENDIF}
+    end;
+  end;
+  inherited Create(CreateHandle);
+end;
+
+destructor TTntFileStream.Destroy;
+begin
+  if Handle >= 0 then FileClose(Handle);
+end;
+
+{ TTntMemoryStream }
+
+procedure TTntMemoryStream.LoadFromFile(const FileName: WideString);
+var
+  Stream: TStream;
+begin
+  Stream := TTntFileStream.Create(FileName, fmOpenRead or fmShareDenyWrite);
+  try
+    LoadFromStream(Stream);
+  finally
+    Stream.Free;
+  end;
+end;
+
+procedure TTntMemoryStream.SaveToFile(const FileName: WideString);
+var
+  Stream: TStream;
+begin
+  Stream := TTntFileStream.Create(FileName, fmCreate);
+  try
+    SaveToStream(Stream);
+  finally
+    Stream.Free;
+  end;
+end;
+
+{ TTntResourceStream }
+
+constructor TTntResourceStream.Create(Instance: THandle; const ResName: WideString;
+  ResType: PWideChar);
+begin
+  inherited Create;
+  Initialize(Instance, PWideChar(ResName), ResType);
+end;
+
+constructor TTntResourceStream.CreateFromID(Instance: THandle; ResID: Word;
+  ResType: PWideChar);
+begin
+  inherited Create;
+  Initialize(Instance, PWideChar(ResID), ResType);
+end;
+
+procedure TTntResourceStream.Initialize(Instance: THandle; Name, ResType: PWideChar);
+
+  procedure Error;
+  begin
+    raise EResNotFound.CreateFmt(SResNotFound, [Name]);
+  end;
+
+begin
+  HResInfo := FindResourceW(Instance, Name, ResType);
+  if HResInfo = 0 then Error;
+  HGlobal := LoadResource(Instance, HResInfo);
+  if HGlobal = 0 then Error;
+  SetPointer(LockResource(HGlobal), SizeOfResource(Instance, HResInfo));
+end;
+
+destructor TTntResourceStream.Destroy;
+begin
+  UnlockResource(HGlobal);
+  FreeResource(HGlobal); { Technically this is not necessary (MS KB #193678) }
+  inherited Destroy;
+end;
+
+function TTntResourceStream.Write(const Buffer; Count: Longint): Longint;
+begin
+  raise EStreamError.CreateRes(PResStringRec(@SCantWriteResourceStreamError));
+end;
+
+procedure TTntResourceStream.SaveToFile(const FileName: WideString);
+var
+  Stream: TStream;
+begin
+  Stream := TTntFileStream.Create(FileName, fmCreate);
+  try
+    SaveToStream(Stream);
+  finally
+    Stream.Free;
+  end;
+end;
+
+{ TAnsiStrings }
+
+procedure TAnsiStrings{TNT-ALLOW TAnsiStrings}.LoadFromFile(const FileName: WideString);
+var
+  Stream: TStream;
+begin
+  Stream := TTntFileStream.Create(FileName, fmOpenRead or fmShareDenyWrite);
+  try
+    LoadFromStream(Stream);
+  finally
+    Stream.Free;
+  end;
+end;
+
+procedure TAnsiStrings{TNT-ALLOW TAnsiStrings}.SaveToFile(const FileName: WideString);
+var
+  Stream: TStream;
+begin
+  Stream := TTntFileStream.Create(FileName, fmCreate);
+  try
+    SaveToStream(Stream);
+  finally
+    Stream.Free;
+  end;
+end;
+
+procedure TAnsiStrings{TNT-ALLOW TAnsiStrings}.LoadFromFileEx(const FileName: WideString; CodePage: Cardinal);
+var
+  Stream: TStream;
+begin
+  Stream := TTntFileStream.Create(FileName, fmOpenRead or fmShareDenyWrite);
+  try
+    LoadFromStreamEx(Stream, CodePage);
+  finally
+    Stream.Free;
+  end;
+end;
+
+procedure TAnsiStrings{TNT-ALLOW TAnsiStrings}.SaveToFileEx(const FileName: WideString; CodePage: Cardinal);
+var
+  Stream: TStream;
+  Utf8BomPtr: PAnsiChar;
+begin
+  Stream := TTntFileStream.Create(FileName, fmCreate);
+  try
+    if (CodePage = CP_UTF8) then
+    begin
+      Utf8BomPtr := PAnsiChar(UTF8_BOM);
+      Stream.WriteBuffer(Utf8BomPtr^, Length(UTF8_BOM));
+    end;
+    SaveToStreamEx(Stream, CodePage);
+  finally
+    Stream.Free;
+  end;
+end;
+
+{ TAnsiStringsForWideStringsAdapter }
+
+constructor TAnsiStringsForWideStringsAdapter.Create(AWideStrings: TTntStrings; _AdapterCodePage: Cardinal);
+begin
+  inherited Create;
+  FWideStrings := AWideStrings;
+  FAdapterCodePage := _AdapterCodePage;
+end;
+
+function TAnsiStringsForWideStringsAdapter.AdapterCodePage: Cardinal;
+begin
+  if FAdapterCodePage = 0 then
+    Result := TntSystem.DefaultSystemCodePage
+  else
+    Result := FAdapterCodePage;
+end;
+
+procedure TAnsiStringsForWideStringsAdapter.Clear;
+begin
+  FWideStrings.Clear;
+end;
+
+procedure TAnsiStringsForWideStringsAdapter.Delete(Index: Integer);
+begin
+  FWideStrings.Delete(Index);
+end;
+
+function TAnsiStringsForWideStringsAdapter.Get(Index: Integer): AnsiString;
+begin
+  Result := WideStringToStringEx(FWideStrings.Get(Index), AdapterCodePage);
+end;
+
+procedure TAnsiStringsForWideStringsAdapter.Put(Index: Integer; const S: AnsiString);
+begin
+  FWideStrings.Put(Index, StringToWideStringEx(S, AdapterCodePage));
+end;
+
+function TAnsiStringsForWideStringsAdapter.GetCount: Integer;
+begin
+  Result := FWideStrings.GetCount;
+end;
+
+procedure TAnsiStringsForWideStringsAdapter.Insert(Index: Integer; const S: AnsiString);
+begin
+  FWideStrings.Insert(Index, StringToWideStringEx(S, AdapterCodePage));
+end;
+
+function TAnsiStringsForWideStringsAdapter.GetObject(Index: Integer): TObject;
+begin
+  Result := FWideStrings.GetObject(Index);
+end;
+
+procedure TAnsiStringsForWideStringsAdapter.PutObject(Index: Integer; AObject: TObject);
+begin
+  FWideStrings.PutObject(Index, AObject);
+end;
+
+procedure TAnsiStringsForWideStringsAdapter.SetUpdateState(Updating: Boolean);
+begin
+  FWideStrings.SetUpdateState(Updating);
+end;
+
+procedure TAnsiStringsForWideStringsAdapter.LoadFromStreamEx(Stream: TStream; CodePage: Cardinal);
+var
+  Size: Integer;
+  S: AnsiString;
+begin
+  BeginUpdate;
+  try
+    Size := Stream.Size - Stream.Position;
+    SetString(S, nil, Size);
+    Stream.Read(Pointer(S)^, Size);
+    FWideStrings.SetTextStr(StringToWideStringEx(S, CodePage));
+  finally
+    EndUpdate;
+  end;
+end;
+
+procedure TAnsiStringsForWideStringsAdapter.SaveToStreamEx(Stream: TStream; CodePage: Cardinal);
+var
+  S: AnsiString;
+begin
+  S := WideStringToStringEx(FWideStrings.GetTextStr, CodePage);
+  Stream.WriteBuffer(Pointer(S)^, Length(S));
+end;
+
+{ TTntStrings }
+
+constructor TTntStrings.Create;
+begin
+  inherited;
+  FAnsiStrings := TAnsiStringsForWideStringsAdapter.Create(Self);
+  FLastFileCharSet := csUnicode;
+end;
+
+destructor TTntStrings.Destroy;
+begin
+  FreeAndNil(FAnsiStrings);
+  inherited;
+end;
+
+procedure TTntStrings.SetAnsiStrings(const Value: TAnsiStrings{TNT-ALLOW TAnsiStrings});
+begin
+  FAnsiStrings.Assign(Value);
+end;
+
+procedure TTntStrings.DefineProperties(Filer: TFiler);
+
+  {$IFNDEF COMPILER_7_UP}
+  function DoWrite: Boolean;
+  begin
+    if Filer.Ancestor <> nil then
+    begin
+      Result := True;
+      if Filer.Ancestor is TWideStrings then
+        Result := not Equals(TWideStrings(Filer.Ancestor))
+    end
+    else Result := Count > 0;
+  end;
+
+  function DoWriteAsUTF7: Boolean;
+  var
+    i: integer;
+  begin
+    Result := False;
+    for i := 0 to Count - 1 do begin
+      if (Strings[i] <> '') and (WideStringToUTF8(Strings[i]) <> Strings[i]) then begin
+        Result := True;
+        break; { found a string with non-ASCII chars (> 127) }
+      end;
+    end;
+  end;
+  {$ENDIF}
+
+begin
+  inherited DefineProperties(Filer); { Handles main 'Strings' property.' }
+  Filer.DefineProperty('WideStrings', ReadData, nil, False);
+  Filer.DefineProperty('WideStringsW', ReadDataUTF8, nil, False);
+  {$IFDEF COMPILER_7_UP}
+  Filer.DefineProperty('WideStrings_UTF7', ReadDataUTF7, WriteDataUTF7, False);
+  {$ELSE}
+  Filer.DefineProperty('WideStrings_UTF7', ReadDataUTF7, WriteDataUTF7, DoWrite and DoWriteAsUTF7);
+  {$ENDIF}
+end;
+
+procedure TTntStrings.LoadFromFile(const FileName: WideString);
+var
+  Stream: TStream;
+begin
+  Stream := TTntFileStream.Create(FileName, fmOpenRead or fmShareDenyWrite);
+  try
+    FLastFileCharSet := AutoDetectCharacterSet(Stream);
+    Stream.Position := 0;
+    LoadFromStream(Stream);
+  finally
+    Stream.Free;
+  end;
+end;
+
+procedure TTntStrings.LoadFromStream(Stream: TStream);
+begin
+  LoadFromStream_BOM(Stream, True);
+end;
+
+procedure TTntStrings.LoadFromStream_BOM(Stream: TStream; WithBOM: Boolean);
+var
+  DataLeft: Integer;
+  StreamCharSet: TTntStreamCharSet;
+  SW: WideString;
+  SA: AnsiString;
+begin
+  BeginUpdate;
+  try
+    if WithBOM then
+      StreamCharSet := AutoDetectCharacterSet(Stream)
+    else
+      StreamCharSet := csUnicode;
+    DataLeft := Stream.Size - Stream.Position;
+    if (StreamCharSet in [csUnicode, csUnicodeSwapped]) then
+    begin
+      // BOM indicates Unicode text stream
+      if DataLeft < SizeOf(WideChar) then
+        SW := ''
+      else begin
+        SetLength(SW, DataLeft div SizeOf(WideChar));
+        Stream.Read(PWideChar(SW)^, DataLeft);
+        if StreamCharSet = csUnicodeSwapped then
+          StrSwapByteOrder(PWideChar(SW));
+      end;
+      SetTextStr(SW);
+    end
+    else if StreamCharSet = csUtf8 then
+    begin
+      // BOM indicates UTF-8 text stream
+      SetLength(SA, DataLeft div SizeOf(AnsiChar));
+      Stream.Read(PAnsiChar(SA)^, DataLeft);
+      SetTextStr(UTF8ToWideString(SA));
+    end
+    else
+    begin
+      // without byte order mark it is assumed that we are loading ANSI text
+      SetLength(SA, DataLeft div SizeOf(AnsiChar));
+      Stream.Read(PAnsiChar(SA)^, DataLeft);
+      SetTextStr(SA);
+    end;
+  finally
+    EndUpdate;
+  end;
+end;
+
+procedure TTntStrings.ReadData(Reader: TReader);
+begin
+  if Reader.NextValue in [vaString, vaLString] then
+    SetTextStr(Reader.ReadString) {JCL compatiblity}
+  else if Reader.NextValue = vaWString then
+    SetTextStr(Reader.ReadWideString) {JCL compatiblity}
+  else begin
+    BeginUpdate;
+    try
+      Clear;
+      Reader.ReadListBegin;
+      while not Reader.EndOfList do
+        if Reader.NextValue in [vaString, vaLString] then
+          Add(Reader.ReadString) {TStrings compatiblity}
+        else
+          Add(Reader.ReadWideString);
+      Reader.ReadListEnd;
+    finally
+      EndUpdate;
+    end;
+  end;
+end;
+
+procedure TTntStrings.ReadDataUTF7(Reader: TReader);
+begin
+  Reader.ReadListBegin;
+  if ReaderNeedsUtfHelp(Reader) then
+  begin
+    BeginUpdate;
+    try
+      Clear;
+      while not Reader.EndOfList do
+        Add(UTF7ToWideString(Reader.ReadString))
+    finally
+      EndUpdate;
+    end;
+  end else begin
+    while not Reader.EndOfList do
+      Reader.ReadString; { do nothing with Result }
+  end;
+  Reader.ReadListEnd;
+end;
+
+procedure TTntStrings.ReadDataUTF8(Reader: TReader);
+begin
+  Reader.ReadListBegin;
+  if ReaderNeedsUtfHelp(Reader)
+  or (Count = 0){ Legacy support where 'WideStrings' was never written in lieu of WideStringsW }
+  then begin
+    BeginUpdate;
+    try
+      Clear;
+      while not Reader.EndOfList do
+        Add(UTF8ToWideString(Reader.ReadString))
+    finally
+      EndUpdate;
+    end;
+  end else begin
+    while not Reader.EndOfList do
+      Reader.ReadString; { do nothing with Result }
+  end;
+  Reader.ReadListEnd;
+end;
+
+procedure TTntStrings.SaveToFile(const FileName: WideString);
+var
+  Stream: TStream;
+begin
+  Stream := TTntFileStream.Create(FileName, fmCreate);
+  try
+    SaveToStream(Stream);
+  finally
+    Stream.Free;
+  end;
+end;
+
+procedure TTntStrings.SaveToStream(Stream: TStream);
+begin
+  SaveToStream_BOM(Stream, True);
+end;
+
+procedure TTntStrings.SaveToStream_BOM(Stream: TStream; WithBOM: Boolean);
+// Saves the currently loaded text into the given stream.
+// WithBOM determines whether to write a byte order mark or not.
+var
+  SW: WideString;
+  BOM: WideChar;
+begin
+  if WithBOM then begin
+    BOM := UNICODE_BOM;
+    Stream.WriteBuffer(BOM, SizeOf(WideChar));
+  end;
+  SW := GetTextStr;
+  Stream.WriteBuffer(PWideChar(SW)^, Length(SW) * SizeOf(WideChar));
+end;
+
+procedure TTntStrings.WriteDataUTF7(Writer: TWriter);
+var
+  I: Integer;
+begin
+  Writer.WriteListBegin;
+  for I := 0 to Count-1 do
+    Writer.WriteString(WideStringToUTF7(Get(I)));
+  Writer.WriteListEnd;
+end;
+
+{ TTntStringList }
+
+destructor TTntStringList.Destroy;
+begin
+  FOnChange := nil;
+  FOnChanging := nil;
+  inherited Destroy;
+  if FCount <> 0 then Finalize(FList^[0], FCount);
+  FCount := 0;
+  SetCapacity(0);
+end;
+
+function TTntStringList.Add(const S: WideString): Integer;
+begin
+  Result := AddObject(S, nil);
+end;
+
+function TTntStringList.AddObject(const S: WideString; AObject: TObject): Integer;
+begin
+  if not Sorted then
+    Result := FCount
+  else
+    if Find(S, Result) then
+      case Duplicates of
+        dupIgnore: Exit;
+        dupError: Error(PResStringRec(@SDuplicateString), 0);
+      end;
+  InsertItem(Result, S, AObject);
+end;
+
+procedure TTntStringList.Changed;
+begin
+  if (not FUpdating) and Assigned(FOnChange) then
+    FOnChange(Self);
+end;
+
+procedure TTntStringList.Changing;
+begin
+  if (not FUpdating) and Assigned(FOnChanging) then
+    FOnChanging(Self);
+end;
+
+procedure TTntStringList.Clear;
+begin
+  if FCount <> 0 then
+  begin
+    Changing;
+    Finalize(FList^[0], FCount);
+    FCount := 0;
+    SetCapacity(0);
+    Changed;
+  end;
+end;
+
+procedure TTntStringList.Delete(Index: Integer);
+begin
+  if (Index < 0) or (Index >= FCount) then Error(PResStringRec(@SListIndexError), Index);
+  Changing;
+  Finalize(FList^[Index]);
+  Dec(FCount);
+  if Index < FCount then
+    System.Move(FList^[Index + 1], FList^[Index],
+      (FCount - Index) * SizeOf(TWideStringItem));
+  Changed;
+end;
+
+procedure TTntStringList.Exchange(Index1, Index2: Integer);
+begin
+  if (Index1 < 0) or (Index1 >= FCount) then Error(PResStringRec(@SListIndexError), Index1);
+  if (Index2 < 0) or (Index2 >= FCount) then Error(PResStringRec(@SListIndexError), Index2);
+  Changing;
+  ExchangeItems(Index1, Index2);
+  Changed;
+end;
+
+procedure TTntStringList.ExchangeItems(Index1, Index2: Integer);
+var
+  Temp: Integer;
+  Item1, Item2: PWideStringItem;
+begin
+  Item1 := @FList^[Index1];
+  Item2 := @FList^[Index2];
+  Temp := Integer(Item1^.FString);
+  Integer(Item1^.FString) := Integer(Item2^.FString);
+  Integer(Item2^.FString) := Temp;
+  Temp := Integer(Item1^.FObject);
+  Integer(Item1^.FObject) := Integer(Item2^.FObject);
+  Integer(Item2^.FObject) := Temp;
+end;
+
+function TTntStringList.Find(const S: WideString; var Index: Integer): Boolean;
+var
+  L, H, I, C: Integer;
+begin
+  Result := False;
+  L := 0;
+  H := FCount - 1;
+  while L <= H do
+  begin
+    I := (L + H) shr 1;
+    C := CompareStrings(FList^[I].FString, S);
+    if C < 0 then L := I + 1 else
+    begin
+      H := I - 1;
+      if C = 0 then
+      begin
+        Result := True;
+        if Duplicates <> dupAccept then L := I;
+      end;
+    end;
+  end;
+  Index := L;
+end;
+
+function TTntStringList.Get(Index: Integer): WideString;
+begin
+  if (Index < 0) or (Index >= FCount) then Error(PResStringRec(@SListIndexError), Index);
+  Result := FList^[Index].FString;
+end;
+
+function TTntStringList.GetCapacity: Integer;
+begin
+  Result := FCapacity;
+end;
+
+function TTntStringList.GetCount: Integer;
+begin
+  Result := FCount;
+end;
+
+function TTntStringList.GetObject(Index: Integer): TObject;
+begin
+  if (Index < 0) or (Index >= FCount) then Error(PResStringRec(@SListIndexError), Index);
+  Result := FList^[Index].FObject;
+end;
+
+procedure TTntStringList.Grow;
+var
+  Delta: Integer;
+begin
+  if FCapacity > 64 then Delta := FCapacity div 4 else
+    if FCapacity > 8 then Delta := 16 else
+      Delta := 4;
+  SetCapacity(FCapacity + Delta);
+end;
+
+function TTntStringList.IndexOf(const S: WideString): Integer;
+begin
+  if not Sorted then Result := inherited IndexOf(S) else
+    if not Find(S, Result) then Result := -1;
+end;
+
+function TTntStringList.IndexOfName(const Name: WideString): Integer;
+var
+  NameKey: WideString;
+begin
+  if not Sorted then
+    Result := inherited IndexOfName(Name)
+  else begin
+    // use sort to find index more quickly
+    NameKey := Name + NameValueSeparator;
+    Find(NameKey, Result);
+    if (Result < 0) or (Result > Count - 1) then
+      Result := -1
+    else if CompareStrings(NameKey, Copy(Strings[Result], 1, Length(NameKey))) <> 0 then
+      Result := -1
+  end;
+end;
+
+procedure TTntStringList.Insert(Index: Integer; const S: WideString);
+begin
+  InsertObject(Index, S, nil);
+end;
+
+procedure TTntStringList.InsertObject(Index: Integer; const S: WideString;
+  AObject: TObject);
+begin
+  if Sorted then Error(PResStringRec(@SSortedListError), 0);
+  if (Index < 0) or (Index > FCount) then Error(PResStringRec(@SListIndexError), Index);
+  InsertItem(Index, S, AObject);
+end;
+
+procedure TTntStringList.InsertItem(Index: Integer; const S: WideString; AObject: TObject);
+begin
+  Changing;
+  if FCount = FCapacity then Grow;
+  if Index < FCount then
+    System.Move(FList^[Index], FList^[Index + 1],
+      (FCount - Index) * SizeOf(TWideStringItem));
+  with FList^[Index] do
+  begin
+    Pointer(FString) := nil;
+    FObject := AObject;
+    FString := S;
+  end;
+  Inc(FCount);
+  Changed;
+end;
+
+procedure TTntStringList.Put(Index: Integer; const S: WideString);
+begin
+  if Sorted then Error(PResStringRec(@SSortedListError), 0);
+  if (Index < 0) or (Index >= FCount) then Error(PResStringRec(@SListIndexError), Index);
+  Changing;
+  FList^[Index].FString := S;
+  Changed;
+end;
+
+procedure TTntStringList.PutObject(Index: Integer; AObject: TObject);
+begin
+  if (Index < 0) or (Index >= FCount) then Error(PResStringRec(@SListIndexError), Index);
+  Changing;
+  FList^[Index].FObject := AObject;
+  Changed;
+end;
+
+procedure TTntStringList.QuickSort(L, R: Integer; SCompare: TWideStringListSortCompare);
+var
+  I, J, P: Integer;
+begin
+  repeat
+    I := L;
+    J := R;
+    P := (L + R) shr 1;
+    repeat
+      while SCompare(Self, I, P) < 0 do Inc(I);
+      while SCompare(Self, J, P) > 0 do Dec(J);
+      if I <= J then
+      begin
+        ExchangeItems(I, J);
+        if P = I then
+          P := J
+        else if P = J then
+          P := I;
+        Inc(I);
+        Dec(J);
+      end;
+    until I > J;
+    if L < J then QuickSort(L, J, SCompare);
+    L := I;
+  until I >= R;
+end;
+
+procedure TTntStringList.SetCapacity(NewCapacity: Integer);
+begin
+  ReallocMem(FList, NewCapacity * SizeOf(TWideStringItem));
+  FCapacity := NewCapacity;
+end;
+
+procedure TTntStringList.SetSorted(Value: Boolean);
+begin
+  if FSorted <> Value then
+  begin
+    if Value then Sort;
+    FSorted := Value;
+  end;
+end;
+
+procedure TTntStringList.SetUpdateState(Updating: Boolean);
+begin
+  FUpdating := Updating;
+  if Updating then Changing else Changed;
+end;
+
+function WideStringListCompareStrings(List: TTntStringList; Index1, Index2: Integer): Integer;
+begin
+  Result := List.CompareStrings(List.FList^[Index1].FString,
+                                List.FList^[Index2].FString);
+end;
+
+procedure TTntStringList.Sort;
+begin
+  CustomSort(WideStringListCompareStrings);
+end;
+
+procedure TTntStringList.CustomSort(Compare: TWideStringListSortCompare);
+begin
+  if not Sorted and (FCount > 1) then
+  begin
+    Changing;
+    QuickSort(0, FCount - 1, Compare);
+    Changed;
+  end;
+end;
+
+function TTntStringList.CompareStrings(const S1, S2: WideString): Integer;
+begin
+  if CaseSensitive then
+    Result := WideCompareStr(S1, S2)
+  else
+    Result := WideCompareText(S1, S2);
+end;
+
+procedure TTntStringList.SetCaseSensitive(const Value: Boolean);
+begin
+  if Value <> FCaseSensitive then
+  begin
+    FCaseSensitive := Value;
+    if Sorted then Sort;
+  end;
+end;
+
+//------------------------- TntClasses introduced procs ----------------------------------
+
+function AutoDetectCharacterSet(Stream: TStream): TTntStreamCharSet;
+var
+  ByteOrderMark: WideChar;
+  BytesRead: Integer;
+  Utf8Test: array[0..2] of AnsiChar;
+begin
+  // Byte Order Mark
+  ByteOrderMark := #0;
+  if (Stream.Size - Stream.Position) >= SizeOf(ByteOrderMark) then begin
+    BytesRead := Stream.Read(ByteOrderMark, SizeOf(ByteOrderMark));
+    if (ByteOrderMark <> UNICODE_BOM) and (ByteOrderMark <> UNICODE_BOM_SWAPPED) then begin
+      ByteOrderMark := #0;
+      Stream.Seek(-BytesRead, soFromCurrent);
+      if (Stream.Size - Stream.Position) >= Length(Utf8Test) * SizeOf(AnsiChar) then begin
+        BytesRead := Stream.Read(Utf8Test[0], Length(Utf8Test) * SizeOf(AnsiChar));
+        if Utf8Test <> UTF8_BOM then
+          Stream.Seek(-BytesRead, soFromCurrent);
+      end;
+    end;
+  end;
+  // Test Byte Order Mark
+  if ByteOrderMark = UNICODE_BOM then
+    Result := csUnicode
+  else if ByteOrderMark = UNICODE_BOM_SWAPPED then
+    Result := csUnicodeSwapped
+  else if Utf8Test = UTF8_BOM then
+    Result := csUtf8
+  else
+    Result := csAnsi;
+end;
+
+function FindSortedListByTarget(List: TList; TargetCompare: TListTargetCompare;
+  Target: Pointer; var Index: Integer): Boolean;
+var
+  L, H, I, C: Integer;
+begin
+  Result := False;
+  L := 0;
+  H := List.Count - 1;
+  while L <= H do
+  begin
+    I := (L + H) shr 1;
+    C := TargetCompare(List[i], Target);
+    if C < 0 then L := I + 1 else
+    begin
+      H := I - 1;
+      if C = 0 then
+      begin
+        Result := True;
+        L := I;
+      end;
+    end;
+  end;
+  Index := L;
+end;
+
+function ClassIsRegistered(const clsid: TCLSID): Boolean;
+var
+  OleStr: POleStr;
+  Reg: TRegIniFile;
+  Key, Filename: WideString;
+begin
+  // First, check to see if there is a ProgID.  This will tell if the
+  // control is registered on the machine.  No ProgID, control won't run
+  Result := ProgIDFromCLSID(clsid, OleStr) = S_OK;
+  if not Result then Exit;  //Bail as soon as anything goes wrong.
+
+  // Next, make sure that the file is actually there by rooting it out
+  // of the registry
+  Key := WideFormat('\SOFTWARE\Classes\CLSID\%s', [GUIDToString(clsid)]);
+  Reg := TRegIniFile.Create;
+  try
+    Reg.RootKey := HKEY_LOCAL_MACHINE;
+    Result := Reg.OpenKeyReadOnly(Key);
+    if not Result then Exit; // Bail as soon as anything goes wrong.
+
+    FileName := Reg.ReadString('InProcServer32', '', EmptyStr);
+    if (Filename = EmptyStr) then // try another key for the file name
+    begin
+      FileName := Reg.ReadString('InProcServer', '', EmptyStr);
+    end;
+    Result := Filename <> EmptyStr;
+    if not Result then Exit;
+    Result := WideFileExists(Filename);
+  finally
+    Reg.Free;
+  end;
+end;
+
+{ TBufferedAnsiString }
+
+procedure TBufferedAnsiString.Clear;
+begin
+  LastWriteIndex := 0;
+  if Length(FStringBuffer) > 0 then
+    FillChar(FStringBuffer[1], Length(FStringBuffer) * SizeOf(AnsiChar), 0);
+end;
+
+procedure TBufferedAnsiString.AddChar(const wc: AnsiChar);
+const
+  MIN_GROW_SIZE = 32;
+  MAX_GROW_SIZE = 256;
+var
+  GrowSize: Integer;
+begin
+  Inc(LastWriteIndex);
+  if LastWriteIndex > Length(FStringBuffer) then begin
+    GrowSize := Max(MIN_GROW_SIZE, Length(FStringBuffer));
+    GrowSize := Min(GrowSize, MAX_GROW_SIZE);
+    SetLength(FStringBuffer, Length(FStringBuffer) + GrowSize);
+    FillChar(FStringBuffer[LastWriteIndex], GrowSize * SizeOf(AnsiChar), 0);
+  end;
+  FStringBuffer[LastWriteIndex] := wc;
+end;
+
+procedure TBufferedAnsiString.AddString(const s: AnsiString);
+var
+  LenS: Integer;
+  BlockSize: Integer;
+  AllocSize: Integer;
+begin
+  LenS := Length(s);
+  if LenS > 0 then begin
+    Inc(LastWriteIndex);
+    if LastWriteIndex + LenS - 1 > Length(FStringBuffer) then begin
+      // determine optimum new allocation size
+      BlockSize := Length(FStringBuffer) div 2;
+      if BlockSize < 8 then
+        BlockSize := 8;
+      AllocSize := ((LenS div BlockSize) + 1) * BlockSize;
+      // realloc buffer
+      SetLength(FStringBuffer, Length(FStringBuffer) + AllocSize);
+      FillChar(FStringBuffer[Length(FStringBuffer) - AllocSize + 1], AllocSize * SizeOf(AnsiChar), 0);
+    end;
+    CopyMemory(@FStringBuffer[LastWriteIndex], @s[1], LenS * SizeOf(AnsiChar));
+    Inc(LastWriteIndex, LenS - 1);
+  end;
+end;
+
+procedure TBufferedAnsiString.AddBuffer(Buff: PAnsiChar; Chars: Integer);
+var
+  i: integer;
+begin
+  for i := 1 to Chars do begin
+    if Buff^ = #0 then
+      break;
+    AddChar(Buff^);
+    Inc(Buff);
+  end;
+end;
+
+function TBufferedAnsiString.Value: AnsiString;
+begin
+  Result := PAnsiChar(FStringBuffer);
+end;
+
+function TBufferedAnsiString.BuffPtr: PAnsiChar;
+begin
+  Result := PAnsiChar(FStringBuffer);
+end;
+
+{ TBufferedWideString }
+
+procedure TBufferedWideString.Clear;
+begin
+  LastWriteIndex := 0;
+  if Length(FStringBuffer) > 0 then
+    FillChar(FStringBuffer[1], Length(FStringBuffer) * SizeOf(WideChar), 0);
+end;
+
+procedure TBufferedWideString.AddChar(const wc: WideChar);
+const
+  MIN_GROW_SIZE = 32;
+  MAX_GROW_SIZE = 256;
+var
+  GrowSize: Integer;
+begin
+  Inc(LastWriteIndex);
+  if LastWriteIndex > Length(FStringBuffer) then begin
+    GrowSize := Max(MIN_GROW_SIZE, Length(FStringBuffer));
+    GrowSize := Min(GrowSize, MAX_GROW_SIZE);
+    SetLength(FStringBuffer, Length(FStringBuffer) + GrowSize);
+    FillChar(FStringBuffer[LastWriteIndex], GrowSize * SizeOf(WideChar), 0);
+  end;
+  FStringBuffer[LastWriteIndex] := wc;
+end;
+
+procedure TBufferedWideString.AddString(const s: WideString);
+var
+  i: integer;
+begin
+  for i := 1 to Length(s) do
+    AddChar(s[i]);
+end;
+
+procedure TBufferedWideString.AddBuffer(Buff: PWideChar; Chars: Integer);
+var
+  i: integer;
+begin
+  for i := 1 to Chars do begin
+    if Buff^ = #0 then
+      break;
+    AddChar(Buff^);
+    Inc(Buff);
+  end;
+end;
+
+function TBufferedWideString.Value: WideString;
+begin
+  Result := PWideChar(FStringBuffer);
+end;
+
+function TBufferedWideString.BuffPtr: PWideChar;
+begin
+  Result := PWideChar(FStringBuffer);
+end;
+
+{ TBufferedStreamReader }
+
+constructor TBufferedStreamReader.Create(Stream: TStream; BufferSize: Integer = 1024);
+begin
+  // init stream
+  FStream := Stream;
+  FStreamSize := Stream.Size;
+  // init buffer
+  FBufferSize := BufferSize;
+  SetLength(FBuffer, BufferSize);
+  FBufferStartPosition := -FBufferSize; { out of any useful range }
+  // init virtual position
+  FVirtualPosition := 0;
+end;
+
+function TBufferedStreamReader.Seek(Offset: Integer; Origin: Word): Longint;
+begin
+  case Origin of
+    soFromBeginning: FVirtualPosition := Offset;
+    soFromCurrent:   Inc(FVirtualPosition, Offset);
+    soFromEnd:       FVirtualPosition := FStreamSize + Offset;
+  end;
+  Result := FVirtualPosition;
+end;
+
+procedure TBufferedStreamReader.UpdateBufferFromPosition(StartPos: Integer);
+begin
+  try
+    FStream.Position := StartPos;
+    FStream.Read(FBuffer[0], FBufferSize);
+    FBufferStartPosition := StartPos;
+  except
+    FBufferStartPosition := -FBufferSize; { out of any useful range }
+    raise;
+  end;
+end;
+
+function TBufferedStreamReader.Read(var Buffer; Count: Integer): Longint;
+var
+  BytesLeft: Integer;
+  FirstBufferRead: Integer;
+  StreamDirectRead: Integer;
+  Buf: PAnsiChar;
+begin
+  if (FVirtualPosition >= 0) and (Count >= 0) then
+  begin
+    Result := FStreamSize - FVirtualPosition;
+    if Result > 0 then
+    begin
+      if Result > Count then
+        Result := Count;
+
+      Buf := @Buffer;
+      BytesLeft := Result;
+
+      // try to read what is left in buffer
+      FirstBufferRead := FBufferStartPosition + FBufferSize - FVirtualPosition;
+      if (FirstBufferRead < 0) or (FirstBufferRead > FBufferSize) then
+        FirstBufferRead := 0;
+      FirstBufferRead := Min(FirstBufferRead, Result);
+      if FirstBufferRead > 0 then begin
+        Move(FBuffer[FVirtualPosition - FBufferStartPosition], Buf[0], FirstBufferRead);
+        Dec(BytesLeft, FirstBufferRead);
+      end;
+
+      if BytesLeft > 0 then begin
+        // The first read in buffer was not enough
+        StreamDirectRead := (BytesLeft div FBufferSize) * FBufferSize;
+        FStream.Position := FVirtualPosition + FirstBufferRead;
+        FStream.Read(Buf[FirstBufferRead], StreamDirectRead);
+        Dec(BytesLeft, StreamDirectRead);
+
+        if BytesLeft > 0 then begin
+          // update buffer, and read what is left
+          UpdateBufferFromPosition(FStream.Position);
+          Move(FBuffer[0], Buf[FirstBufferRead + StreamDirectRead], BytesLeft);
+        end;
+      end;
+
+      Inc(FVirtualPosition, Result);
+      Exit;
+    end;
+  end;
+  Result := 0;
+end;
+
+function TBufferedStreamReader.Write(const Buffer; Count: Integer): Longint;
+begin
+  raise ETntInternalError.Create('Internal Error: class can not write.');
+  Result := 0;
+end;
+
+//-------- synced wide string -----------------
+
+function GetSyncedWideString(var WideStr: WideString; const AnsiStr: AnsiString): WideString;
+begin
+  if AnsiString(WideStr) <> (AnsiStr) then begin
+    WideStr := AnsiStr; {AnsiStr changed.  Keep WideStr in sync.}
+  end;
+  Result := WideStr;
+end;
+
+procedure SetSyncedWideString(const Value: WideString; var WideStr: WideString;
+  const AnsiStr: AnsiString; SetAnsiStr: TSetAnsiStrEvent);
+begin
+  if Value <> GetSyncedWideString(WideStr, AnsiStr) then
+  begin
+    if (not WideSameStr(Value, AnsiString(Value))) {unicode chars lost in conversion}
+    and (AnsiStr = AnsiString(Value))  {AnsiStr is not going to change}
+    then begin
+      SetAnsiStr(''); {force the change}
+    end;
+    WideStr := Value;
+    SetAnsiStr(Value);
+  end;
+end;
+
+{ TWideComponentHelper }
+
+function CompareComponentHelperToTarget(Item, Target: Pointer): Integer;
+begin
+  if PtrUInt(TWideComponentHelper(Item).FComponent) < PtrUInt(Target) then
+    Result := -1
+  else if PtrUInt(TWideComponentHelper(Item).FComponent) > PtrUInt(Target) then
+    Result := 1
+  else
+    Result := 0;
+end;
+
+function FindWideComponentHelperIndex(ComponentHelperList: TComponentList; Component: TComponent; var Index: Integer): Boolean;
+begin
+  // find Component in sorted wide caption list (list is sorted by TWideComponentHelper.FComponent)
+  Result := FindSortedListByTarget(ComponentHelperList, CompareComponentHelperToTarget, Component, Index);
+end;
+
+constructor TWideComponentHelper.Create(AOwner: TComponent);
+begin
+  raise ETntInternalError.Create('TNT Internal Error: TWideComponentHelper.Create should never be encountered.');
+end;
+
+constructor TWideComponentHelper.CreateHelper(AOwner: TComponent; ComponentHelperList: TComponentList);
+var
+  Index: Integer;
+begin
+  // don't use direct ownership for memory management
+  inherited Create(nil);
+  FComponent := AOwner;
+  FComponent.FreeNotification(Self);
+
+  // insert into list according to sort
+  FindWideComponentHelperIndex(ComponentHelperList, FComponent, Index);
+  ComponentHelperList.Insert(Index, Self);
+end;
+
+procedure TWideComponentHelper.Notification(AComponent: TComponent; Operation: TOperation);
+begin
+  inherited;
+  if (AComponent = FComponent) and (Operation = opRemove) then begin
+    FComponent := nil;
+    Free;
+  end;
+end;
+
+function FindWideComponentHelper(ComponentHelperList: TComponentList; Component: TComponent): TWideComponentHelper;
+var
+  Index: integer;
+begin
+  if FindWideComponentHelperIndex(ComponentHelperList, Component, Index) then begin
+  	Result := TWideComponentHelper(ComponentHelperList[Index]);
+    Assert(Result.FComponent = Component, 'TNT Internal Error: FindWideComponentHelperIndex failed.');
+  end else
+    Result := nil;
+end;
+
+initialization
+  RuntimeUTFStreaming := False; { Delphi 6 and higher don't need UTF help at runtime. }
+
+end.
diff --git a/Lua/src/lib/TntUnicodeControls/TntCompilers.inc b/Lua/src/lib/TntUnicodeControls/TntCompilers.inc
new file mode 100644
index 00000000..06f4d9ab
--- /dev/null
+++ b/Lua/src/lib/TntUnicodeControls/TntCompilers.inc
@@ -0,0 +1,378 @@
+//----------------------------------------------------------------------------------------------------------------------
+// Include file to determine which compiler is currently being used to build the project/component.
+// This file uses ideas from Brad Stowers DFS.inc file (www.delphifreestuff.com).
+//
+// Portions created by Mike Lischke are Copyright
+// (C) 1999-2002 Dipl. Ing. Mike Lischke. All Rights Reserved.
+//----------------------------------------------------------------------------------------------------------------------
+// The following symbols are defined:
+//
+// COMPILER_1    : Kylix/Delphi/BCB 1.x is the compiler.
+// COMPILER_1_UP : Kylix/Delphi/BCB 1.x or higher is the compiler.
+// COMPILER_2    : Kylix/Delphi 2.x or BCB 1.x is the compiler.
+// COMPILER_2_UP : Kylix/Delphi 2.x or higher, or BCB 1.x or higher is the compiler.
+// COMPILER_3    : Kylix/Delphi/BCB 3.x is the compiler.
+// COMPILER_3_UP : Kylix/Delphi/BCB 3.x or higher is the compiler.
+// COMPILER_4    : Kylix/Delphi/BCB 4.x is the compiler.
+// COMPILER_4_UP : Kylix/Delphi/BCB 4.x or higher is the compiler.
+// COMPILER_5    : Kylix/Delphi/BCB 5.x is the compiler.
+// COMPILER_5_UP : Kylix/Delphi/BCB 5.x or higher is the compiler.
+// COMPILER_6    : Kylix/Delphi/BCB 6.x is the compiler.
+// COMPILER_6_UP : Kylix/Delphi/BCB 6.x or higher is the compiler.
+// COMPILER_7    : Kylix/Delphi/BCB 7.x is the compiler.
+// COMPILER_7_UP : Kylix/Delphi/BCB 7.x or higher is the compiler.
+//
+// Only defined if Windows is the target:
+// CPPB        : Any version of BCB is being used.
+// CPPB_1      : BCB v1.x is being used.
+// CPPB_3      : BCB v3.x is being used.
+// CPPB_3_UP   : BCB v3.x or higher is being used.
+// CPPB_4      : BCB v4.x is being used.
+// CPPB_4_UP   : BCB v4.x or higher is being used.
+// CPPB_5      : BCB v5.x is being used.
+// CPPB_5_UP   : BCB v5.x or higher is being used.
+// CPPB_6      : BCB v6.x is being used.
+// CPPB_6_UP   : BCB v6.x or higher is being used.
+//
+// Only defined if Windows is the target:
+// DELPHI      : Any version of Delphi is being used.
+// DELPHI_1    : Delphi v1.x is being used.
+// DELPHI_2    : Delphi v2.x is being used.
+// DELPHI_2_UP : Delphi v2.x or higher is being used.
+// DELPHI_3    : Delphi v3.x is being used.
+// DELPHI_3_UP : Delphi v3.x or higher is being used.
+// DELPHI_4    : Delphi v4.x is being used.
+// DELPHI_4_UP : Delphi v4.x or higher is being used.
+// DELPHI_5    : Delphi v5.x is being used.
+// DELPHI_5_UP : Delphi v5.x or higher is being used.
+// DELPHI_6    : Delphi v6.x is being used.
+// DELPHI_6_UP : Delphi v6.x or higher is being used.
+// DELPHI_7    : Delphi v7.x is being used.
+// DELPHI_7_UP : Delphi v7.x or higher is being used.
+//
+// Only defined if Linux is the target:
+// KYLIX       : Any version of Kylix is being used.
+// KYLIX_1     : Kylix 1.x is being used.
+// KYLIX_1_UP  : Kylix 1.x or higher is being used.
+// KYLIX_2     : Kylix 2.x is being used.
+// KYLIX_2_UP  : Kylix 2.x or higher is being used.
+// KYLIX_3     : Kylix 3.x is being used.
+// KYLIX_3_UP  : Kylix 3.x or higher is being used.
+//
+// Only defined if Linux is the target:
+// QT_CLX      : Trolltech's QT library is being used.
+//----------------------------------------------------------------------------------------------------------------------
+
+{$ifdef Win32}
+
+  {$ifdef VER180}
+    {$define COMPILER_10}
+    {$define DELPHI}
+    {$define DELPHI_10}
+  {$endif}
+
+  {$ifdef VER170}
+    {$define COMPILER_9}
+    {$define DELPHI}
+    {$define DELPHI_9}
+  {$endif}
+
+  {$ifdef VER150}        
+    {$define COMPILER_7}
+    {$define DELPHI}
+    {$define DELPHI_7}
+  {$endif}
+
+  {$ifdef VER140}
+    {$define COMPILER_6}
+    {$ifdef BCB}
+      {$define CPPB}
+      {$define CPPB_6}
+    {$else}
+      {$define DELPHI}
+      {$define DELPHI_6}
+    {$endif}
+  {$endif}
+
+  {$ifdef VER130}
+    {$define COMPILER_5}
+    {$ifdef BCB}
+      {$define CPPB}
+      {$define CPPB_5}
+    {$else}
+      {$define DELPHI}
+      {$define DELPHI_5}
+    {$endif}
+  {$endif}
+
+  {$ifdef VER125}
+    {$define COMPILER_4}
+    {$define CPPB}
+    {$define CPPB_4}
+  {$endif}
+
+  {$ifdef VER120}
+    {$define COMPILER_4}
+    {$define DELPHI}
+    {$define DELPHI_4}
+  {$endif}
+
+  {$ifdef VER110}
+    {$define COMPILER_3}
+    {$define CPPB}
+    {$define CPPB_3}
+  {$endif}
+
+  {$ifdef VER100}
+    {$define COMPILER_3}
+    {$define DELPHI}
+    {$define DELPHI_3}
+  {$endif}
+
+  {$ifdef VER93}
+    {$define COMPILER_2} // C++ Builder v1 compiler is really v2 
+    {$define CPPB}
+    {$define CPPB_1}
+  {$endif}
+
+  {$ifdef VER90}
+    {$define COMPILER_2}
+    {$define DELPHI}
+    {$define DELPHI_2}
+  {$endif}
+
+  {$ifdef VER80}
+    {$define COMPILER_1}
+    {$define DELPHI}
+    {$define DELPHI_1}
+  {$endif}
+
+  {$ifdef FPC}
+    {.$define DELPHI}
+  {$endif}
+    
+  {$ifdef DELPHI_2}
+    {$define DELPHI_2_UP}
+  {$endif}
+
+  {$ifdef DELPHI_3}
+    {$define DELPHI_2_UP}
+    {$define DELPHI_3_UP}
+  {$endif}
+
+  {$ifdef DELPHI_4}
+    {$define DELPHI_2_UP}
+    {$define DELPHI_3_UP}
+    {$define DELPHI_4_UP}
+  {$endif}
+
+  {$ifdef DELPHI_5}
+    {$define DELPHI_2_UP}
+    {$define DELPHI_3_UP}
+    {$define DELPHI_4_UP}
+    {$define DELPHI_5_UP}
+  {$endif}
+
+  {$ifdef DELPHI_6}
+    {$define DELPHI_2_UP}
+    {$define DELPHI_3_UP}
+    {$define DELPHI_4_UP}
+    {$define DELPHI_5_UP}
+    {$define DELPHI_6_UP}
+  {$endif}
+
+  {$ifdef DELPHI_7}
+    {$define DELPHI_2_UP}
+    {$define DELPHI_3_UP}
+    {$define DELPHI_4_UP}
+    {$define DELPHI_5_UP}
+    {$define DELPHI_6_UP}
+    {$define DELPHI_7_UP}
+  {$endif}
+
+  {$ifdef DELPHI_9}
+    {$define DELPHI_2_UP}
+    {$define DELPHI_3_UP}
+    {$define DELPHI_4_UP}
+    {$define DELPHI_5_UP}
+    {$define DELPHI_6_UP}
+    {$define DELPHI_7_UP}
+    {$define DELPHI_9_UP}
+  {$endif}
+
+  {$ifdef DELPHI_10}
+    {$define DELPHI_2_UP}
+    {$define DELPHI_3_UP}
+    {$define DELPHI_4_UP}
+    {$define DELPHI_5_UP}
+    {$define DELPHI_6_UP}
+    {$define DELPHI_7_UP}
+    {$define DELPHI_9_UP}
+    {$define DELPHI_10_UP}
+  {$endif}
+
+  {$ifdef CPPB_3}
+    {$define CPPB_3_UP}
+  {$endif}
+
+  {$ifdef CPPB_4}
+    {$define CPPB_3_UP}
+    {$define CPPB_4_UP}
+  {$endif}
+
+  {$ifdef CPPB_5}
+    {$define CPPB_3_UP}
+    {$define CPPB_4_UP}
+    {$define CPPB_5_UP}
+  {$endif}
+
+  {$ifdef CPPB_6}
+    {$define CPPB_3_UP}
+    {$define CPPB_4_UP}
+    {$define CPPB_5_UP}
+    {$define CPPB_6_UP}
+  {$endif}
+
+  {$ifdef CPPB_3_UP}
+    // C++ Builder requires this if you use Delphi components in run-time packages.
+    {$ObjExportAll On}
+  {$endif}
+
+{$else (not Windows)}
+  // Linux is the target
+  {$define QT_CLX}
+
+  {$define KYLIX}
+  {$define KYLIX_1}
+  {$define KYLIX_1_UP}
+
+  {$ifdef VER150}
+    {$define COMPILER_7}
+    {$define KYLIX_3}
+  {$endif}
+
+  {$ifdef VER140}
+    {$define COMPILER_6}
+    {$define KYLIX_2}
+  {$endif}
+
+  {$ifdef KYLIX_2}
+    {$define KYLIX_2_UP}
+  {$endif}
+
+  {$ifdef KYLIX_3}
+    {$define KYLIX_2_UP}
+    {$define KYLIX_3_UP}
+  {$endif}
+
+{$endif}
+
+// Compiler defines common to all platforms.
+{$ifdef COMPILER_1}
+  {$define COMPILER_1_UP}
+{$endif}
+
+{$ifdef COMPILER_2}
+  {$define COMPILER_1_UP}
+  {$define COMPILER_2_UP}
+{$endif}
+
+{$ifdef COMPILER_3}
+  {$define COMPILER_1_UP}
+  {$define COMPILER_2_UP}
+  {$define COMPILER_3_UP}
+{$endif}
+
+{$ifdef COMPILER_4}
+  {$define COMPILER_1_UP}
+  {$define COMPILER_2_UP}
+  {$define COMPILER_3_UP}
+  {$define COMPILER_4_UP}
+{$endif}
+
+{$ifdef COMPILER_5}
+  {$define COMPILER_1_UP}
+  {$define COMPILER_2_UP}
+  {$define COMPILER_3_UP}
+  {$define COMPILER_4_UP}
+  {$define COMPILER_5_UP}
+{$endif}
+
+{$ifdef COMPILER_6}
+  {$define COMPILER_1_UP}
+  {$define COMPILER_2_UP}
+  {$define COMPILER_3_UP}
+  {$define COMPILER_4_UP}
+  {$define COMPILER_5_UP}
+  {$define COMPILER_6_UP}
+{$endif}
+
+{$ifdef COMPILER_7}
+  {$define COMPILER_1_UP}
+  {$define COMPILER_2_UP}
+  {$define COMPILER_3_UP}
+  {$define COMPILER_4_UP}
+  {$define COMPILER_5_UP}
+  {$define COMPILER_6_UP}
+  {$define COMPILER_7_UP}
+{$endif}
+
+{$ifdef COMPILER_9}
+  {$define COMPILER_1_UP}
+  {$define COMPILER_2_UP}
+  {$define COMPILER_3_UP}
+  {$define COMPILER_4_UP}
+  {$define COMPILER_5_UP}
+  {$define COMPILER_6_UP}
+  {$define COMPILER_7_UP}
+  {$define COMPILER_9_UP}
+{$endif}
+
+{$ifdef COMPILER_10}
+  {$define COMPILER_1_UP}
+  {$define COMPILER_2_UP}
+  {$define COMPILER_3_UP}
+  {$define COMPILER_4_UP}
+  {$define COMPILER_5_UP}
+  {$define COMPILER_6_UP}
+  {$define COMPILER_7_UP}
+  {$define COMPILER_9_UP}
+  {$define COMPILER_10_UP}
+{$endif}
+
+//----------------------------------------------------------------------------------------------------------------------
+
+{$ALIGN ON}
+{$BOOLEVAL OFF}
+
+{$ifdef COMPILER_7_UP}
+  {$define THEME_7_UP} { Allows experimental theme support on pre-Delphi 7. }
+{$endif}
+
+{$IFDEF COMPILER_6_UP}
+{$WARN SYMBOL_PLATFORM OFF} { We are going to use Win32 specific symbols! }
+{$ENDIF}
+
+{$IFDEF COMPILER_7_UP}
+{$IFDEF FPC}
+  {$DEFINE UNSAFE_WARNINGS_OFF}
+{$ENDIF}
+{$ENDIF}
+
+{$IFDEF UNSAFE_WARNINGS_OFF}
+{$WARN UNSAFE_CODE OFF} { We are not going to be "safe"! }
+{$WARN UNSAFE_TYPE OFF}
+{$WARN UNSAFE_CAST OFF}
+{$ENDIF}
+
+{$IFDEF FPC}
+{$HINTS OFF}
+{$ENDIF}
+
+{$IFNDEF FPC}
+  // Delphi system function overrides might (not tested) cause problems on
+  // CPUs with code protection (NX-bit). So disable by default. 
+  {.$DEFINE USE_SYSTEM_OVERRIDES}
+{$ENDIF}
+
+
diff --git a/Lua/src/lib/TntUnicodeControls/TntFormatStrUtils.pas b/Lua/src/lib/TntUnicodeControls/TntFormatStrUtils.pas
new file mode 100644
index 00000000..c6b65082
--- /dev/null
+++ b/Lua/src/lib/TntUnicodeControls/TntFormatStrUtils.pas
@@ -0,0 +1,521 @@
+
+{*****************************************************************************}
+{                                                                             }
+{    Tnt Delphi Unicode Controls                                              }
+{      http://www.tntware.com/delphicontrols/unicode/                         }
+{        Version: 2.3.0                                                       }
+{                                                                             }
+{    Copyright (c) 2002-2007, Troy Wolbrink (troy.wolbrink@tntware.com)       }
+{                                                                             }
+{*****************************************************************************}
+
+unit TntFormatStrUtils;
+
+{$IFDEF FPC}
+  {$MODE Delphi}
+{$ENDIF}
+
+{$INCLUDE TntCompilers.inc}
+
+interface
+
+// this unit provides functions to work with format strings
+
+uses
+  TntSysUtils;
+
+function GetCanonicalFormatStr(const _FormatString: WideString): WideString;
+
+{$IFNDEF FPC}
+{$IFNDEF COMPILER_9_UP}
+function ReplaceFloatingArgumentsInFormatString(const _FormatString: WideString;
+  const Args: array of const
+    {$IFDEF COMPILER_7_UP}; FormatSettings: PFormatSettings{$ENDIF}): WideString;
+{$ENDIF}
+{$ENDIF}
+procedure CompareFormatStrings(FormatStr1, FormatStr2: WideString);
+function FormatStringsAreCompatible(FormatStr1, FormatStr2: WideString): Boolean;
+
+type
+  EFormatSpecError = class(ETntGeneralError);
+
+implementation
+
+uses
+  SysUtils, Math, TntClasses;
+
+resourcestring
+  SInvalidFormatSpecifier = 'Invalid Format Specifier: %s';
+  SMismatchedArgumentTypes = 'Argument types for index %d do not match. (%s <> %s)';
+  SMismatchedArgumentCounts = 'Number of format specifiers do not match.';
+
+type
+  TFormatSpecifierType = (fstInteger, fstFloating, fstPointer, fstString);
+
+function GetFormatSpecifierType(const FormatSpecifier: WideString): TFormatSpecifierType;
+var
+  LastChar: WideChar;
+begin
+  LastChar := TntWideLastChar(FormatSpecifier);
+  case LastChar of
+    'd', 'D', 'u', 'U', 'x', 'X':
+      result := fstInteger;
+    'e', 'E', 'f', 'F', 'g', 'G', 'n', 'N', 'm', 'M':
+      result := fstFloating;
+    'p', 'P':
+      result := fstPointer;
+    's', 'S':
+      result := fstString
+    else
+      raise ETntInternalError.CreateFmt('Internal Error: Unexpected format type (%s)', [LastChar]);
+  end;
+end;
+
+type
+  TFormatStrParser = class(TObject)
+  private
+    ParsedString: TBufferedWideString;
+    PFormatString: PWideChar;
+    LastIndex: Integer;
+    ExplicitCount: Integer;
+    ImplicitCount: Integer;
+    procedure RaiseInvalidFormatSpecifier;
+    function ParseChar(c: WideChar): Boolean;
+    procedure ForceParseChar(c: WideChar);
+    function ParseDigit: Boolean;
+    function ParseInteger: Boolean;
+    procedure ForceParseType;
+    function PeekDigit: Boolean;
+    function PeekIndexSpecifier(out Index: Integer): Boolean;
+  public
+    constructor Create(const _FormatString: WideString);
+    destructor Destroy; override;
+    function ParseFormatSpecifier: Boolean;
+  end;
+
+constructor TFormatStrParser.Create(const _FormatString: WideString);
+begin
+  inherited Create;
+  PFormatString := PWideChar(_FormatString);
+  ExplicitCount := 0;
+  ImplicitCount := 0;
+  LastIndex := -1;
+  ParsedString := TBufferedWideString.Create;
+end;
+
+destructor TFormatStrParser.Destroy;
+begin
+  FreeAndNil(ParsedString);
+  inherited;
+end;
+
+procedure TFormatStrParser.RaiseInvalidFormatSpecifier;
+begin
+  raise EFormatSpecError.CreateFmt(SInvalidFormatSpecifier, [ParsedString.Value + PFormatString]);
+end;
+
+function TFormatStrParser.ParseChar(c: WideChar): Boolean;
+begin
+  result := False;
+  if PFormatString^ = c then begin
+    result := True;
+    ParsedString.AddChar(c);
+    Inc(PFormatString);
+  end;
+end;
+
+procedure TFormatStrParser.ForceParseChar(c: WideChar);
+begin
+  if not ParseChar(c) then
+    RaiseInvalidFormatSpecifier;
+end;
+
+function TFormatStrParser.PeekDigit: Boolean;
+begin
+  result := False;
+  if  (PFormatString^ <> #0)
+  and (PFormatString^ >= '0')
+  and (PFormatString^ <= '9') then
+    result := True;
+end;
+
+function TFormatStrParser.ParseDigit: Boolean;
+begin
+  result := False;
+  if PeekDigit then begin
+    result := True;
+    ForceParseChar(PFormatString^);
+  end;
+end;
+
+function TFormatStrParser.ParseInteger: Boolean;
+const
+  MAX_INT_DIGITS = 6;
+var
+  digitcount: integer;
+begin
+  digitcount := 0;
+  While ParseDigit do begin
+    inc(digitcount);
+  end;
+  result := (digitcount > 0);
+  if digitcount > MAX_INT_DIGITS then
+    RaiseInvalidFormatSpecifier;
+end;
+
+procedure TFormatStrParser.ForceParseType;
+begin
+  if PFormatString^ = #0 then
+    RaiseInvalidFormatSpecifier;
+
+  case PFormatString^ of
+    'd', 'u', 'x', 'e', 'f', 'g', 'n', 'm', 'p', 's',
+    'D', 'U', 'X', 'E', 'F', 'G', 'N', 'M', 'P', 'S':
+  begin
+    // do nothing
+  end
+  else
+    RaiseInvalidFormatSpecifier;
+  end;
+  ForceParseChar(PFormatString^);
+end;
+
+function TFormatStrParser.PeekIndexSpecifier(out Index: Integer): Boolean;
+var
+  SaveParsedString: WideString;
+  SaveFormatString: PWideChar;
+begin
+  SaveParsedString := ParsedString.Value;
+  SaveFormatString := PFormatString;
+  try
+    ParsedString.Clear;
+    Result := False;
+    Index := -1;
+    if ParseInteger then begin
+      Index := StrToInt(ParsedString.Value);
+      if ParseChar(':') then
+        Result := True;
+    end;
+  finally
+    ParsedString.Clear;
+    ParsedString.AddString(SaveParsedString);
+    PFormatString := SaveFormatString;
+  end;
+end;
+
+function TFormatStrParser.ParseFormatSpecifier: Boolean;
+var
+  ExplicitIndex: Integer;
+begin
+  Result := False;
+  // Parse entire format specifier
+  ForceParseChar('%');
+  if (PFormatString^ <> #0)
+  and (not ParseChar(' '))
+  and (not ParseChar('%')) then begin
+    if PeekIndexSpecifier(ExplicitIndex) then begin
+      Inc(ExplicitCount);
+      LastIndex := Max(LastIndex, ExplicitIndex);
+    end else begin
+      Inc(ImplicitCount);
+      Inc(LastIndex);
+      ParsedString.AddString(IntToStr(LastIndex));
+      ParsedString.AddChar(':');
+    end;
+    if ParseChar('*') then
+    begin
+      Inc(ImplicitCount);
+      Inc(LastIndex);
+      ParseChar(':');
+    end else if ParseInteger then
+      ParseChar(':');
+    ParseChar('-');
+    if ParseChar('*') then begin
+      Inc(ImplicitCount);
+      Inc(LastIndex);
+    end else
+      ParseInteger;
+    if ParseChar('.') then begin
+      if not ParseChar('*') then
+        ParseInteger;
+    end;
+    ForceParseType;
+    Result := True;
+  end;
+end;
+
+//-----------------------------------
+
+function GetCanonicalFormatStr(const _FormatString: WideString): WideString;
+var
+  PosSpec: Integer;
+begin
+  with TFormatStrParser.Create(_FormatString) do
+  try
+    // loop until no more '%'
+    PosSpec := Pos('%', PFormatString);
+    While PosSpec <> 0 do begin
+      try
+        // delete everything up until '%'
+        ParsedString.AddBuffer(PFormatString, PosSpec - 1);
+        Inc(PFormatString, PosSpec - 1);
+        // parse format specifier
+        ParseFormatSpecifier;
+      finally
+        PosSpec := Pos('%', PFormatString);
+      end;
+    end;
+    if ((ExplicitCount = 0) and (ImplicitCount = 1)) {simple expression}
+    or ((ExplicitCount > 0) and (ImplicitCount = 0)) {nothing converted} then
+      result := _FormatString {original}
+    else
+      result := ParsedString.Value + PFormatString;
+  finally
+    Free;
+  end;
+end;
+
+{$IFNDEF FPC}
+{$IFNDEF COMPILER_9_UP}
+function ReplaceFloatingArgumentsInFormatString(const _FormatString: WideString;
+  const Args: array of const
+    {$IFDEF COMPILER_7_UP}; FormatSettings: PFormatSettings{$ENDIF}): WideString;
+{ This function replaces floating point format specifiers with their actual formatted values.
+  It also adds index specifiers so that the other format specifiers don't lose their place.
+  The reason for this is that WideFormat doesn't correctly format floating point specifiers.
+  See QC#4254. }
+var
+  Parser: TFormatStrParser;
+  PosSpec: Integer;
+  Output: TBufferedWideString;
+begin
+  Output := TBufferedWideString.Create;
+  try
+    Parser := TFormatStrParser.Create(_FormatString);
+    with Parser do
+    try
+      // loop until no more '%'
+      PosSpec := Pos('%', PFormatString);
+      While PosSpec <> 0 do begin
+        try
+          // delete everything up until '%'
+          Output.AddBuffer(PFormatString, PosSpec - 1);
+          Inc(PFormatString, PosSpec - 1);
+          // parse format specifier
+          ParsedString.Clear;
+          if (not ParseFormatSpecifier)
+          or (GetFormatSpecifierType(ParsedString.Value) <> fstFloating) then
+            Output.AddBuffer(ParsedString.BuffPtr, MaxInt)
+          {$IFDEF COMPILER_7_UP}
+          else if Assigned(FormatSettings) then
+            Output.AddString(Format{TNT-ALLOW Format}(ParsedString.Value, Args, FormatSettings^))
+          {$ENDIF}
+          else
+            Output.AddString(Format{TNT-ALLOW Format}(ParsedString.Value, Args));
+        finally
+          PosSpec := Pos('%', PFormatString);
+        end;
+      end;
+      Output.AddString(PFormatString);
+    finally
+      Free;
+    end;
+    Result := Output.Value;
+  finally
+    Output.Free;
+  end;
+end;
+{$ENDIF}
+{$ENDIF}
+
+procedure GetFormatArgs(const _FormatString: WideString; FormatArgs: TTntStrings);
+var
+  PosSpec: Integer;
+begin
+  with TFormatStrParser.Create(_FormatString) do
+  try
+    FormatArgs.Clear;
+    // loop until no more '%'
+    PosSpec := Pos('%', PFormatString);
+    While PosSpec <> 0 do begin
+      try
+        // delete everything up until '%'
+        Inc(PFormatString, PosSpec - 1);
+        // add format specifier to list
+        ParsedString.Clear;
+        if ParseFormatSpecifier then
+          FormatArgs.Add(ParsedString.Value);
+      finally
+        PosSpec := Pos('%', PFormatString);
+      end;
+    end;
+  finally
+    Free;
+  end;
+end;
+
+function GetExplicitIndex(const FormatSpecifier: WideString): Integer;
+var
+  IndexStr: WideString;
+  PosColon: Integer;
+begin
+  result := -1;
+  PosColon := Pos(':', FormatSpecifier);
+  if PosColon <> 0 then begin
+    IndexStr := Copy(FormatSpecifier, 2, PosColon - 2);
+    result := StrToInt(IndexStr);
+  end;
+end;
+
+function GetMaxIndex(FormatArgs: TTntStrings): Integer;
+var
+  i: integer;
+  RunningIndex: Integer;
+  ExplicitIndex: Integer;
+begin
+  result := -1;
+  RunningIndex := -1;
+  for i := 0 to FormatArgs.Count - 1 do begin
+    ExplicitIndex := GetExplicitIndex(FormatArgs[i]);
+    if ExplicitIndex <> -1 then
+      RunningIndex := ExplicitIndex
+    else
+      inc(RunningIndex);
+    result := Max(result, RunningIndex);
+  end;
+end;
+
+function FormatSpecToObject(SpecType: TFormatSpecifierType): TObject;
+begin
+  {$IFNDEF FPC}
+  Result := TObject(SpecType);
+  {$ELSE}
+  Result := Pointer(SpecType);
+  {$ENDIF}
+end;
+
+procedure UpdateTypeList(FormatArgs, TypeList: TTntStrings);
+var
+  i: integer;
+  f: WideString;
+  SpecType: TFormatSpecifierType;
+  ExplicitIndex: Integer;
+  MaxIndex: Integer;
+  RunningIndex: Integer;
+begin
+  // set count of TypeList to accomodate maximum index
+  MaxIndex := GetMaxIndex(FormatArgs);
+  TypeList.Clear;
+  for i := 0 to MaxIndex do
+    TypeList.Add('');
+
+  // for each arg...
+  RunningIndex := -1;
+  for i := 0 to FormatArgs.Count - 1 do begin
+    f := FormatArgs[i];
+    ExplicitIndex := GetExplicitIndex(f);
+    SpecType := GetFormatSpecifierType(f);
+
+    // determine running arg index
+    if ExplicitIndex <> -1 then
+      RunningIndex := ExplicitIndex
+    else
+      inc(RunningIndex);
+
+    if TypeList[RunningIndex] <> '' then begin
+      // already exists in list, check for compatibility
+      if TypeList.Objects[RunningIndex] <> FormatSpecToObject(SpecType) then
+        raise EFormatSpecError.CreateFmt(SMismatchedArgumentTypes,
+          [RunningIndex, TypeList[RunningIndex], f]);
+    end else begin
+      // not in list so update it
+      TypeList[RunningIndex] := f;
+      TypeList.Objects[RunningIndex] := FormatSpecToObject(SpecType);
+    end;
+  end;
+end;
+
+procedure CompareFormatStrings(FormatStr1, FormatStr2: WideString);
+var
+  ArgList1: TTntStringList;
+  ArgList2: TTntStringList;
+  TypeList1: TTntStringList;
+  TypeList2: TTntStringList;
+  i: integer;
+begin
+  ArgList1 := nil;
+  ArgList2 := nil;
+  TypeList1 := nil;
+  TypeList2 := nil;
+  try
+    ArgList1 := TTntStringList.Create;
+    ArgList2 := TTntStringList.Create;
+    TypeList1 := TTntStringList.Create;
+    TypeList2 := TTntStringList.Create;
+
+    GetFormatArgs(FormatStr1, ArgList1);
+    UpdateTypeList(ArgList1, TypeList1);
+
+    GetFormatArgs(FormatStr2, ArgList2);
+    UpdateTypeList(ArgList2, TypeList2);
+
+    if TypeList1.Count <> TypeList2.Count then
+      raise EFormatSpecError.Create(SMismatchedArgumentCounts + CRLF + CRLF + '> ' + FormatStr1 + CRLF + '> ' + FormatStr2);
+
+    for i := 0 to TypeList1.Count - 1 do begin
+      if TypeList1.Objects[i] <> TypeList2.Objects[i] then begin
+        raise EFormatSpecError.CreateFmt(SMismatchedArgumentTypes,
+          [i, TypeList1[i], TypeList2[i]]);
+      end;
+    end;
+
+  finally
+    ArgList1.Free;
+    ArgList2.Free;
+    TypeList1.Free;
+    TypeList2.Free;
+  end;
+end;
+
+function FormatStringsAreCompatible(FormatStr1, FormatStr2: WideString): Boolean;
+var
+  ArgList1: TTntStringList;
+  ArgList2: TTntStringList;
+  TypeList1: TTntStringList;
+  TypeList2: TTntStringList;
+  i: integer;
+begin
+  ArgList1 := nil;
+  ArgList2 := nil;
+  TypeList1 := nil;
+  TypeList2 := nil;
+  try
+    ArgList1 := TTntStringList.Create;
+    ArgList2 := TTntStringList.Create;
+    TypeList1 := TTntStringList.Create;
+    TypeList2 := TTntStringList.Create;
+
+    GetFormatArgs(FormatStr1, ArgList1);
+    UpdateTypeList(ArgList1, TypeList1);
+
+    GetFormatArgs(FormatStr2, ArgList2);
+    UpdateTypeList(ArgList2, TypeList2);
+
+    Result := (TypeList1.Count = TypeList2.Count);
+    if Result then begin
+      for i := 0 to TypeList1.Count - 1 do begin
+        if TypeList1.Objects[i] <> TypeList2.Objects[i] then begin
+          Result := False;
+          break;
+        end;
+      end;
+    end;
+  finally
+    ArgList1.Free;
+    ArgList2.Free;
+    TypeList1.Free;
+    TypeList2.Free;
+  end;
+end;
+
+end.
diff --git a/Lua/src/lib/TntUnicodeControls/TntSysUtils.pas b/Lua/src/lib/TntUnicodeControls/TntSysUtils.pas
new file mode 100644
index 00000000..b7cf2467
--- /dev/null
+++ b/Lua/src/lib/TntUnicodeControls/TntSysUtils.pas
@@ -0,0 +1,1753 @@
+
+{*****************************************************************************}
+{                                                                             }
+{    Tnt Delphi Unicode Controls                                              }
+{      http://www.tntware.com/delphicontrols/unicode/                         }
+{        Version: 2.3.0                                                       }
+{                                                                             }
+{    Copyright (c) 2002-2007, Troy Wolbrink (troy.wolbrink@tntware.com)       }
+{                                                                             }
+{*****************************************************************************}
+
+unit TntSysUtils;
+
+{$IFDEF FPC}
+  {$MODE Delphi}
+{$ENDIF}
+
+{$INCLUDE TntCompilers.inc}
+
+interface
+
+{ TODO: Consider: more filename functions from SysUtils }
+{ TODO: Consider: string functions from StrUtils. }
+
+uses
+  Types, SysUtils, Windows, TntWindows;
+
+//---------------------------------------------------------------------------------------------
+//                                 Tnt - Types
+//---------------------------------------------------------------------------------------------
+
+// ......... introduced .........
+type
+  // The user of the application did something plainly wrong.
+  ETntUserError = class(Exception);
+  // A general error occured. (ie. file didn't exist, server didn't return data, etc.)
+  ETntGeneralError = class(Exception);
+  // Like Assert().  An error occured that should never have happened, send me a bug report now!
+  ETntInternalError = class(Exception);
+
+{$IFNDEF FPC}
+type
+  PtrInt = LongInt;
+  PtrUInt = LongWord;
+{$ENDIF}
+
+//---------------------------------------------------------------------------------------------
+//                                 Tnt - SysUtils
+//---------------------------------------------------------------------------------------------
+
+// ......... SBCS and MBCS functions with WideString replacements in SysUtils.pas .........
+
+{TNT-WARN CompareStr}                   {TNT-WARN AnsiCompareStr}
+{TNT-WARN SameStr}                      {TNT-WARN AnsiSameStr}
+{TNT-WARN SameText}                     {TNT-WARN AnsiSameText}
+{TNT-WARN CompareText}                  {TNT-WARN AnsiCompareText}
+{TNT-WARN UpperCase}                    {TNT-WARN AnsiUpperCase}
+{TNT-WARN LowerCase}                    {TNT-WARN AnsiLowerCase}
+
+{TNT-WARN AnsiPos}  { --> Pos() supports WideString. }
+{TNT-WARN FmtStr}
+{TNT-WARN Format}
+{TNT-WARN FormatBuf}
+
+// ......... MBCS Byte Type Procs .........
+
+{TNT-WARN ByteType}
+{TNT-WARN StrByteType}
+{TNT-WARN ByteToCharIndex}
+{TNT-WARN ByteToCharLen}
+{TNT-WARN CharToByteIndex}
+{TNT-WARN CharToByteLen}
+
+// ........ null-terminated string functions .........
+
+{TNT-WARN StrEnd}
+{TNT-WARN StrLen}
+{TNT-WARN StrLCopy}
+{TNT-WARN StrCopy}
+{TNT-WARN StrECopy}
+{TNT-WARN StrPLCopy}
+{TNT-WARN StrPCopy}
+{TNT-WARN StrLComp}
+{TNT-WARN AnsiStrLComp}
+{TNT-WARN StrComp}
+{TNT-WARN AnsiStrComp}
+{TNT-WARN StrLIComp}
+{TNT-WARN AnsiStrLIComp}
+{TNT-WARN StrIComp}
+{TNT-WARN AnsiStrIComp}
+{TNT-WARN StrLower}
+{TNT-WARN AnsiStrLower}
+{TNT-WARN StrUpper}
+{TNT-WARN AnsiStrUpper}
+{TNT-WARN StrPos}
+{TNT-WARN AnsiStrPos}
+{TNT-WARN StrScan}
+{TNT-WARN AnsiStrScan}
+{TNT-WARN StrRScan}
+{TNT-WARN AnsiStrRScan}
+{TNT-WARN StrLCat}
+{TNT-WARN StrCat}
+{TNT-WARN StrMove}
+{TNT-WARN StrPas}
+{TNT-WARN StrAlloc}
+{TNT-WARN StrBufSize}
+{TNT-WARN StrNew}
+{TNT-WARN StrDispose}
+
+{TNT-WARN AnsiExtractQuotedStr}
+{TNT-WARN AnsiLastChar}
+{TNT-WARN AnsiStrLastChar}
+{TNT-WARN QuotedStr}
+{TNT-WARN AnsiQuotedStr}
+{TNT-WARN AnsiDequotedStr}
+
+// ........ string functions .........
+
+{$IFNDEF FPC}
+{$IFNDEF COMPILER_9_UP}
+  //
+  // pre-Delphi 9 issues w/ WideFormatBuf, WideFmtStr and WideFormat
+  //
+
+  {$IFDEF COMPILER_7_UP}
+  type
+    PFormatSettings = ^TFormatSettings;
+  {$ENDIF}
+
+  // SysUtils.WideFormatBuf doesn't correctly handle numeric specifiers.
+  function Tnt_WideFormatBuf(var Buffer; BufLen: Cardinal; const FormatStr;
+    FmtLen: Cardinal; const Args: array of const): Cardinal; {$IFDEF COMPILER_7_UP} overload; {$ENDIF}
+
+  {$IFDEF COMPILER_7_UP}
+  function Tnt_WideFormatBuf(var Buffer; BufLen: Cardinal; const FormatStr;
+    FmtLen: Cardinal; const Args: array of const;
+      const FormatSettings: TFormatSettings): Cardinal; overload;
+  {$ENDIF}
+
+  // SysUtils.WideFmtStr doesn't handle string lengths > 4096.
+  procedure Tnt_WideFmtStr(var Result: WideString; const FormatStr: WideString;
+    const Args: array of const); {$IFDEF COMPILER_7_UP} overload; {$ENDIF}
+
+  {$IFDEF COMPILER_7_UP}
+  procedure Tnt_WideFmtStr(var Result: WideString; const FormatStr: WideString;
+    const Args: array of const; const FormatSettings: TFormatSettings); overload;
+  {$ENDIF}
+
+  {----------------------------------------------------------------------------------------
+    Without the FormatSettings parameter, Tnt_WideFormat is *NOT* necessary...
+      TntSystem.InstallTntSystemUpdates([tsFixWideFormat]);
+        will fix WideFormat as well as WideFmtStr.
+  ----------------------------------------------------------------------------------------}
+  function Tnt_WideFormat(const FormatStr: WideString; const Args: array of const): WideString; {$IFDEF COMPILER_7_UP} overload; {$ENDIF}
+
+  {$IFDEF COMPILER_7_UP}
+  function Tnt_WideFormat(const FormatStr: WideString; const Args: array of const;
+    const FormatSettings: TFormatSettings): WideString; overload;
+  {$ENDIF}
+
+{$ENDIF}
+{$ENDIF}
+
+{TNT-WARN WideUpperCase} // SysUtils.WideUpperCase is broken on Win9x for D6, D7, D9.
+function Tnt_WideUpperCase(const S: WideString): WideString;
+{TNT-WARN WideLowerCase} // SysUtils.WideLowerCase is broken on Win9x for D6, D7, D9.
+function Tnt_WideLowerCase(const S: WideString): WideString;
+
+function TntWideLastChar(const S: WideString): WideChar;
+
+{TNT-WARN StringReplace}
+{TNT-WARN WideStringReplace} // <-- WideStrUtils.WideStringReplace uses SysUtils.WideUpperCase which is broken on Win9x.
+function Tnt_WideStringReplace(const S, OldPattern, NewPattern: WideString;
+  Flags: TReplaceFlags; WholeWord: Boolean = False): WideString;
+
+{TNT-WARN AdjustLineBreaks}
+type TTntTextLineBreakStyle = (tlbsLF, tlbsCRLF, tlbsCR);
+function TntAdjustLineBreaksLength(const S: WideString; Style: TTntTextLineBreakStyle = tlbsCRLF): Integer;
+function TntAdjustLineBreaks(const S: WideString; Style: TTntTextLineBreakStyle = tlbsCRLF): WideString;
+
+{TNT-WARN WrapText}
+function WideWrapText(const Line, BreakStr: WideString; const BreakChars: TSysCharSet;
+  MaxCol: Integer): WideString; overload;
+function WideWrapText(const Line: WideString; MaxCol: Integer): WideString; overload;
+
+// ........ filename manipulation .........
+
+{TNT-WARN SameFileName}           // doesn't apply to Unicode filenames, use WideSameText
+{TNT-WARN AnsiCompareFileName}    // doesn't apply to Unicode filenames, use WideCompareText
+{TNT-WARN AnsiLowerCaseFileName}  // doesn't apply to Unicode filenames, use WideLowerCase
+{TNT-WARN AnsiUpperCaseFileName}  // doesn't apply to Unicode filenames, use WideUpperCase
+
+{TNT-WARN IncludeTrailingBackslash}
+function WideIncludeTrailingBackslash(const S: WideString): WideString;
+{TNT-WARN IncludeTrailingPathDelimiter}
+function WideIncludeTrailingPathDelimiter(const S: WideString): WideString;
+{TNT-WARN ExcludeTrailingBackslash}
+function WideExcludeTrailingBackslash(const S: WideString): WideString;
+{TNT-WARN ExcludeTrailingPathDelimiter}
+function WideExcludeTrailingPathDelimiter(const S: WideString): WideString;
+{TNT-WARN IsDelimiter}
+function WideIsDelimiter(const Delimiters, S: WideString; Index: Integer): Boolean;
+{TNT-WARN IsPathDelimiter}
+function WideIsPathDelimiter(const S: WideString; Index: Integer): Boolean;
+{TNT-WARN LastDelimiter}
+function WideLastDelimiter(const Delimiters, S: WideString): Integer;
+{TNT-WARN ChangeFileExt}
+function WideChangeFileExt(const FileName, Extension: WideString): WideString;
+{TNT-WARN ExtractFilePath}
+function WideExtractFilePath(const FileName: WideString): WideString;
+{TNT-WARN ExtractFileDir}
+function WideExtractFileDir(const FileName: WideString): WideString;
+{TNT-WARN ExtractFileDrive}
+function WideExtractFileDrive(const FileName: WideString): WideString;
+{TNT-WARN ExtractFileName}
+function WideExtractFileName(const FileName: WideString): WideString;
+{TNT-WARN ExtractFileExt}
+function WideExtractFileExt(const FileName: WideString): WideString;
+{TNT-WARN ExtractRelativePath}
+function WideExtractRelativePath(const BaseName, DestName: WideString): WideString;
+
+// ........ file management routines .........
+
+{TNT-WARN ExpandFileName}
+function WideExpandFileName(const FileName: WideString): WideString;
+{TNT-WARN ExtractShortPathName}
+function WideExtractShortPathName(const FileName: WideString): WideString;
+{TNT-WARN FileCreate}
+function WideFileCreate(const FileName: WideString): Integer;
+{TNT-WARN FileOpen}
+function WideFileOpen(const FileName: WideString; Mode: LongWord): Integer;
+{TNT-WARN FileAge}
+function WideFileAge(const FileName: WideString): Integer; overload;
+function WideFileAge(const FileName: WideString; out FileDateTime: TDateTime): Boolean; overload;
+{TNT-WARN DirectoryExists}
+function WideDirectoryExists(const Name: WideString): Boolean;
+{TNT-WARN FileExists}
+function WideFileExists(const Name: WideString): Boolean;
+{TNT-WARN FileGetAttr}
+function WideFileGetAttr(const FileName: WideString): Cardinal;
+{TNT-WARN FileSetAttr}
+function WideFileSetAttr(const FileName: WideString; Attr: Integer): Boolean;
+{TNT-WARN FileIsReadOnly}
+function WideFileIsReadOnly(const FileName: WideString): Boolean;
+{TNT-WARN FileSetReadOnly}
+function WideFileSetReadOnly(const FileName: WideString; ReadOnly: Boolean): Boolean;
+{TNT-WARN ForceDirectories}
+function WideForceDirectories(Dir: WideString): Boolean;
+{TNT-WARN FileSearch}
+function WideFileSearch(const Name, DirList: WideString): WideString;
+{TNT-WARN RenameFile}
+function WideRenameFile(const OldName, NewName: WideString): Boolean;
+{TNT-WARN DeleteFile}
+function WideDeleteFile(const FileName: WideString): Boolean;
+{TNT-WARN CopyFile}
+function WideCopyFile(const FromFile, ToFile: WideString; FailIfExists: Boolean): Boolean;
+
+
+{TNT-WARN TFileName}
+type
+  TWideFileName = type WideString;
+
+{TNT-WARN TSearchRec} // <-- FindFile - warning on TSearchRec is all that is necessary
+type
+  TSearchRecW = record
+    Time: Integer;
+    Size: Int64;
+    Attr: Integer;
+    Name: TWideFileName;
+    ExcludeAttr: Integer;
+    FindHandle: THandle;
+    FindData: TWin32FindDataW;
+  end;
+function WideFindFirst(const Path: WideString; Attr: Integer; var F: TSearchRecW): Integer;
+function WideFindNext(var F: TSearchRecW): Integer;
+procedure WideFindClose(var F: TSearchRecW);
+
+{TNT-WARN CreateDir}
+function WideCreateDir(const Dir: WideString): Boolean;
+{TNT-WARN RemoveDir}
+function WideRemoveDir(const Dir: WideString): Boolean;
+{TNT-WARN GetCurrentDir}
+function WideGetCurrentDir: WideString;
+{TNT-WARN SetCurrentDir}
+function WideSetCurrentDir(const Dir: WideString): Boolean;
+
+
+// ........ date/time functions .........
+
+{TNT-WARN TryStrToDateTime}
+function TntTryStrToDateTime(Str: WideString; out DateTime: TDateTime): Boolean;
+{TNT-WARN TryStrToDate}
+function TntTryStrToDate(Str: WideString; out DateTime: TDateTime): Boolean;
+{TNT-WARN TryStrToTime}
+function TntTryStrToTime(Str: WideString; out DateTime: TDateTime): Boolean;
+
+{ introduced }
+function ValidDateTimeStr(Str: WideString): Boolean;
+function ValidDateStr(Str: WideString): Boolean;
+function ValidTimeStr(Str: WideString): Boolean;
+
+{TNT-WARN StrToDateTime}
+function TntStrToDateTime(Str: WideString): TDateTime;
+{TNT-WARN StrToDate}
+function TntStrToDate(Str: WideString): TDateTime;
+{TNT-WARN StrToTime}
+function TntStrToTime(Str: WideString): TDateTime;
+{TNT-WARN StrToDateTimeDef}
+function TntStrToDateTimeDef(Str: WideString; Default: TDateTime): TDateTime;
+{TNT-WARN StrToDateDef}
+function TntStrToDateDef(Str: WideString; Default: TDateTime): TDateTime;
+{TNT-WARN StrToTimeDef}
+function TntStrToTimeDef(Str: WideString; Default: TDateTime): TDateTime;
+
+{TNT-WARN CurrToStr}
+{TNT-WARN CurrToStrF}
+function TntCurrToStr(Value: Currency; lpFormat: PCurrencyFmtW = nil): WideString;
+{TNT-WARN StrToCurr}
+function TntStrToCurr(const S: WideString): Currency;
+{TNT-WARN StrToCurrDef}
+function ValidCurrencyStr(const S: WideString): Boolean;
+function TntStrToCurrDef(const S: WideString; const Default: Currency): Currency;
+function GetDefaultCurrencyFmt: TCurrencyFmtW;
+
+// ........ misc functions .........
+
+{TNT-WARN GetLocaleStr}
+function WideGetLocaleStr(LocaleID: LCID; LocaleType: Integer; const Default: WideString): WideString;
+{TNT-WARN SysErrorMessage}
+function WideSysErrorMessage(ErrorCode: Integer): WideString;
+
+// ......... introduced .........
+
+function WideLibraryErrorMessage(const LibName: WideString; Dll: THandle; ErrorCode: Integer): WideString;
+
+const
+  CR = WideChar(#13);
+  LF = WideChar(#10);
+  CRLF = WideString(#13#10);
+  WideLineSeparator = WideChar($2028);
+
+var
+  Win32PlatformIsUnicode: Boolean;
+  Win32PlatformIsXP: Boolean;
+  Win32PlatformIs2003: Boolean;
+  Win32PlatformIsVista: Boolean;
+
+{$IFNDEF FPC}
+{$IFNDEF COMPILER_7_UP}
+function CheckWin32Version(AMajor: Integer; AMinor: Integer = 0): Boolean;
+{$ENDIF}
+{$ENDIF}
+function WinCheckH(RetVal: Cardinal): Cardinal;
+function WinCheckFileH(RetVal: Cardinal): Cardinal;
+function WinCheckP(RetVal: Pointer): Pointer;
+
+function WideGetModuleFileName(Instance: HModule): WideString;
+function WideSafeLoadLibrary(const Filename: Widestring;
+  ErrorMode: UINT = SEM_NOOPENFILEERRORBOX): HMODULE;
+{$IFNDEF FPC}
+function WideLoadPackage(const Name: Widestring): HMODULE;
+{$ENDIF}
+
+function IsWideCharUpper(WC: WideChar): Boolean;
+function IsWideCharLower(WC: WideChar): Boolean;
+function IsWideCharDigit(WC: WideChar): Boolean;
+function IsWideCharSpace(WC: WideChar): Boolean;
+function IsWideCharPunct(WC: WideChar): Boolean;
+function IsWideCharCntrl(WC: WideChar): Boolean;
+function IsWideCharBlank(WC: WideChar): Boolean;
+function IsWideCharXDigit(WC: WideChar): Boolean;
+function IsWideCharAlpha(WC: WideChar): Boolean;
+function IsWideCharAlphaNumeric(WC: WideChar): Boolean;
+
+function WideTextPos(const SubStr, S: WideString): Integer;
+
+function ExtractStringArrayStr(P: PWideChar): WideString;
+function ExtractStringFromStringArray(var P: PWideChar; Separator: WideChar = #0): WideString;
+function ExtractStringsFromStringArray(P: PWideChar; Separator: WideChar = #0): TWideStringDynArray;
+
+function IsWideCharMappableToAnsi(const WC: WideChar): Boolean;
+function IsWideStringMappableToAnsi(const WS: WideString): Boolean;
+function IsRTF(const Value: WideString): Boolean;
+
+function ENG_US_FloatToStr(Value: Extended): WideString;
+function ENG_US_StrToFloat(const S: WideString): Extended;
+
+//---------------------------------------------------------------------------------------------
+//                                 Tnt - Variants
+//---------------------------------------------------------------------------------------------
+
+// ........ Variants.pas has WideString versions of these functions .........
+{TNT-WARN VarToStr}
+{TNT-WARN VarToStrDef}
+
+var
+  _SettingChangeTime: Cardinal;
+
+implementation
+
+uses
+  ActiveX, ComObj, SysConst,
+  {$IFDEF COMPILER_9_UP} WideStrUtils, {$ENDIF} TntWideStrUtils,
+  TntSystem, TntFormatStrUtils;
+
+//---------------------------------------------------------------------------------------------
+//                                 Tnt - SysUtils
+//---------------------------------------------------------------------------------------------
+
+{$IFNDEF FPC}
+{$IFNDEF COMPILER_9_UP}
+
+  function _Tnt_WideFormatBuf(var Buffer; BufLen: Cardinal; const FormatStr;
+    FmtLen: Cardinal; const Args: array of const
+      {$IFDEF COMPILER_7_UP}; const FormatSettings: PFormatSettings {$ENDIF}): Cardinal;
+  var
+    OldFormat: WideString;
+    NewFormat: WideString;
+  begin
+    SetString(OldFormat, PWideChar(@FormatStr), FmtLen);
+    { The reason for this is that WideFormat doesn't correctly format floating point specifiers.
+      See QC#4254. }
+    NewFormat := ReplaceFloatingArgumentsInFormatString(OldFormat, Args{$IFDEF COMPILER_7_UP}, FormatSettings{$ENDIF});
+    {$IFDEF COMPILER_7_UP}
+    if FormatSettings <> nil then
+      Result := WideFormatBuf(Buffer, BufLen, Pointer(NewFormat)^,
+        Length(NewFormat), Args, FormatSettings^)
+    else
+    {$ENDIF}
+      Result := WideFormatBuf(Buffer, BufLen, Pointer(NewFormat)^,
+        Length(NewFormat), Args);
+  end;
+
+  function Tnt_WideFormatBuf(var Buffer; BufLen: Cardinal; const FormatStr;
+    FmtLen: Cardinal; const Args: array of const): Cardinal;
+  begin
+    Result := _Tnt_WideFormatBuf(Buffer, BufLen, FormatStr, FmtLen, Args{$IFDEF COMPILER_7_UP}, nil{$ENDIF});
+  end;
+
+  {$IFDEF COMPILER_7_UP}
+  function Tnt_WideFormatBuf(var Buffer; BufLen: Cardinal; const FormatStr;
+    FmtLen: Cardinal; const Args: array of const; const FormatSettings: TFormatSettings): Cardinal;
+  begin
+    Result := _Tnt_WideFormatBuf(Buffer, BufLen, FormatStr, FmtLen, Args, @FormatSettings);
+  end;
+  {$ENDIF}
+
+  procedure _Tnt_WideFmtStr(var Result: WideString; const FormatStr: WideString;
+    const Args: array of const{$IFDEF COMPILER_7_UP}; const FormatSettings: PFormatSettings{$ENDIF});
+  var
+    Len, BufLen: Integer;
+    Buffer: array[0..4095] of WideChar;
+  begin
+    BufLen := Length(Buffer); // Fixes buffer overwrite issue. (See QC #4703, #4744)
+    if Length(FormatStr) < (Length(Buffer) - (Length(Buffer) div 4)) then
+      Len := _Tnt_WideFormatBuf(Buffer, Length(Buffer) - 1, Pointer(FormatStr)^,
+        Length(FormatStr), Args{$IFDEF COMPILER_7_UP}, FormatSettings{$ENDIF})
+    else
+    begin
+      BufLen := Length(FormatStr);
+      Len := BufLen;
+    end;
+    if Len >= BufLen - 1 then
+    begin
+      while Len >= BufLen - 1 do
+      begin
+        Inc(BufLen, BufLen);
+        Result := '';          // prevent copying of existing data, for speed
+        SetLength(Result, BufLen);
+        Len := _Tnt_WideFormatBuf(Pointer(Result)^, BufLen - 1, Pointer(FormatStr)^,
+          Length(FormatStr), Args{$IFDEF COMPILER_7_UP}, FormatSettings{$ENDIF});
+      end;
+      SetLength(Result, Len);
+    end
+    else
+      SetString(Result, Buffer, Len);
+  end;
+
+  procedure Tnt_WideFmtStr(var Result: WideString; const FormatStr: WideString;
+    const Args: array of const);
+  begin
+    _Tnt_WideFmtStr(Result, FormatStr, Args{$IFDEF COMPILER_7_UP}, nil{$ENDIF});
+  end;
+
+  {$IFDEF COMPILER_7_UP}
+  procedure Tnt_WideFmtStr(var Result: WideString; const FormatStr: WideString;
+    const Args: array of const; const FormatSettings: TFormatSettings);
+  begin
+    _Tnt_WideFmtStr(Result, FormatStr, Args, @FormatSettings);
+  end;
+  {$ENDIF}
+
+  {----------------------------------------------------------------------------------------
+    Without the FormatSettings parameter, Tnt_WideFormat is *NOT* necessary...
+      TntSystem.InstallTntSystemUpdates([tsFixWideFormat]);
+        will fix WideFormat as well as WideFmtStr.
+  ----------------------------------------------------------------------------------------}
+  function Tnt_WideFormat(const FormatStr: WideString; const Args: array of const): WideString;
+  begin
+    Tnt_WideFmtStr(Result, FormatStr, Args);
+  end;
+
+  {$IFDEF COMPILER_7_UP}
+  function Tnt_WideFormat(const FormatStr: WideString; const Args: array of const;
+    const FormatSettings: TFormatSettings): WideString;
+  begin
+    Tnt_WideFmtStr(Result, FormatStr, Args, FormatSettings);
+  end;
+  {$ENDIF}
+
+{$ENDIF}
+{$ENDIF FPC}
+
+function Tnt_WideUpperCase(const S: WideString): WideString;
+begin
+  {$IFNDEF FPC}
+  {$IFNDEF COMPILER_10_UP}
+    {$DEFINE WIDEUPPERCASE_BROKEN}
+  {$ENDIF}
+  {$ENDIF}
+  {$IFDEF WIDEUPPERCASE_BROKEN}
+  { SysUtils.WideUpperCase is broken for Win9x. }
+  Result := S;
+  if Length(Result) > 0 then
+    Tnt_CharUpperBuffW(PWideChar(Result), Length(Result));
+  {$ELSE}
+  Result := SysUtils.WideUpperCase{TNT-ALLOW WideUpperCase}(S);
+  {$ENDIF}
+end;
+
+function Tnt_WideLowerCase(const S: WideString): WideString;
+begin
+  {$IFNDEF FPC}
+  {$IFNDEF COMPILER_10_UP}
+    {$DEFINE WIDELOWERCASE_BROKEN}
+  {$ENDIF}
+  {$ENDIF}
+  {$IFDEF WIDELOWERCASE_BROKEN}
+  { SysUtils.WideLowerCase is broken for Win9x. }
+  Result := S;
+  if Length(Result) > 0 then
+    Tnt_CharLowerBuffW(PWideChar(Result), Length(Result));
+  {$ELSE}
+  Result := SysUtils.WideLowerCase{TNT-ALLOW WideLowerCase}(S);
+  {$ENDIF}
+end;
+
+function TntWideLastChar(const S: WideString): WideChar;
+var
+  P: PWideChar;
+begin
+  P := WideLastChar(S);
+  if P = nil then
+    Result := #0
+  else
+    Result := P^;
+end;
+
+function Tnt_WideStringReplace(const S, OldPattern, NewPattern: WideString;
+  Flags: TReplaceFlags; WholeWord: Boolean = False): WideString;
+
+  function IsWordSeparator(WC: WideChar): Boolean;
+  begin
+    Result := (WC = WideChar(#0))
+           or IsWideCharSpace(WC)
+           or IsWideCharPunct(WC);
+  end;
+
+var
+  SearchStr, Patt, NewStr: WideString;
+  Offset: Integer;
+  PrevChar, NextChar: WideChar;
+begin
+  if rfIgnoreCase in Flags then
+  begin
+    SearchStr := Tnt_WideUpperCase(S);
+    Patt := Tnt_WideUpperCase(OldPattern);
+  end else
+  begin
+    SearchStr := S;
+    Patt := OldPattern;
+  end;
+  NewStr := S;
+  Result := '';
+  while SearchStr <> '' do
+  begin
+    Offset := Pos(Patt, SearchStr);
+    if Offset = 0 then
+    begin
+      Result := Result + NewStr;
+      Break;
+    end; // done
+
+    if (WholeWord) then
+    begin
+      if (Offset = 1) then
+        PrevChar := TntWideLastChar(Result)
+      else
+        PrevChar := NewStr[Offset - 1];
+
+      if Offset + Length(OldPattern) <= Length(NewStr) then
+        NextChar := NewStr[Offset + Length(OldPattern)]
+      else
+        NextChar := WideChar(#0);
+
+      if (not IsWordSeparator(PrevChar))
+      or (not IsWordSeparator(NextChar)) then
+      begin
+        Result := Result + Copy(NewStr, 1, Offset + Length(OldPattern) - 1);
+        NewStr := Copy(NewStr, Offset + Length(OldPattern), MaxInt);
+        SearchStr := Copy(SearchStr, Offset + Length(Patt), MaxInt);
+        continue;
+      end;
+    end;
+
+    Result := Result + Copy(NewStr, 1, Offset - 1) + NewPattern;
+    NewStr := Copy(NewStr, Offset + Length(OldPattern), MaxInt);
+    if not (rfReplaceAll in Flags) then
+    begin
+      Result := Result + NewStr;
+      Break;
+    end;
+    SearchStr := Copy(SearchStr, Offset + Length(Patt), MaxInt);
+  end;
+end;
+
+function TntAdjustLineBreaksLength(const S: WideString; Style: TTntTextLineBreakStyle = tlbsCRLF): Integer;
+var
+  Source, SourceEnd: PWideChar;
+begin
+  Source := Pointer(S);
+  SourceEnd := Source + Length(S);
+  Result := Length(S);
+  while Source < SourceEnd do
+  begin
+    case Source^ of
+      #10, WideLineSeparator:
+        if Style = tlbsCRLF then
+          Inc(Result);
+      #13:
+        if Style = tlbsCRLF then
+          if Source[1] = #10 then
+            Inc(Source)
+          else
+            Inc(Result)
+        else
+          if Source[1] = #10 then
+            Dec(Result);
+    end;
+    Inc(Source);
+  end;
+end;
+
+function TntAdjustLineBreaks(const S: WideString; Style: TTntTextLineBreakStyle = tlbsCRLF): WideString;
+var
+  Source, SourceEnd, Dest: PWideChar;
+  DestLen: Integer;
+begin
+  Source := Pointer(S);
+  SourceEnd := Source + Length(S);
+  DestLen := TntAdjustLineBreaksLength(S, Style);
+  SetString(Result, nil, DestLen);
+  Dest := Pointer(Result);
+  while Source < SourceEnd do begin
+    case Source^ of
+      #10, WideLineSeparator:
+        begin
+          if Style in [tlbsCRLF, tlbsCR] then
+          begin
+            Dest^ := #13;
+            Inc(Dest);
+          end;
+          if Style in [tlbsCRLF, tlbsLF] then
+          begin
+            Dest^ := #10;
+            Inc(Dest);
+          end;
+          Inc(Source);
+        end;
+      #13:
+        begin
+          if Style in [tlbsCRLF, tlbsCR] then
+          begin
+            Dest^ := #13;
+            Inc(Dest);
+          end;
+          if Style in [tlbsCRLF, tlbsLF] then
+          begin
+            Dest^ := #10;
+            Inc(Dest);
+          end;
+          Inc(Source);
+          if Source^ = #10 then Inc(Source);
+        end;
+    else
+      Dest^ := Source^;
+      Inc(Dest);
+      Inc(Source);
+    end;
+  end;
+end;
+
+function WideWrapText(const Line, BreakStr: WideString; const BreakChars: TSysCharSet;
+  MaxCol: Integer): WideString;
+
+  function WideCharIn(C: WideChar; SysCharSet: TSysCharSet): Boolean;
+  begin
+    Result := (C <= High(AnsiChar)) and (AnsiChar(C) in SysCharSet);
+  end;
+
+const
+  QuoteChars = ['''', '"'];
+var
+  Col, Pos: Integer;
+  LinePos, LineLen: Integer;
+  BreakLen, BreakPos: Integer;
+  QuoteChar, CurChar: WideChar;
+  ExistingBreak: Boolean;
+begin
+  Col := 1;
+  Pos := 1;
+  LinePos := 1;
+  BreakPos := 0;
+  QuoteChar := ' ';
+  ExistingBreak := False;
+  LineLen := Length(Line);
+  BreakLen := Length(BreakStr);
+  Result := '';
+  while Pos <= LineLen do
+  begin
+    CurChar := Line[Pos];
+    if CurChar = BreakStr[1] then
+    begin
+      if QuoteChar = ' ' then
+      begin
+        ExistingBreak := WideSameText(BreakStr, Copy(Line, Pos, BreakLen));
+        if ExistingBreak then
+        begin
+          Inc(Pos, BreakLen-1);
+          BreakPos := Pos;
+        end;
+      end
+    end
+    else if WideCharIn(CurChar, BreakChars) then
+    begin
+      if QuoteChar = ' ' then BreakPos := Pos
+    end
+    else if WideCharIn(CurChar, QuoteChars) then
+    begin
+      if CurChar = QuoteChar then
+        QuoteChar := ' '
+      else if QuoteChar = ' ' then
+        QuoteChar := CurChar;
+    end;
+    Inc(Pos);
+    Inc(Col);
+    if not (WideCharIn(QuoteChar, QuoteChars)) and (ExistingBreak or
+      ((Col > MaxCol) and (BreakPos > LinePos))) then
+    begin
+      Col := Pos - BreakPos;
+      Result := Result + Copy(Line, LinePos, BreakPos - LinePos + 1);
+      if not (WideCharIn(CurChar, QuoteChars)) then
+        while Pos <= LineLen do
+        begin
+          if WideCharIn(Line[Pos], BreakChars) then
+            Inc(Pos)
+          else if Copy(Line, Pos, Length(sLineBreak)) = sLineBreak then
+            Inc(Pos, Length(sLineBreak))
+          else
+            break;
+        end;
+      if not ExistingBreak and (Pos < LineLen) then
+        Result := Result + BreakStr;
+      Inc(BreakPos);
+      LinePos := BreakPos;
+      ExistingBreak := False;
+    end;
+  end;
+  Result := Result + Copy(Line, LinePos, MaxInt);
+end;
+
+function WideWrapText(const Line: WideString; MaxCol: Integer): WideString;
+begin
+  Result := WideWrapText(Line, sLineBreak, [' ', '-', #9], MaxCol); { do not localize }
+end;
+
+function WideIncludeTrailingBackslash(const S: WideString): WideString;
+begin
+  Result := WideIncludeTrailingPathDelimiter(S);
+end;
+
+function WideIncludeTrailingPathDelimiter(const S: WideString): WideString;
+begin
+  Result := S;
+  if not WideIsPathDelimiter(Result, Length(Result)) then Result := Result + PathDelim;
+end;
+
+function WideExcludeTrailingBackslash(const S: WideString): WideString;
+begin
+  Result := WideExcludeTrailingPathDelimiter(S);
+end;
+
+function WideExcludeTrailingPathDelimiter(const S: WideString): WideString;
+begin
+  Result := S;
+  if WideIsPathDelimiter(Result, Length(Result)) then
+    SetLength(Result, Length(Result)-1);
+end;
+
+function WideIsDelimiter(const Delimiters, S: WideString; Index: Integer): Boolean;
+begin
+  Result := False;
+  if (Index <= 0) or (Index > Length(S)) then exit;
+  Result := WStrScan(PWideChar(Delimiters), S[Index]) <> nil;
+end;
+
+function WideIsPathDelimiter(const S: WideString; Index: Integer): Boolean;
+begin
+  Result := (Index > 0) and (Index <= Length(S)) and (S[Index] = PathDelim);
+end;
+
+function WideLastDelimiter(const Delimiters, S: WideString): Integer;
+var
+  P: PWideChar;
+begin
+  Result := Length(S);
+  P := PWideChar(Delimiters);
+  while Result > 0 do
+  begin
+    if (S[Result] <> #0) and (WStrScan(P, S[Result]) <> nil) then
+      Exit;
+    Dec(Result);
+  end;
+end;
+
+function WideChangeFileExt(const FileName, Extension: WideString): WideString;
+var
+  I: Integer;
+begin
+  I := WideLastDelimiter('.\:',Filename);
+  if (I = 0) or (FileName[I] <> '.') then I := MaxInt;
+  Result := Copy(FileName, 1, I - 1) + Extension;
+end;
+
+function WideExtractFilePath(const FileName: WideString): WideString;
+var
+  I: Integer;
+begin
+  I := WideLastDelimiter('\:', FileName);
+  Result := Copy(FileName, 1, I);
+end;
+
+function WideExtractFileDir(const FileName: WideString): WideString;
+var
+  I: Integer;
+begin
+  I := WideLastDelimiter(DriveDelim + PathDelim,Filename);
+  if (I > 1) and (FileName[I] = PathDelim) and
+    (not (FileName[I - 1] in [WideChar(PathDelim), WideChar(DriveDelim)])) then Dec(I);
+  Result := Copy(FileName, 1, I);
+end;
+
+function WideExtractFileDrive(const FileName: WideString): WideString;
+var
+  I, J: Integer;
+begin
+  if (Length(FileName) >= 2) and (FileName[2] = DriveDelim) then
+    Result := Copy(FileName, 1, 2)
+  else if (Length(FileName) >= 2) and (FileName[1] = PathDelim) and
+    (FileName[2] = PathDelim) then
+  begin
+    J := 0;
+    I := 3;
+    While (I < Length(FileName)) and (J < 2) do
+    begin
+      if FileName[I] = PathDelim then Inc(J);
+      if J < 2 then Inc(I);
+    end;
+    if FileName[I] = PathDelim then Dec(I);
+    Result := Copy(FileName, 1, I);
+  end else Result := '';
+end;
+
+function WideExtractFileName(const FileName: WideString): WideString;
+var
+  I: Integer;
+begin
+  I := WideLastDelimiter('\:', FileName);
+  Result := Copy(FileName, I + 1, MaxInt);
+end;
+
+function WideExtractFileExt(const FileName: WideString): WideString;
+var
+  I: Integer;
+begin
+  I := WideLastDelimiter('.\:', FileName);
+  if (I > 0) and (FileName[I] = '.') then
+    Result := Copy(FileName, I, MaxInt) else
+    Result := '';
+end;
+
+function WideExtractRelativePath(const BaseName, DestName: WideString): WideString;
+var
+  BasePath, DestPath: WideString;
+  BaseLead, DestLead: PWideChar;
+  BasePtr, DestPtr: PWideChar;
+
+  function WideExtractFilePathNoDrive(const FileName: WideString): WideString;
+  begin
+    Result := WideExtractFilePath(FileName);
+    Delete(Result, 1, Length(WideExtractFileDrive(FileName)));
+  end;
+
+  function Next(var Lead: PWideChar): PWideChar;
+  begin
+    Result := Lead;
+    if Result = nil then Exit;
+    Lead := WStrScan(Lead, PathDelim);
+    if Lead <> nil then
+    begin
+      Lead^ := #0;
+      Inc(Lead);
+    end;
+  end;
+
+begin
+  if WideSameText(WideExtractFileDrive(BaseName), WideExtractFileDrive(DestName)) then
+  begin
+    BasePath := WideExtractFilePathNoDrive(BaseName);
+    DestPath := WideExtractFilePathNoDrive(DestName);
+    BaseLead := Pointer(BasePath);
+    BasePtr := Next(BaseLead);
+    DestLead := Pointer(DestPath);
+    DestPtr := Next(DestLead);
+    while (BasePtr <> nil) and (DestPtr <> nil) and WideSameText(BasePtr, DestPtr) do
+    begin
+      BasePtr := Next(BaseLead);
+      DestPtr := Next(DestLead);
+    end;
+    Result := '';
+    while BaseLead <> nil do
+    begin
+      Result := Result + '..' + PathDelim;             { Do not localize }
+      Next(BaseLead);
+    end;
+    if (DestPtr <> nil) and (DestPtr^ <> #0) then
+      Result := Result + DestPtr + PathDelim;
+    if DestLead <> nil then
+      Result := Result + DestLead;     // destlead already has a trailing backslash
+    Result := Result + WideExtractFileName(DestName);
+  end
+  else
+    Result := DestName;
+end;
+
+function WideExpandFileName(const FileName: WideString): WideString;
+var
+  FName: PWideChar;
+  Buffer: array[0..MAX_PATH - 1] of WideChar;
+begin
+  SetString(Result, Buffer, Tnt_GetFullPathNameW(PWideChar(FileName), MAX_PATH, Buffer, FName));
+end;
+
+function WideExtractShortPathName(const FileName: WideString): WideString;
+var
+  Buffer: array[0..MAX_PATH - 1] of WideChar;
+begin
+  SetString(Result, Buffer, Tnt_GetShortPathNameW(PWideChar(FileName), Buffer, MAX_PATH));
+end;
+
+function WideFileCreate(const FileName: WideString): Integer;
+begin
+  Result := Integer(Tnt_CreateFileW(PWideChar(FileName), GENERIC_READ or GENERIC_WRITE,
+    0, nil, CREATE_ALWAYS, FILE_ATTRIBUTE_NORMAL, 0))
+end;
+
+function WideFileOpen(const FileName: WideString; Mode: LongWord): Integer;
+const
+  AccessMode: array[0..2] of LongWord = (
+    GENERIC_READ,
+    GENERIC_WRITE,
+    GENERIC_READ or GENERIC_WRITE);
+  ShareMode: array[0..4] of LongWord = (
+    0,
+    0,
+    FILE_SHARE_READ,
+    FILE_SHARE_WRITE,
+    FILE_SHARE_READ or FILE_SHARE_WRITE);
+begin
+  Result := Integer(Tnt_CreateFileW(PWideChar(FileName), AccessMode[Mode and 3],
+    ShareMode[(Mode and $F0) shr 4], nil, OPEN_EXISTING,
+      FILE_ATTRIBUTE_NORMAL, 0));
+end;
+
+function WideFileAge(const FileName: WideString): Integer;
+var
+  Handle: THandle;
+  FindData: TWin32FindDataW;
+  LocalFileTime: TFileTime;
+begin
+  Handle := Tnt_FindFirstFileW(PWideChar(FileName), FindData);
+  if Handle <> INVALID_HANDLE_VALUE then
+  begin
+    Windows.FindClose(Handle);
+    if (FindData.dwFileAttributes and FILE_ATTRIBUTE_DIRECTORY) = 0 then
+    begin
+      FileTimeToLocalFileTime(FindData.ftLastWriteTime, LocalFileTime);
+      if FileTimeToDosDateTime(LocalFileTime, LongRec(Result).Hi, LongRec(Result).Lo) then
+        Exit
+    end;
+  end;
+  Result := -1;
+end;
+
+function WideFileAge(const FileName: WideString; out FileDateTime: TDateTime): Boolean;
+var
+  Handle: THandle;
+  FindData: TWin32FindDataW;
+  LSystemTime: TSystemTime;
+  LocalFileTime: TFileTime;
+begin
+  Result := False;
+  Handle := Tnt_FindFirstFileW(PWideChar(FileName), FindData);
+  if Handle <> INVALID_HANDLE_VALUE then
+  begin
+    Windows.FindClose(Handle);
+    if (FindData.dwFileAttributes and FILE_ATTRIBUTE_DIRECTORY) = 0 then
+    begin
+      Result := True;
+      FileTimeToLocalFileTime(FindData.ftLastWriteTime, LocalFileTime);
+      FileTimeToSystemTime(LocalFileTime, LSystemTime);
+      with LSystemTime do
+        FileDateTime := EncodeDate(wYear, wMonth, wDay) +
+          EncodeTime(wHour, wMinute, wSecond, wMilliSeconds);
+    end;
+  end;
+end;
+
+function WideDirectoryExists(const Name: WideString): Boolean;
+var
+  Code: Cardinal;
+begin
+  Code := WideFileGetAttr(Name);
+  Result := (Code <> INVALID_FILE_ATTRIBUTES) and ((FILE_ATTRIBUTE_DIRECTORY and Code) <> 0);
+end;
+
+function WideFileExists(const Name: WideString): Boolean;
+var
+  Code: Cardinal;
+begin
+  Code := WideFileGetAttr(Name);
+  Result := (Code <> INVALID_FILE_ATTRIBUTES) and ((FILE_ATTRIBUTE_DIRECTORY and Code) = 0);
+end;
+
+function WideFileGetAttr(const FileName: WideString): Cardinal;
+begin
+  Result := Tnt_GetFileAttributesW(PWideChar(FileName));
+end;
+
+function WideFileSetAttr(const FileName: WideString; Attr: Integer): Boolean;
+begin
+  Result := Tnt_SetFileAttributesW(PWideChar(FileName), Attr)
+end;
+
+function WideFileIsReadOnly(const FileName: WideString): Boolean;
+begin
+  Result := (Tnt_GetFileAttributesW(PWideChar(FileName)) and faReadOnly) <> 0;
+end;
+
+function WideFileSetReadOnly(const FileName: WideString; ReadOnly: Boolean): Boolean;
+var
+  Flags: Integer;
+begin
+  Result := False;
+  Flags := Tnt_GetFileAttributesW(PWideChar(FileName));
+  if Flags = -1 then Exit;
+  if ReadOnly then
+    Flags := Flags or faReadOnly
+  else
+    Flags := Flags and not faReadOnly;
+  Result := Tnt_SetFileAttributesW(PWideChar(FileName), Flags);
+end;
+
+function WideForceDirectories(Dir: WideString): Boolean;
+begin
+  Result := True;
+  if Length(Dir) = 0 then
+    raise ETntGeneralError.Create(
+      {$IFNDEF FPC} SCannotCreateDir {$ELSE} SCannotCreateEmptyDir {$ENDIF});
+  Dir := WideExcludeTrailingBackslash(Dir);
+  if (Length(Dir) < 3) or WideDirectoryExists(Dir)
+    or (WideExtractFilePath(Dir) = Dir) then Exit; // avoid 'xyz:\' problem.
+  Result := WideForceDirectories(WideExtractFilePath(Dir));
+  if Result then
+    Result := Tnt_CreateDirectoryW(PWideChar(Dir), nil)
+end;
+
+function WideFileSearch(const Name, DirList: WideString): WideString;
+var
+  I, P, L: Integer;
+  C: WideChar;
+begin
+  Result := Name;
+  P := 1;
+  L := Length(DirList);
+  while True do
+  begin
+    if WideFileExists(Result) then Exit;
+    while (P <= L) and (DirList[P] = PathSep) do Inc(P);
+    if P > L then Break;
+    I := P;
+    while (P <= L) and (DirList[P] <> PathSep) do
+      Inc(P);
+    Result := Copy(DirList, I, P - I);
+    C := TntWideLastChar(Result);
+    if (C <> DriveDelim) and (C <> PathDelim) then
+      Result := Result + PathDelim;
+    Result := Result + Name;
+  end;
+  Result := '';
+end;
+
+function WideRenameFile(const OldName, NewName: WideString): Boolean;
+begin
+  Result := Tnt_MoveFileW(PWideChar(OldName), PWideChar(NewName))
+end;
+
+function WideDeleteFile(const FileName: WideString): Boolean;
+begin
+  Result := Tnt_DeleteFileW(PWideChar(FileName))
+end;
+
+function WideCopyFile(const FromFile, ToFile: WideString; FailIfExists: Boolean): Boolean;
+begin
+  Result := Tnt_CopyFileW(PWideChar(FromFile), PWideChar(ToFile), FailIfExists)
+end;
+
+function _WideFindMatchingFile(var F: TSearchRecW): Integer;
+var
+  LocalFileTime: TFileTime;
+begin
+  with F do
+  begin
+    while FindData.dwFileAttributes and ExcludeAttr <> 0 do
+      if not Tnt_FindNextFileW(FindHandle, FindData) then
+      begin
+        Result := GetLastError;
+        Exit;
+      end;
+    FileTimeToLocalFileTime(FindData.ftLastWriteTime, LocalFileTime);
+    FileTimeToDosDateTime(LocalFileTime, LongRec(Time).Hi, LongRec(Time).Lo);
+    Size := (Int64(FindData.nFileSizeHigh) shl 32) + FindData.nFileSizeLow;
+    Attr := FindData.dwFileAttributes;
+    Name := FindData.cFileName;
+  end;
+  Result := 0;
+end;
+
+function WideFindFirst(const Path: WideString; Attr: Integer; var F: TSearchRecW): Integer;
+const
+  faSpecial = faHidden or faSysFile {$IFNDEF COMPILER_9_UP} or faVolumeID {$ENDIF} or faDirectory;
+begin
+  F.ExcludeAttr := not Attr and faSpecial;
+  F.FindHandle := Tnt_FindFirstFileW(PWideChar(Path), F.FindData);
+  if F.FindHandle <> INVALID_HANDLE_VALUE then
+  begin
+    Result := _WideFindMatchingFile(F);
+    if Result <> 0 then WideFindClose(F);
+  end else
+    Result := GetLastError;
+end;
+
+function WideFindNext(var F: TSearchRecW): Integer;
+begin
+  if Tnt_FindNextFileW(F.FindHandle, F.FindData) then
+    Result := _WideFindMatchingFile(F) else
+    Result := GetLastError;
+end;
+
+procedure WideFindClose(var F: TSearchRecW);
+begin
+  if F.FindHandle <> INVALID_HANDLE_VALUE then
+  begin
+    Windows.FindClose(F.FindHandle);
+    F.FindHandle := INVALID_HANDLE_VALUE;
+  end;
+end;
+
+function WideCreateDir(const Dir: WideString): Boolean;
+begin
+  Result := Tnt_CreateDirectoryW(PWideChar(Dir), nil);
+end;
+
+function WideRemoveDir(const Dir: WideString): Boolean;
+begin
+  Result := Tnt_RemoveDirectoryW(PWideChar(Dir));
+end;
+
+function WideGetCurrentDir: WideString;
+begin
+  SetLength(Result, MAX_PATH);
+  Tnt_GetCurrentDirectoryW(MAX_PATH, PWideChar(Result));
+  Result := PWideChar(Result);
+end;
+
+function WideSetCurrentDir(const Dir: WideString): Boolean;
+begin
+  Result := Tnt_SetCurrentDirectoryW(PWideChar(Dir));
+end;
+
+//=============================================================================================
+//==  DATE/TIME STRING PARSING ================================================================
+//=============================================================================================
+
+{$IFDEF FPC}
+const
+  VAR_TIMEVALUEONLY = 1;
+  VAR_DATEVALUEONLY = 2;
+{$ENDIF}
+
+function _IntTryStrToDateTime(Str: WideString; Flags: Integer; out DateTime: TDateTime): HResult;
+begin
+  Result := VarDateFromStr(
+      {$IFDEF FPC} POLECHAR(Str) {$ELSE} Str {$ENDIF},
+      GetThreadLocale, Flags, Double(DateTime));
+  if (not Succeeded(Result)) then begin
+    if (Flags = VAR_TIMEVALUEONLY)
+    and SysUtils.TryStrToTime{TNT-ALLOW TryStrToTime}(Str, DateTime) then
+      Result := S_OK // SysUtils seems confident (works for date = "dd.MM.yy" and time = "H.mm.ss")
+    else if (Flags = VAR_DATEVALUEONLY)
+    and SysUtils.TryStrToDate{TNT-ALLOW TryStrToDate}(Str, DateTime) then
+      Result := S_OK // SysUtils seems confident
+    else if (Flags = 0)
+    and SysUtils.TryStrToDateTime{TNT-ALLOW TryStrToDateTime}(Str, DateTime) then
+      Result := S_OK // SysUtils seems confident
+  end;
+end;
+
+function TntTryStrToDateTime(Str: WideString; out DateTime: TDateTime): Boolean;
+begin
+  Result := Succeeded(_IntTryStrToDateTime(Str, 0, DateTime));
+end;
+
+function TntTryStrToDate(Str: WideString; out DateTime: TDateTime): Boolean;
+begin
+  Result := Succeeded(_IntTryStrToDateTime(Str, VAR_DATEVALUEONLY, DateTime));
+end;
+
+function TntTryStrToTime(Str: WideString; out DateTime: TDateTime): Boolean;
+begin
+  Result := Succeeded(_IntTryStrToDateTime(Str, VAR_TIMEVALUEONLY, DateTime));
+end;
+
+function ValidDateTimeStr(Str: WideString): Boolean;
+var
+  Temp: TDateTime;
+begin
+  Result := Succeeded(_IntTryStrToDateTime(Str, 0, Temp));
+end;
+
+function ValidDateStr(Str: WideString): Boolean;
+var
+  Temp: TDateTime;
+begin
+  Result := Succeeded(_IntTryStrToDateTime(Str, VAR_DATEVALUEONLY, Temp));
+end;
+
+function ValidTimeStr(Str: WideString): Boolean;
+var
+  Temp: TDateTime;
+begin
+  Result := Succeeded(_IntTryStrToDateTime(Str, VAR_TIMEVALUEONLY, Temp));
+end;
+
+function TntStrToDateTimeDef(Str: WideString; Default: TDateTime): TDateTime;
+begin
+  if not TntTryStrToDateTime(Str, Result) then
+    Result := Default;
+end;
+
+function TntStrToDateDef(Str: WideString; Default: TDateTime): TDateTime;
+begin
+  if not TntTryStrToDate(Str, Result) then
+    Result := Default;
+end;
+
+function TntStrToTimeDef(Str: WideString; Default: TDateTime): TDateTime;
+begin
+  if not TntTryStrToTime(Str, Result) then
+    Result := Default;
+end;
+
+function _IntStrToDateTime(Str: WideString; Flags: Integer; ErrorFormatStr: WideString): TDateTime;
+begin
+  try
+    OleCheck(_IntTryStrToDateTime(Str, Flags, Result));
+  except
+    on E: Exception do begin
+      E.Message := E.Message + CRLF + WideFormat(ErrorFormatStr, [Str]);
+      raise EConvertError.Create(E.Message);
+    end;
+  end;
+end;
+
+function TntStrToDateTime(Str: WideString): TDateTime;
+begin
+  Result := _IntStrToDateTime(Str, 0, SInvalidDateTime);
+end;
+
+function TntStrToDate(Str: WideString): TDateTime;
+begin
+  Result := _IntStrToDateTime(Str, VAR_DATEVALUEONLY,
+      {$IFNDEF FPC} SInvalidDate {$ELSE} SInvalidDateTime {$ENDIF});
+end;
+
+function TntStrToTime(Str: WideString): TDateTime;
+begin
+  Result := _IntStrToDateTime(Str, VAR_TIMEVALUEONLY,
+      {$IFNDEF FPC} SInvalidTime {$ELSE} SInvalidDateTime {$ENDIF});
+end;
+
+//=============================================================================================
+//==  CURRENCY STRING PARSING =================================================================
+//=============================================================================================
+
+function TntCurrToStr(Value: Currency; lpFormat: PCurrencyFmtW = nil): WideString;
+const
+  MAX_BUFF_SIZE = 64; // can a currency string actually be larger?
+var
+  ValueStr: WideString;
+begin
+  // format lpValue using ENG-US settings
+  ValueStr := ENG_US_FloatToStr(Value);
+  // get currency format
+  SetLength(Result, MAX_BUFF_SIZE);
+  if 0 = Tnt_GetCurrencyFormatW(GetThreadLocale, 0, PWideChar(ValueStr),
+    lpFormat, PWideChar(Result), Length(Result))
+  then begin
+    RaiseLastOSError;
+  end;
+  Result := PWideChar(Result);
+end;
+
+function TntStrToCurr(const S: WideString): Currency;
+begin
+  try
+    OleCheck(VarCyFromStr(
+        {$IFDEF FPC} POLECHAR(S) {$ELSE} S {$ENDIF},
+        GetThreadLocale, 0, Result));
+  except
+    on E: Exception do begin
+      E.Message := E.Message + CRLF + WideFormat(SInvalidCurrency, [S]);
+      raise EConvertError.Create(E.Message);
+    end;
+  end;
+end;
+
+function ValidCurrencyStr(const S: WideString): Boolean;
+var
+  Dummy: Currency;
+begin
+  Result := Succeeded(VarCyFromStr(
+      {$IFDEF FPC} POLECHAR(S) {$ELSE} S {$ENDIF},
+      GetThreadLocale, 0, Dummy));
+end;
+
+function TntStrToCurrDef(const S: WideString; const Default: Currency): Currency;
+begin
+  if not Succeeded(VarCyFromStr(
+      {$IFDEF FPC} POLECHAR(S) {$ELSE} S {$ENDIF},
+      GetThreadLocale, 0, Result)) then
+    Result := Default;
+end;
+
+threadvar
+  Currency_DecimalSep: WideString;
+  Currency_ThousandSep: WideString;
+  Currency_CurrencySymbol: WideString;
+
+function GetDefaultCurrencyFmt: TCurrencyFmtW;
+begin
+  ZeroMemory(@Result, SizeOf(Result));
+  Result.NumDigits := StrToIntDef(WideGetLocaleStr(GetThreadLocale, LOCALE_ICURRDIGITS, '2'), 2);
+  Result.LeadingZero := StrToIntDef(WideGetLocaleStr(GetThreadLocale, LOCALE_ILZERO, '1'), 1);
+  Result.Grouping := StrToIntDef(Copy(WideGetLocaleStr(GetThreadLocale, LOCALE_SMONGROUPING, '3;0'), 1, 1), 3);
+  Currency_DecimalSep := WideGetLocaleStr(GetThreadLocale, LOCALE_SMONDECIMALSEP, '.');
+  Result.lpDecimalSep := {$IFNDEF FPC} PWideChar(Currency_DecimalSep)
+                         {$ELSE}       LPTSTR(PWideChar(Currency_DecimalSep)) {$ENDIF};
+  Currency_ThousandSep := WideGetLocaleStr(GetThreadLocale, LOCALE_SMONTHOUSANDSEP, ',');
+  Result.lpThousandSep := {$IFNDEF FPC} PWideChar(Currency_ThousandSep)
+                          {$ELSE}       LPTSTR(PWideChar(Currency_ThousandSep)) {$ENDIF};
+  Result.NegativeOrder := StrToIntDef(WideGetLocaleStr(GetThreadLocale, LOCALE_INEGCURR, '0'), 0);
+  Result.PositiveOrder := StrToIntDef(WideGetLocaleStr(GetThreadLocale, LOCALE_ICURRENCY, '0'), 0);
+  Currency_CurrencySymbol := WideGetLocaleStr(GetThreadLocale, LOCALE_SCURRENCY, '');
+  Result.lpCurrencySymbol := {$IFNDEF FPC} PWideChar(Currency_CurrencySymbol)
+                             {$ELSE}       LPTSTR(PWideChar(Currency_CurrencySymbol)) {$ENDIF};
+end;
+
+//=============================================================================================
+
+{$IFDEF FPC}
+function GetLocaleStr(Locale, LocaleType: Integer; const Default: string): string;
+var
+  L: Integer;
+  Buffer: array[0..255] of Char;
+begin
+  L := GetLocaleInfo(Locale, LocaleType, Buffer, SizeOf(Buffer));
+  if L > 0 then SetString(Result, Buffer, L - 1) else Result := Default;
+end;
+{$ENDIF}
+
+function WideGetLocaleStr(LocaleID: LCID; LocaleType: Integer; const Default: WideString): WideString;
+var
+  L: Integer;
+begin
+  if (not Win32PlatformIsUnicode) then
+    Result := GetLocaleStr{TNT-ALLOW GetLocaleStr}(LocaleID, LocaleType, Default)
+  else begin
+    SetLength(Result, 255);
+    L := GetLocaleInfoW(LocaleID, LocaleType, PWideChar(Result), Length(Result));
+    if L > 0 then
+      SetLength(Result, L - 1)
+    else
+      Result := Default;
+  end;
+end;
+
+function WideSysErrorMessage(ErrorCode: Integer): WideString;
+begin
+  Result := WideLibraryErrorMessage('system', 0, ErrorCode);
+end;
+
+function WideLibraryErrorMessage(const LibName: WideString; Dll: THandle; ErrorCode: Integer): WideString;
+var
+  Len: Integer;
+  AnsiResult: AnsiString;
+  Flags: Cardinal;
+begin
+  Flags := FORMAT_MESSAGE_FROM_SYSTEM or FORMAT_MESSAGE_IGNORE_INSERTS or FORMAT_MESSAGE_ARGUMENT_ARRAY;
+  if Dll <> 0 then
+    Flags := Flags or FORMAT_MESSAGE_FROM_HMODULE;
+  if Win32PlatformIsUnicode then begin
+    SetLength(Result, 256);
+    Len := FormatMessageW(Flags, Pointer(Dll), ErrorCode, 0, PWideChar(Result), Length(Result), nil);
+    SetLength(Result, Len);
+  end else begin
+    SetLength(AnsiResult, 256);
+    Len := FormatMessageA(Flags, Pointer(Dll), ErrorCode, 0, PAnsiChar(AnsiResult), Length(AnsiResult), nil);
+    SetLength(AnsiResult, Len);
+    Result := AnsiResult;
+  end;
+  if Trim(Result) = '' then
+    Result := WideFormat('Unspecified error (%d) from %s.', [ErrorCode, LibName]);
+end;
+
+{$IFNDEF COMPILER_7_UP}
+function CheckWin32Version(AMajor: Integer; AMinor: Integer = 0): Boolean;
+begin
+  Result := (Win32MajorVersion > AMajor) or
+            ((Win32MajorVersion = AMajor) and
+             (Win32MinorVersion >= AMinor));
+end;
+{$ENDIF}
+
+function WinCheckH(RetVal: Cardinal): Cardinal;
+begin
+  if RetVal = 0 then RaiseLastOSError;
+  Result := RetVal;
+end;
+
+function WinCheckFileH(RetVal: Cardinal): Cardinal;
+begin
+  if RetVal = INVALID_HANDLE_VALUE then RaiseLastOSError;
+  Result := RetVal;
+end;
+
+function WinCheckP(RetVal: Pointer): Pointer;
+begin
+  if RetVal = nil then RaiseLastOSError;
+  Result := RetVal;
+end;
+
+function WideGetModuleFileName(Instance: HModule): WideString;
+begin
+  SetLength(Result, MAX_PATH);
+  WinCheckH(Tnt_GetModuleFileNameW(Instance, PWideChar(Result), Length(Result)));
+  Result := PWideChar(Result)
+end;
+
+function WideSafeLoadLibrary(const Filename: Widestring; ErrorMode: UINT): HMODULE;
+var
+  OldMode: UINT;
+  FPUControlWord: Word;
+begin
+  OldMode := SetErrorMode(ErrorMode);
+  try
+    asm
+      FNSTCW  FPUControlWord
+    end;
+    try
+      Result := Tnt_LoadLibraryW(PWideChar(Filename));
+    finally
+      asm
+        FNCLEX
+        FLDCW FPUControlWord
+      end;
+    end;
+  finally
+    SetErrorMode(OldMode);
+  end;
+end;
+
+{$IFNDEF FPC}
+function WideLoadPackage(const Name: Widestring): HMODULE;
+begin
+  Result := WideSafeLoadLibrary(Name);
+  if Result = 0 then
+  begin
+    raise EPackageError.CreateFmt(sErrorLoadingPackage, [Name, WideSysErrorMessage(GetLastError)]);
+  end;
+  try
+    InitializePackage(Result);
+  except
+    FreeLibrary(Result);
+    raise;
+  end;
+end;
+{$ENDIF}
+
+function _WideCharType(WC: WideChar; dwInfoType: Cardinal): Word;
+begin
+  Win32Check(Tnt_GetStringTypeExW(GetThreadLocale, dwInfoType, PWideChar(@WC), 1, Result))
+end;
+
+function IsWideCharUpper(WC: WideChar): Boolean;
+begin
+  Result := (_WideCharType(WC, CT_CTYPE1) and C1_UPPER) <> 0;
+end;
+
+function IsWideCharLower(WC: WideChar): Boolean;
+begin
+  Result := (_WideCharType(WC, CT_CTYPE1) and C1_LOWER) <> 0;
+end;
+
+function IsWideCharDigit(WC: WideChar): Boolean;
+begin
+  Result := (_WideCharType(WC, CT_CTYPE1) and C1_DIGIT) <> 0;
+end;
+
+function IsWideCharSpace(WC: WideChar): Boolean;
+begin
+  Result := (_WideCharType(WC, CT_CTYPE1) and C1_SPACE) <> 0;
+end;
+
+function IsWideCharPunct(WC: WideChar): Boolean;
+begin
+  Result := (_WideCharType(WC, CT_CTYPE1) and C1_PUNCT) <> 0;
+end;
+
+function IsWideCharCntrl(WC: WideChar): Boolean;
+begin
+  Result := (_WideCharType(WC, CT_CTYPE1) and C1_CNTRL) <> 0;
+end;
+
+function IsWideCharBlank(WC: WideChar): Boolean;
+begin
+  Result := (_WideCharType(WC, CT_CTYPE1) and C1_BLANK) <> 0;
+end;
+
+function IsWideCharXDigit(WC: WideChar): Boolean;
+begin
+  Result := (_WideCharType(WC, CT_CTYPE1) and C1_XDIGIT) <> 0;
+end;
+
+function IsWideCharAlpha(WC: WideChar): Boolean;
+begin
+  Result := (_WideCharType(WC, CT_CTYPE1) and C1_ALPHA) <> 0;
+end;
+
+function IsWideCharAlphaNumeric(WC: WideChar): Boolean;
+begin
+  Result := (_WideCharType(WC, CT_CTYPE1) and (C1_ALPHA + C1_DIGIT)) <> 0;
+end;
+
+function WideTextPos(const SubStr, S: WideString): Integer;
+begin
+  Result := Pos(Tnt_WideUpperCase(SubStr), Tnt_WideUpperCase(S));
+end;
+
+function FindDoubleTerminator(P: PWideChar): PWideChar;
+begin
+  Result := P;
+  while True do begin
+    Result := WStrScan(Result, #0);
+    Inc(Result);
+    if Result^ = #0 then begin
+      Dec(Result);
+      break;
+    end;
+  end;
+end;
+
+function ExtractStringArrayStr(P: PWideChar): WideString;
+var
+  PEnd: PWideChar;
+begin
+  PEnd := FindDoubleTerminator(P);
+  Inc(PEnd, 2); // move past #0#0
+  SetString(Result, P, PEnd - P);
+end;
+
+function ExtractStringFromStringArray(var P: PWideChar; Separator: WideChar = #0): WideString;
+var
+  Start: PWideChar;
+begin
+  Start := P;
+  P := WStrScan(Start, Separator);
+  if P = nil then begin
+    Result := Start;
+    P := WStrEnd(Start);
+  end else begin
+    SetString(Result, Start, P - Start);
+    Inc(P);
+  end;
+end;
+
+function ExtractStringsFromStringArray(P: PWideChar; Separator: WideChar = #0): TWideStringDynArray;
+const
+  GROW_COUNT = 256;
+var
+  Count: Integer;
+  Item: WideString;
+begin
+  Count := 0;
+  SetLength(Result, GROW_COUNT);
+  Item := ExtractStringFromStringArray(P, Separator);
+  While Item <> '' do begin
+    if Count > High(Result) then
+      SetLength(Result, Length(Result) + GROW_COUNT);
+    Result[Count] := Item;
+    Inc(Count);
+    Item := ExtractStringFromStringArray(P, Separator);
+  end;
+  SetLength(Result, Count);
+end;
+
+function IsWideCharMappableToAnsi(const WC: WideChar): Boolean;
+var
+  UsedDefaultChar: BOOL;
+begin
+  WideCharToMultiByte(DefaultSystemCodePage, 0, PWideChar(@WC), 1, nil, 0, nil, @UsedDefaultChar);
+  Result := not UsedDefaultChar;
+end;
+
+function IsWideStringMappableToAnsi(const WS: WideString): Boolean;
+var
+  UsedDefaultChar: BOOL;
+begin
+  WideCharToMultiByte(DefaultSystemCodePage, 0, PWideChar(WS), Length(WS), nil, 0, nil, @UsedDefaultChar);
+  Result := not UsedDefaultChar;
+end;
+
+function IsRTF(const Value: WideString): Boolean;
+const
+  RTF_BEGIN_1  = WideString('{\RTF');
+  RTF_BEGIN_2  = WideString('{URTF');
+begin
+  Result := (WideTextPos(RTF_BEGIN_1, Value) = 1)
+         or (WideTextPos(RTF_BEGIN_2, Value) = 1);
+end;
+
+{$IFDEF COMPILER_7_UP}
+var
+  Cached_ENG_US_FormatSettings: TFormatSettings;
+  Cached_ENG_US_FormatSettings_Time: Cardinal;
+
+function ENG_US_FormatSettings: TFormatSettings;
+begin
+  if Cached_ENG_US_FormatSettings_Time = _SettingChangeTime then
+    Result := Cached_ENG_US_FormatSettings
+  else begin
+    GetLocaleFormatSettings(MAKELCID(MAKELANGID(LANG_ENGLISH, SUBLANG_ENGLISH_US)), Result);
+    Result.DecimalSeparator := '.'; // ignore overrides
+    Cached_ENG_US_FormatSettings := Result;
+    Cached_ENG_US_FormatSettings_Time := _SettingChangeTime;
+  end;
+ end;
+
+function ENG_US_FloatToStr(Value: Extended): WideString;
+begin
+  Result := FloatToStr(Value, ENG_US_FormatSettings);
+end;
+
+function ENG_US_StrToFloat(const S: WideString): Extended;
+begin
+  if not TextToFloat(PAnsiChar(AnsiString(S)), Result, fvExtended, ENG_US_FormatSettings) then
+    Result := StrToFloat(S); // try using native format
+end;
+
+{$ELSE}
+
+function ENG_US_FloatToStr(Value: Extended): WideString;
+var
+  SaveDecimalSep: AnsiChar;
+begin
+  SaveDecimalSep := SysUtils.DecimalSeparator;
+  try
+    SysUtils.DecimalSeparator := '.';
+    Result := FloatToStr(Value);
+  finally
+    SysUtils.DecimalSeparator := SaveDecimalSep;
+  end;
+end;
+
+function ENG_US_StrToFloat(const S: WideString): Extended;
+var
+  SaveDecimalSep: AnsiChar;
+begin
+  try
+    SaveDecimalSep := SysUtils.DecimalSeparator;
+    try
+      SysUtils.DecimalSeparator := '.';
+      Result := StrToFloat(S);
+    finally
+      SysUtils.DecimalSeparator := SaveDecimalSep;
+    end;
+  except
+    if SysUtils.DecimalSeparator <> '.' then
+      Result := StrToFloat(S) // try using native format
+    else
+      raise;
+  end;
+end;
+{$ENDIF}
+
+//---------------------------------------------------------------------------------------------
+//                                 Tnt - Variants
+//---------------------------------------------------------------------------------------------
+
+initialization
+  Win32PlatformIsUnicode := (Win32Platform = VER_PLATFORM_WIN32_NT);
+  Win32PlatformIsXP := ((Win32MajorVersion = 5) and (Win32MinorVersion >= 1))
+                    or  (Win32MajorVersion > 5);
+  Win32PlatformIs2003 := ((Win32MajorVersion = 5) and (Win32MinorVersion >= 2))
+                    or  (Win32MajorVersion > 5);
+  Win32PlatformIsVista := (Win32MajorVersion >= 6);
+
+finalization
+  Currency_DecimalSep := ''; {make memory sleuth happy}
+  Currency_ThousandSep := ''; {make memory sleuth happy}
+  Currency_CurrencySymbol := ''; {make memory sleuth happy}
+
+end.
diff --git a/Lua/src/lib/TntUnicodeControls/TntSystem.pas b/Lua/src/lib/TntUnicodeControls/TntSystem.pas
new file mode 100644
index 00000000..e613ce0c
--- /dev/null
+++ b/Lua/src/lib/TntUnicodeControls/TntSystem.pas
@@ -0,0 +1,1427 @@
+
+{*****************************************************************************}
+{                                                                             }
+{    Tnt Delphi Unicode Controls                                              }
+{      http://www.tntware.com/delphicontrols/unicode/                         }
+{        Version: 2.3.0                                                       }
+{                                                                             }
+{    Copyright (c) 2002-2007, Troy Wolbrink (troy.wolbrink@tntware.com)       }
+{                                                                             }
+{*****************************************************************************}
+
+unit TntSystem;
+
+{$IFDEF FPC}
+  {$MODE Delphi}
+{$ENDIF}
+
+{$INCLUDE TntCompilers.inc}
+
+{*****************************************************************************}
+{  Special thanks go to Francisco Leong for originating the design for        }
+{    WideString-enabled resourcestrings.                                      }
+{*****************************************************************************}
+
+interface
+
+uses
+  Windows;
+
+// These functions should not be used by Delphi code since conversions are implicit.
+{TNT-WARN WideCharToString}
+{TNT-WARN WideCharLenToString}
+{TNT-WARN WideCharToStrVar}
+{TNT-WARN WideCharLenToStrVar}
+{TNT-WARN StringToWideChar}
+
+// ................ ANSI TYPES ................
+{TNT-WARN Char}
+{TNT-WARN PChar}
+{TNT-WARN String}
+
+{TNT-WARN CP_ACP} // <-- use DefaultSystemCodePage
+function DefaultSystemCodePage: Cardinal; // implicitly used when converting AnsiString <--> WideString.
+
+{$IFNDEF FPC}
+var
+  WideCustomLoadResString: function(ResStringRec: PResStringRec; var Value: WideString): Boolean;
+{$ENDIF}
+
+{TNT-WARN LoadResString}
+function WideLoadResString(ResStringRec: PResStringRec): WideString;
+{TNT-WARN ParamCount}
+function WideParamCount: Integer;
+{TNT-WARN ParamStr}
+function WideParamStr(Index: Integer): WideString;
+
+// ......... introduced .........
+
+const
+  { Each Unicode stream should begin with the code U+FEFF,  }
+  {   which the standard defines as the *byte order mark*.  }
+  UNICODE_BOM = WideChar($FEFF);
+  UNICODE_BOM_SWAPPED = WideChar($FFFE);
+  UTF8_BOM = AnsiString(#$EF#$BB#$BF);
+
+function WideStringToUTF8(const S: WideString): AnsiString;
+function UTF8ToWideString(const S: AnsiString): WideString;
+
+function WideStringToUTF7(const W: WideString): AnsiString;
+function UTF7ToWideString(const S: AnsiString): WideString;
+
+function StringToWideStringEx(const S: AnsiString; CodePage: Cardinal): WideString;
+function WideStringToStringEx(const WS: WideString; CodePage: Cardinal): AnsiString;
+
+function UCS2ToWideString(const Value: AnsiString): WideString;
+function WideStringToUCS2(const Value: WideString): AnsiString;
+
+function CharSetToCodePage(ciCharset: UINT): Cardinal;
+function LCIDToCodePage(ALcid: LCID): Cardinal;
+function KeyboardCodePage: Cardinal;
+function KeyUnicode(CharCode: Word): WideChar;
+
+procedure StrSwapByteOrder(Str: PWideChar);
+
+{$IFDEF USE_SYSTEM_OVERRIDES}
+
+type
+  TTntSystemUpdate =
+    (tsWideResourceStrings
+     {$IFNDEF COMPILER_9_UP}, tsFixImplicitCodePage, tsFixWideStrConcat, tsFixWideFormat {$ENDIF}
+    );
+  TTntSystemUpdateSet = set of TTntSystemUpdate;
+
+const
+  AllTntSystemUpdates = [Low(TTntSystemUpdate)..High(TTntSystemUpdate)];
+
+procedure InstallTntSystemUpdates(Updates: TTntSystemUpdateSet = AllTntSystemUpdates);
+
+{$ENDIF USE_SYSTEM_OVERRIDES}
+
+implementation
+
+uses
+  SysUtils, Variants, TntWindows, TntSysUtils;
+
+var
+  GDefaultSystemCodePage: Cardinal;
+
+function DefaultSystemCodePage: Cardinal;
+begin
+  Result := GDefaultSystemCodePage;
+end;
+
+{$IFDEF USE_SYSTEM_OVERRIDES}
+var
+  IsDebugging: Boolean;
+{$ENDIF USE_SYSTEM_OVERRIDES}
+
+function WideLoadResStringDetect(ResStringRec: PResStringRec): WideString;
+var
+  PCustom: PAnsiChar;
+begin
+  // custom string pointer
+  PCustom := PAnsiChar(ResStringRec); { I would like to use PWideChar, but this would break legacy code. }
+  if  (StrLen{TNT-ALLOW StrLen}(PCustom) > Cardinal(Length(UTF8_BOM)))
+  and CompareMem(PCustom, PAnsiChar(UTF8_BOM), Length(UTF8_BOM)) then
+    // detected UTF8
+    Result := UTF8ToWideString(PAnsiChar(PCustom + Length(UTF8_BOM)))
+  else
+    // normal
+    Result := PCustom;
+end;
+
+{$IFNDEF FPC}
+
+function WideLoadResString(ResStringRec: PResStringRec): WideString;
+const
+  MAX_RES_STRING_SIZE = 4097; { MSDN documents this as the maximum size of a string in table. }
+var
+  Buffer: array [0..MAX_RES_STRING_SIZE] of WideChar; { Buffer leaves room for null terminator. }
+begin
+  if Assigned(WideCustomLoadResString) and WideCustomLoadResString(ResStringRec, Result) then
+    exit; { a custom resourcestring has been loaded. }
+
+  if ResStringRec = nil then
+    Result := ''
+  else if ResStringRec.Identifier < 64*1024 then
+    SetString(Result, Buffer,
+      Tnt_LoadStringW(FindResourceHInstance(ResStringRec.Module^),
+        ResStringRec.Identifier, Buffer, MAX_RES_STRING_SIZE))
+  else begin
+    Result := WideLoadResStringDetect(ResStringRec);
+  end;
+end;
+
+{$ELSE}
+
+function WideLoadResString(ResStringRec: PResStringRec): WideString;
+begin
+  Result := WideLoadResStringDetect(ResStringRec);
+end;
+
+{$ENDIF}
+
+function WideGetParamStr(P: PWideChar; var Param: WideString): PWideChar;
+var
+  i, Len: Integer;
+  Start, S, Q: PWideChar;
+begin
+  while True do
+  begin
+    while (P[0] <> #0) and (P[0] <= ' ') do
+      Inc(P);
+    if (P[0] = '"') and (P[1] = '"') then Inc(P, 2) else Break;
+  end;
+  Len := 0;
+  Start := P;
+  while P[0] > ' ' do
+  begin
+    if P[0] = '"' then
+    begin
+      Inc(P);
+      while (P[0] <> #0) and (P[0] <> '"') do
+      begin
+        Q := P + 1;
+        Inc(Len, Q - P);
+        P := Q;
+      end;
+      if P[0] <> #0 then
+        Inc(P);
+    end
+    else
+    begin
+      Q := P + 1;
+      Inc(Len, Q - P);
+      P := Q;
+    end;
+  end;
+
+  SetLength(Param, Len);
+
+  P := Start;
+  S := PWideChar(Param);
+  i := 0;
+  while P[0] > ' ' do
+  begin
+    if P[0] = '"' then
+    begin
+      Inc(P);
+      while (P[0] <> #0) and (P[0] <> '"') do
+      begin
+        Q := P + 1;
+        while P < Q do
+        begin
+          S[i] := P^;
+          Inc(P);
+          Inc(i);
+        end;
+      end;
+      if P[0] <> #0 then Inc(P);
+    end
+    else
+    begin
+      Q := P + 1;
+      while P < Q do
+      begin
+        S[i] := P^;
+        Inc(P);
+        Inc(i);
+      end;
+    end;
+  end;
+
+  Result := P;
+end;
+
+function WideParamCount: Integer;
+var
+  P: PWideChar;
+  S: WideString;
+begin
+  P := WideGetParamStr(GetCommandLineW, S);
+  Result := 0;
+  while True do
+  begin
+    P := WideGetParamStr(P, S);
+    if S = '' then Break;
+    Inc(Result);
+  end;
+end;
+
+function WideParamStr(Index: Integer): WideString;
+var
+  P: PWideChar;
+begin
+  if Index = 0 then
+    Result := WideGetModuleFileName(0)
+  else
+  begin
+    P := GetCommandLineW;
+    while True do
+    begin
+      P := WideGetParamStr(P, Result);
+      if (Index = 0) or (Result = '') then Break;
+      Dec(Index);
+    end;
+  end;
+end;
+
+function WideStringToUTF8(const S: WideString): AnsiString;
+begin
+  Result := UTF8Encode(S);
+end;
+
+function UTF8ToWideString(const S: AnsiString): WideString;
+begin
+  Result := UTF8Decode(S);
+end;
+
+  { ======================================================================= }
+  { Original File:   ConvertUTF7.c                                          }
+  { Author: David B. Goldsmith                                              }
+  { Copyright (C) 1994, 1996 Taligent, Inc. All rights reserved.            }
+  {                                                                         }
+  { This code is copyrighted. Under the copyright laws, this code may not   }
+  { be copied, in whole or part, without prior written consent of Taligent. }
+  {                                                                         }
+  { Taligent grants the right to use this code as long as this ENTIRE       }
+  { copyright notice is reproduced in the code.  The code is provided       }
+  { AS-IS, AND TALIGENT DISCLAIMS ALL WARRANTIES, EITHER EXPRESS OR         }
+  { IMPLIED, INCLUDING, BUT NOT LIMITED TO IMPLIED WARRANTIES OF            }
+  { MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE.  IN NO EVENT      }
+  { WILL TALIGENT BE LIABLE FOR ANY DAMAGES WHATSOEVER (INCLUDING,          }
+  { WITHOUT LIMITATION, DAMAGES FOR LOSS OF BUSINESS PROFITS, BUSINESS      }
+  { INTERRUPTION, LOSS OF BUSINESS INFORMATION, OR OTHER PECUNIARY          }
+  { LOSS) ARISING OUT OF THE USE OR INABILITY TO USE THIS CODE, EVEN        }
+  { IF TALIGENT HAS BEEN ADVISED OF THE POSSIBILITY OF SUCH DAMAGES.        }
+  { BECAUSE SOME STATES DO NOT ALLOW THE EXCLUSION OR LIMITATION OF         }
+  { LIABILITY FOR CONSEQUENTIAL OR INCIDENTAL DAMAGES, THE ABOVE            }
+  { LIMITATION MAY NOT APPLY TO YOU.                                        }
+  {                                                                         }
+  { RESTRICTED RIGHTS LEGEND: Use, duplication, or disclosure by the        }
+  { government is subject to restrictions as set forth in subparagraph      }
+  { (c)(l)(ii) of the Rights in Technical Data and Computer Software        }
+  { clause at DFARS 252.227-7013 and FAR 52.227-19.                         }
+  {                                                                         }
+  { This code may be protected by one or more U.S. and International        }
+  { Patents.                                                                }
+  {                                                                         }
+  { TRADEMARKS: Taligent and the Taligent Design Mark are registered        }
+  { trademarks of Taligent, Inc.                                            }
+  { ======================================================================= }
+
+type UCS2 = Word;
+
+const
+  _base64: AnsiString = 'ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789+/';
+  _direct: AnsiString = 'ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789''(),-./:?';
+  _optional: AnsiString = '!"#$%&*;<=>@[]^_`{|}';
+  _spaces: AnsiString = #9#13#10#32;
+
+var
+  base64: PAnsiChar;
+  invbase64: array[0..127] of SmallInt;
+  direct: PAnsiChar;
+  optional: PAnsiChar;
+  spaces: PAnsiChar;
+  mustshiftsafe: array[0..127] of AnsiChar;
+  mustshiftopt: array[0..127] of AnsiChar;
+
+var
+  needtables: Boolean = True;
+
+procedure Initialize_UTF7_Data;
+begin
+  base64 := PAnsiChar(_base64);
+  direct := PAnsiChar(_direct);
+  optional := PAnsiChar(_optional);
+  spaces := PAnsiChar(_spaces);
+end;
+
+procedure tabinit;
+var
+  i: Integer;
+  limit: Integer;
+begin
+  i := 0;
+  while (i < 128) do
+  begin
+    mustshiftopt[i] := #1;
+    mustshiftsafe[i] := #1;
+    invbase64[i] := -1;
+    Inc(i);
+  end { For };
+  limit := Length(_Direct);
+  i := 0;
+  while (i < limit) do
+  begin
+    mustshiftopt[Integer(direct[i])] := #0;
+    mustshiftsafe[Integer(direct[i])] := #0;
+    Inc(i);
+  end { For };
+  limit := Length(_Spaces);
+  i := 0;
+  while (i < limit) do
+  begin
+    mustshiftopt[Integer(spaces[i])] := #0;
+    mustshiftsafe[Integer(spaces[i])] := #0;
+    Inc(i);
+  end { For };
+  limit := Length(_Optional);
+  i := 0;
+  while (i < limit) do
+  begin
+    mustshiftopt[Integer(optional[i])] := #0;
+    Inc(i);
+  end { For };
+  limit := Length(_Base64);
+  i := 0;
+  while (i < limit) do
+  begin
+    invbase64[Integer(base64[i])] := i;
+    Inc(i);
+  end { For };
+  needtables := False;
+end; { tabinit }
+
+function WRITE_N_BITS(x: UCS2; n: Integer; var BITbuffer: Cardinal; var bufferbits: Integer): Integer;
+begin
+  BITbuffer := BITbuffer or (x and (not (-1 shl n))) shl (32 - n - bufferbits);
+  bufferbits := bufferbits + n;
+  Result := bufferbits;
+end; { WRITE_N_BITS }
+
+function READ_N_BITS(n: Integer; var BITbuffer: Cardinal; var bufferbits: Integer): UCS2;
+var
+  buffertemp: Cardinal;
+begin
+  buffertemp := BITbuffer shr (32 - n);
+  BITbuffer := BITbuffer shl n;
+  bufferbits := bufferbits - n;
+  Result := UCS2(buffertemp);
+end; { READ_N_BITS }
+
+function ConvertUCS2toUTF7(var sourceStart: PWideChar; sourceEnd: PWideChar;
+  var targetStart: PAnsiChar; targetEnd: PAnsiChar; optional: Boolean;
+    verbose: Boolean): Integer;
+var
+  r: UCS2;
+  target: PAnsiChar;
+  source: PWideChar;
+  BITbuffer: Cardinal;
+  bufferbits: Integer;
+  shifted: Boolean;
+  needshift: Boolean;
+  done: Boolean;
+  mustshift: PAnsiChar;
+begin
+  Initialize_UTF7_Data;
+  Result := 0;
+  BITbuffer := 0;
+  bufferbits := 0;
+  shifted := False;
+  source := sourceStart;
+  target := targetStart;
+  r := 0;
+  if needtables then
+    tabinit;
+  if optional then
+    mustshift := @mustshiftopt[0]
+  else
+    mustshift := @mustshiftsafe[0];
+  repeat
+    done := source >= sourceEnd;
+    if not Done then
+    begin
+      r := Word(source^);
+      Inc(Source);
+    end { If };
+    needshift := (not done) and ((r > $7F) or (mustshift[r] <> #0));
+    if needshift and (not shifted) then
+    begin
+      if (Target >= TargetEnd) then
+      begin
+        Result := 2;
+        break;
+      end { If };
+      target^ := '+';
+      Inc(target);
+      { Special case handling of the SHIFT_IN character }
+      if (r = UCS2('+')) then
+      begin
+        if (target >= targetEnd) then
+        begin
+          Result := 2;
+          break;
+        end;
+        target^ := '-';
+        Inc(target);
+      end
+      else
+        shifted := True;
+    end { If };
+    if shifted then
+    begin
+      { Either write the character to the bit buffer, or pad }
+      { the bit buffer out to a full base64 character. }
+      { }
+      if needshift then
+        WRITE_N_BITS(r, 16, BITbuffer, bufferbits)
+      else
+        WRITE_N_BITS(0, (6 - (bufferbits mod 6)) mod 6, BITbuffer,
+          bufferbits);
+      { Flush out as many full base64 characters as possible }
+      { from the bit buffer. }
+      { }
+      while (target < targetEnd) and (bufferbits >= 6) do
+      begin
+        Target^ := base64[READ_N_BITS(6, BITbuffer, bufferbits)];
+        Inc(Target);
+      end { While };
+      if (bufferbits >= 6) then
+      begin
+        if (target >= targetEnd) then
+        begin
+          Result := 2;
+          break;
+        end { If };
+      end { If };
+      if (not needshift) then
+      begin
+        { Write the explicit shift out character if }
+        { 1) The caller has requested we always do it, or }
+        { 2) The directly encoded character is in the }
+        { base64 set, or }
+        { 3) The directly encoded character is SHIFT_OUT. }
+        { }
+        if verbose or ((not done) and ((invbase64[r] >= 0) or (r =
+          Integer('-')))) then
+        begin
+          if (target >= targetEnd) then
+          begin
+            Result := 2;
+            Break;
+          end { If };
+          Target^ := '-';
+          Inc(Target);
+        end { If };
+        shifted := False;
+      end { If };
+      { The character can be directly encoded as ASCII. }
+    end { If };
+    if (not needshift) and (not done) then
+    begin
+      if (target >= targetEnd) then
+      begin
+        Result := 2;
+        break;
+      end { If };
+      Target^ := AnsiChar(r);
+      Inc(Target);
+    end { If };
+  until (done);
+  sourceStart := source;
+  targetStart := target;
+end; { ConvertUCS2toUTF7 }
+
+function ConvertUTF7toUCS2(var sourceStart: PAnsiChar; sourceEnd: PAnsiChar;
+  var targetStart: PWideChar; targetEnd: PWideChar): Integer;
+var
+  target: PWideChar { Register };
+  source: PAnsiChar { Register };
+  BITbuffer: Cardinal { & "Address Of" Used };
+  bufferbits: Integer { & "Address Of" Used };
+  shifted: Boolean { Used In Boolean Context };
+  first: Boolean { Used In Boolean Context };
+  wroteone: Boolean;
+  base64EOF: Boolean;
+  base64value: Integer;
+  done: Boolean;
+  c: UCS2;
+  prevc: UCS2;
+  junk: UCS2 { Used In Boolean Context };
+begin
+  Initialize_UTF7_Data;
+  Result := 0;
+  BITbuffer := 0;
+  bufferbits := 0;
+  shifted := False;
+  first := False;
+  wroteone := False;
+  source := sourceStart;
+  target := targetStart;
+  c := 0;
+  if needtables then
+    tabinit;
+  repeat
+    { read an ASCII character c }
+    done := Source >= SourceEnd;
+    if (not done) then
+    begin
+      c := Word(Source^);
+      Inc(Source);
+    end { If };
+    if shifted then
+    begin
+      { We're done with a base64 string if we hit EOF, it's not a valid }
+      { ASCII character, or it's not in the base64 set. }
+      { }
+      base64value := invbase64[c];
+      base64EOF := (done or (c > $7F)) or (base64value < 0);
+      if base64EOF then
+      begin
+        shifted := False;
+        { If the character causing us to drop out was SHIFT_IN or }
+        { SHIFT_OUT, it may be a special escape for SHIFT_IN. The }
+        { test for SHIFT_IN is not necessary, but allows an alternate }
+        { form of UTF-7 where SHIFT_IN is escaped by SHIFT_IN. This }
+        { only works for some values of SHIFT_IN. }
+        { }
+        if ((not done) and ((c = Integer('+')) or (c = Integer('-')))) then
+        begin
+          { get another character c }
+          prevc := c;
+          Done := Source >= SourceEnd;
+          if (not Done) then
+          begin
+            c := Word(Source^);
+            Inc(Source);
+            { If no base64 characters were encountered, and the }
+            { character terminating the shift sequence was }
+            { SHIFT_OUT, then it's a special escape for SHIFT_IN. }
+            { }
+          end;
+          if first and (prevc = Integer('-')) then
+          begin
+            { write SHIFT_IN unicode }
+            if (target >= targetEnd) then
+            begin
+              Result := 2;
+              break;
+            end { If };
+            Target^ := WideChar('+');
+            Inc(Target);
+          end
+          else
+          begin
+            if (not wroteone) then
+            begin
+              Result := 1;
+            end { If };
+          end { Else };
+          ;
+        end { If }
+        else
+        begin
+          if (not wroteone) then
+          begin
+            Result := 1;
+          end { If };
+        end { Else };
+      end { If }
+      else
+      begin
+        { Add another 6 bits of base64 to the bit buffer. }
+        WRITE_N_BITS(base64value, 6, BITbuffer,
+          bufferbits);
+        first := False;
+      end { Else };
+      { Extract as many full 16 bit characters as possible from the }
+      { bit buffer. }
+      { }
+      while (bufferbits >= 16) and (target < targetEnd) do
+      begin
+        { write a unicode }
+        Target^ := WideChar(READ_N_BITS(16, BITbuffer, bufferbits));
+        Inc(Target);
+        wroteone := True;
+      end { While };
+      if (bufferbits >= 16) then
+      begin
+        if (target >= targetEnd) then
+        begin
+          Result := 2;
+          Break;
+        end;
+      end { If };
+      if (base64EOF) then
+      begin
+        junk := READ_N_BITS(bufferbits, BITbuffer, bufferbits);
+        if (junk <> 0) then
+        begin
+          Result := 1;
+        end { If };
+      end { If };
+    end { If };
+    if (not shifted) and (not done) then
+    begin
+      if (c = Integer('+')) then
+      begin
+        shifted := True;
+        first := True;
+        wroteone := False;
+      end { If }
+      else
+      begin
+        { It must be a directly encoded character. }
+        if (c > $7F) then
+        begin
+          Result := 1;
+        end { If };
+        if (target >= targetEnd) then
+        begin
+          Result := 2;
+          break;
+        end { If };
+        Target^ := WideChar(c);
+        Inc(Target);
+      end { Else };
+    end { If };
+  until (done);
+  sourceStart := source;
+  targetStart := target;
+end; { ConvertUTF7toUCS2 }
+
+  {*****************************************************************************}
+  { Thanks to Francisco Leong for providing the Pascal conversion of            }
+  {   ConvertUTF7.c (by David B. Goldsmith)                                     }
+  {*****************************************************************************}
+
+resourcestring
+  SBufferOverflow = 'Buffer overflow';
+  SInvalidUTF7 = 'Invalid UTF7';
+
+function WideStringToUTF7(const W: WideString): AnsiString;
+var
+  SourceStart, SourceEnd: PWideChar;
+  TargetStart, TargetEnd: PAnsiChar;
+begin
+  if W = '' then
+    Result := ''
+  else
+  begin
+    SetLength(Result, Length(W) * 7); // Assume worst case
+    SourceStart := PWideChar(@W[1]);
+    SourceEnd := PWideChar(@W[Length(W)]) + 1;
+    TargetStart := PAnsiChar(@Result[1]);
+    TargetEnd := PAnsiChar(@Result[Length(Result)]) + 1;
+    if ConvertUCS2toUTF7(SourceStart, SourceEnd, TargetStart,
+      TargetEnd, True, False) <> 0
+    then
+      raise ETntInternalError.Create(SBufferOverflow);
+    SetLength(Result, TargetStart - PAnsiChar(@Result[1]));
+  end;
+end;
+
+function UTF7ToWideString(const S: AnsiString): WideString;
+var
+  SourceStart, SourceEnd: PAnsiChar;
+  TargetStart, TargetEnd: PWideChar;
+begin
+  if (S = '') then
+    Result := ''
+  else
+  begin
+    SetLength(Result, Length(S)); // Assume Worst case
+    SourceStart := PAnsiChar(@S[1]);
+    SourceEnd := PAnsiChar(@S[Length(S)]) + 1;
+    TargetStart := PWideChar(@Result[1]);
+    TargetEnd := PWideChar(@Result[Length(Result)]) + 1;
+    case ConvertUTF7toUCS2(SourceStart, SourceEnd, TargetStart,
+      TargetEnd) of
+      1: raise ETntGeneralError.Create(SInvalidUTF7);
+      2: raise ETntInternalError.Create(SBufferOverflow);
+    end;
+    SetLength(Result, TargetStart - PWideChar(@Result[1]));
+  end;
+end;
+
+function StringToWideStringEx(const S: AnsiString; CodePage: Cardinal): WideString;
+var
+  InputLength,
+  OutputLength: Integer;
+begin
+  if CodePage = CP_UTF7 then
+    Result := UTF7ToWideString(S) // CP_UTF7 not supported on Windows 95
+  else if CodePage = CP_UTF8 then
+    Result := UTF8ToWideString(S) // CP_UTF8 not supported on Windows 95
+  else begin
+    InputLength := Length(S);
+    OutputLength := MultiByteToWideChar(CodePage, 0, PAnsiChar(S), InputLength, nil, 0);
+    SetLength(Result, OutputLength);
+    MultiByteToWideChar(CodePage, 0, PAnsiChar(S), InputLength, PWideChar(Result), OutputLength);
+  end;
+end;
+
+function WideStringToStringEx(const WS: WideString; CodePage: Cardinal): AnsiString;
+var
+  InputLength,
+  OutputLength: Integer;
+begin
+  if CodePage = CP_UTF7 then
+    Result := WideStringToUTF7(WS) // CP_UTF7 not supported on Windows 95
+  else if CodePage = CP_UTF8 then
+    Result := WideStringToUTF8(WS) // CP_UTF8 not supported on Windows 95
+  else begin
+    InputLength := Length(WS);
+    OutputLength := WideCharToMultiByte(CodePage, 0, PWideChar(WS), InputLength, nil, 0, nil, nil);
+    SetLength(Result, OutputLength);
+    WideCharToMultiByte(CodePage, 0, PWideChar(WS), InputLength, PAnsiChar(Result), OutputLength, nil, nil);
+  end;
+end;
+
+function UCS2ToWideString(const Value: AnsiString): WideString;
+begin
+  if Length(Value) = 0 then
+    Result := ''
+  else
+    SetString(Result, PWideChar(@Value[1]), Length(Value) div SizeOf(WideChar))
+end;
+
+function WideStringToUCS2(const Value: WideString): AnsiString;
+begin
+  if Length(Value) = 0 then
+    Result := ''
+  else
+    SetString(Result, PAnsiChar(@Value[1]), Length(Value) * SizeOf(WideChar))
+end;
+
+{ Windows.pas doesn't declare TranslateCharsetInfo() correctly. }
+function TranslateCharsetInfo(lpSrc: PDWORD; var lpCs: TCharsetInfo; dwFlags: DWORD): BOOL; stdcall; external gdi32 name 'TranslateCharsetInfo';
+
+function CharSetToCodePage(ciCharset: UINT): Cardinal;
+var
+  C: TCharsetInfo;
+begin
+  Win32Check(TranslateCharsetInfo(PDWORD(ciCharset), C, TCI_SRCCHARSET));
+  Result := C.ciACP
+end;
+
+function LCIDToCodePage(ALcid: LCID): Cardinal;
+var
+  Buf: array[0..6] of AnsiChar;
+begin
+  GetLocaleInfo(ALcid, LOCALE_IDefaultAnsiCodePage, Buf, 6);
+  Result := StrToIntDef(Buf, GetACP);
+end;
+
+function KeyboardCodePage: Cardinal;
+begin
+  Result := LCIDToCodePage(GetKeyboardLayout(0) and $FFFF);
+end;
+
+function KeyUnicode(CharCode: Word): WideChar;
+var
+  AChar: AnsiChar;
+begin
+  // converts the given character (as it comes with a WM_CHAR message) into its
+  // corresponding Unicode character depending on the active keyboard layout
+  if CharCode <= Word(High(AnsiChar)) then begin
+    AChar := AnsiChar(CharCode);
+    MultiByteToWideChar(KeyboardCodePage, MB_USEGLYPHCHARS, @AChar, 1, @Result, 1);
+  end else
+    Result := WideChar(CharCode);
+end;
+
+procedure StrSwapByteOrder(Str: PWideChar);
+var
+  P: PWord;
+begin
+  P := PWord(Str);
+  While (P^ <> 0) do begin
+    P^ := MakeWord(HiByte(P^), LoByte(P^));
+    Inc(P);
+  end;
+end;
+
+{$IFDEF USE_SYSTEM_OVERRIDES}
+
+//--------------------------------------------------------------------
+//                LoadResString()
+//
+//  This system function is used to retrieve a resourcestring and
+//   return the result as an AnsiString.  If we believe that the result
+//    is only a temporary value, and that it will be immediately
+//     assigned to a WideString or a Variant, then we will save the
+//      Unicode result as well as a reference to the original Ansi string.
+//       WStrFromPCharLen() or VarFromLStr() will return this saved
+//        Unicode string if it appears to receive the most recent result
+//         of LoadResString.
+//--------------------------------------------------------------------
+
+
+  //===========================================================================================
+  //
+  //    function CodeMatchesPatternForUnicode(...);
+  //
+  //    GIVEN:  SomeWideString := SSomeResString;  { WideString := resourcestring }
+  //
+  //    Delphi will compile this statement into the following:
+  //    -------------------------------------------------
+  //    TempAnsiString := LoadResString(@SSomeResString);
+  //      LINE 1:  lea edx,[SomeTempAnsiString]
+  //      LINE 2:  mov eax,[@SomeResString]
+  //      LINE 3:  call LoadResString
+  //
+  //    WStrFromLStr(SomeWideString, TempAnsiString);  { SomeWideString := TempAnsiString }
+  //      LINE 4:  mov edx,[SomeTempAnsiString]
+  //      LINE 5:  mov/lea eax [@SomeWideString]
+  //      LINE 6:  call @WStrFromLStr
+  //    -------------------------------------------------
+  //
+  //    The order in which the parameters are prepared for WStrFromLStr (ie LINE 4 & 5) is
+  //      reversed when assigning a non-temporary AnsiString to a WideString.
+  //
+  //    This code, for example, results in LINE 4 and LINE 5 being swapped.
+  //
+  //      SomeAnsiString := SSomeResString;
+  //      SomeWideString := SomeAnsiString;
+  //
+  //    Since we know the "signature" used by the compiler, we can detect this pattern.
+  //     If we believe it is only temporary, we can save the Unicode results for later
+  //      retrieval from WStrFromLStr.
+  //
+  //    One final note:  When assigning a resourcestring to a Variant, the same patterns exist.
+  //===========================================================================================
+
+function CodeMatchesPatternForUnicode(PLine4: PAnsiChar): Boolean;
+const
+  SIZEOF_OPCODE = 1 {byte};
+  MOV_16_OPCODE = AnsiChar($8B); { we'll assume operand size is 16 bits }
+  MOV_32_OPCODE = AnsiChar($B8); { we'll assume operand size is 32 bits }
+  LEA_OPCODE    = AnsiChar($8D); { operand size can be 16 or 40 bits }
+  CALL_OPCODE   = AnsiChar($E8); { assumed operand size is 32 bits }
+  BREAK_OPCODE  = AnsiChar($CC); {in a breakpoint}
+var
+  PLine1: PAnsiChar;
+  PLine2: PAnsiChar;
+  PLine3: PAnsiChar;
+  DataSize: Integer; // bytes in first LEA operand
+begin
+  Result := False;
+
+  PLine3 := PLine4 - SizeOf(CALL_OPCODE) - 4;
+  PLine2 := PLine3 - SizeOf(MOV_32_OPCODE) - 4;
+
+  // figure PLine1 and operand size
+  DataSize := 2; { try 16 bit operand for line 1 }
+  PLine1 := PLine2 - DataSize - SizeOf(LEA_OPCODE);
+  if (PLine1^ <> LEA_OPCODE) and (not (IsDebugging and (PLine1^ = BREAK_OPCODE))) then
+  begin
+    DataSize := 5; { try 40 bit operand for line 1 }
+    PLine1 := PLine2 - DataSize - SizeOf(LEA_OPCODE);
+  end;
+  if (PLine1^ = LEA_OPCODE) or (IsDebugging and (PLine1^ = BREAK_OPCODE)) then
+  begin
+    if CompareMem(PLine1 + SIZEOF_OPCODE, PLine4 + SIZEOF_OPCODE, DataSize) then
+    begin
+      // After this check, it seems to match the WideString <- (temp) AnsiString pattern
+      Result := True; // It is probably OK. (The side effects of being wrong aren't very bad.)
+    end;
+  end;
+end;
+
+threadvar
+  PLastResString: PAnsiChar;
+  LastResStringValue: AnsiString;
+  LastWideResString: WideString;
+
+procedure FreeTntSystemThreadVars;
+begin
+  LastResStringValue := '';
+  LastWideResString := '';
+end;
+
+procedure Custom_System_EndThread(ExitCode: Integer);
+begin
+  FreeTntSystemThreadVars;
+  {$IFDEF COMPILER_10_UP}
+  if Assigned(SystemThreadEndProc) then
+    SystemThreadEndProc(ExitCode);
+  {$ENDIF}
+  ExitThread(ExitCode);
+end;
+
+function Custom_System_LoadResString(ResStringRec: PResStringRec): AnsiString;
+var
+  ReturnAddr: Pointer;
+begin
+  // get return address
+  asm
+    PUSH   ECX
+    MOV    ECX, [EBP + 4]
+    MOV    ReturnAddr, ECX
+    POP    ECX
+  end;
+  // check calling code pattern
+  if CodeMatchesPatternForUnicode(ReturnAddr) then begin
+    // result will probably be assigned to an intermediate AnsiString
+    //   on its way to either a WideString or Variant.
+    LastWideResString := WideLoadResString(ResStringRec);
+    Result := LastWideResString;
+    LastResStringValue := Result;
+    if Result = '' then
+      PLastResString := nil
+    else
+      PLastResString := PAnsiChar(Result);
+  end else begin
+    // result will probably be assigned to an actual AnsiString variable.
+    PLastResString := nil;
+    Result := WideLoadResString(ResStringRec);
+  end;
+end;
+
+//--------------------------------------------------------------------
+//                WStrFromPCharLen()
+//
+//  This system function is used to assign an AnsiString to a WideString.
+//   It has been modified to assign Unicode results from LoadResString.
+//     Another purpose of this function is to specify the code page.
+//--------------------------------------------------------------------
+
+procedure Custom_System_WStrFromPCharLen(var Dest: WideString; Source: PAnsiChar; Length: Integer);
+var
+  DestLen: Integer;
+  Buffer: array[0..2047] of WideChar;
+  Local_PLastResString: Pointer;
+begin
+  Local_PLastResString := PLastResString;
+  if  (Local_PLastResString <> nil)
+  and (Local_PLastResString = Source)
+  and (System.Length(LastResStringValue) = Length)
+  and (LastResStringValue = Source) then begin
+    // use last unicode resource string
+    PLastResString := nil; { clear for further use }
+    Dest := LastWideResString;
+  end else begin
+    if Local_PLastResString <> nil then
+      PLastResString := nil; { clear for further use }
+    if Length <= 0 then
+    begin
+      Dest := '';
+      Exit;
+    end;
+    if Length + 1 < High(Buffer) then
+    begin
+      DestLen := MultiByteToWideChar(DefaultSystemCodePage, 0, Source, Length, Buffer,
+        High(Buffer));
+      if DestLen > 0 then
+      begin
+        SetLength(Dest, DestLen);
+        Move(Pointer(@Buffer[0])^, Pointer(Dest)^, DestLen * SizeOf(WideChar));
+        Exit;
+      end;
+    end;
+    DestLen := (Length + 1);
+    SetLength(Dest, DestLen); // overallocate, trim later
+    DestLen := MultiByteToWideChar(DefaultSystemCodePage, 0, Source, Length, Pointer(Dest),
+      DestLen);
+    if DestLen < 0 then
+      DestLen := 0;
+    SetLength(Dest, DestLen);
+  end;
+end;
+
+{$IFNDEF COMPILER_9_UP}
+
+//--------------------------------------------------------------------
+//                LStrFromPWCharLen()
+//
+//  This system function is used to assign an WideString to an AnsiString.
+//   It has not been modified from its original purpose other than to specify the code page.
+//--------------------------------------------------------------------
+
+procedure Custom_System_LStrFromPWCharLen(var Dest: AnsiString; Source: PWideChar; Length: Integer);
+var
+  DestLen: Integer;
+  Buffer: array[0..4095] of AnsiChar;
+begin
+  if Length <= 0 then
+  begin
+    Dest := '';
+    Exit;
+  end;
+  if Length + 1 < (High(Buffer) div sizeof(WideChar)) then
+  begin
+    DestLen := WideCharToMultiByte(DefaultSystemCodePage, 0, Source,
+      Length, Buffer, High(Buffer),
+      nil, nil);
+    if DestLen >= 0 then
+    begin
+      SetLength(Dest, DestLen);
+      Move(Pointer(@Buffer[0])^, PAnsiChar(Dest)^, DestLen);
+      Exit;
+    end;
+  end;
+
+  DestLen := (Length + 1) * sizeof(WideChar);
+  SetLength(Dest, DestLen); // overallocate, trim later
+  DestLen := WideCharToMultiByte(DefaultSystemCodePage, 0, Source, Length, Pointer(Dest), DestLen,
+    nil, nil);
+  if DestLen < 0 then
+    DestLen := 0;
+  SetLength(Dest, DestLen);
+end;
+
+//--------------------------------------------------------------------
+//                WStrToString()
+//
+//  This system function is used to assign an WideString to an short string.
+//   It has not been modified from its original purpose other than to specify the code page.
+//--------------------------------------------------------------------
+
+procedure Custom_System_WStrToString(Dest: PShortString; const Source: WideString; MaxLen: Integer);
+var
+  SourceLen, DestLen: Integer;
+  Buffer: array[0..511] of AnsiChar;
+begin
+  if MaxLen > 255 then MaxLen := 255;
+  SourceLen := Length(Source);
+  if SourceLen >= MaxLen then SourceLen := MaxLen;
+  if SourceLen = 0 then
+    DestLen := 0
+  else begin
+    DestLen := WideCharToMultiByte(DefaultSystemCodePage, 0, Pointer(Source), SourceLen,
+      Buffer, SizeOf(Buffer), nil, nil);
+    if DestLen > MaxLen then DestLen := MaxLen;
+  end;
+  Dest^[0] := Chr(DestLen);
+  if DestLen > 0 then Move(Buffer, Dest^[1], DestLen);
+end;
+
+{$ENDIF}
+
+//--------------------------------------------------------------------
+//                VarFromLStr()
+//
+//  This system function is used to assign an AnsiString to a Variant.
+//   It has been modified to assign Unicode results from LoadResString.
+//--------------------------------------------------------------------
+
+procedure Custom_System_VarFromLStr(var V: TVarData; const Value: AnsiString);
+const
+  varDeepData = $BFE8;
+var
+  Local_PLastResString: Pointer;
+begin
+  if (V.VType and varDeepData) <> 0 then
+    VarClear(PVariant(@V)^);
+
+  Local_PLastResString := PLastResString;
+  if  (Local_PLastResString <> nil)
+  and (Local_PLastResString = PAnsiChar(Value))
+  and (LastResStringValue = Value) then begin
+    // use last unicode resource string
+    PLastResString := nil; { clear for further use }
+    V.VOleStr := nil;
+    V.VType := varOleStr;
+    WideString(Pointer(V.VOleStr)) := Copy(LastWideResString, 1, MaxInt);
+  end else begin
+    if Local_PLastResString <> nil then
+      PLastResString := nil; { clear for further use }
+    V.VString := nil;
+    V.VType := varString;
+    AnsiString(V.VString) := Value;
+  end;
+end;
+
+{$IFNDEF COMPILER_9_UP}
+
+//--------------------------------------------------------------------
+//                WStrCat3()     A := B + C;
+//
+//  This system function is used to concatenate two strings into one result.
+//    This function is added because A := '' + '' doesn't necessarily result in A = '';
+//--------------------------------------------------------------------
+
+procedure Custom_System_WStrCat3(var Dest: WideString; const Source1, Source2: WideString);
+
+  function NewWideString(CharLength: Longint): Pointer;
+  var
+    _NewWideString: function(CharLength: Longint): Pointer;
+  begin
+    asm
+      PUSH   ECX
+      MOV    ECX, offset System.@NewWideString;
+      MOV    _NewWideString, ECX
+      POP    ECX
+    end;
+    Result := _NewWideString(CharLength);
+  end;
+
+  procedure WStrSet(var S: WideString; P: PWideChar);
+  var
+    Temp: Pointer;
+  begin
+    Temp := Pointer(InterlockedExchange(Integer(S), Integer(P)));
+    if Temp <> nil then
+      WideString(Temp) := '';
+  end;
+
+var
+  Source1Len, Source2Len: Integer;
+  NewStr: PWideChar;
+begin
+  Source1Len := Length(Source1);
+  Source2Len := Length(Source2);
+  if (Source1Len <> 0) or (Source2Len <> 0) then
+  begin
+    NewStr := NewWideString(Source1Len + Source2Len);
+    Move(Pointer(Source1)^, Pointer(NewStr)^, Source1Len * sizeof(WideChar));
+    Move(Pointer(Source2)^, NewStr[Source1Len], Source2Len * sizeof(WideChar));
+    WStrSet(Dest, NewStr);
+  end else
+    Dest := '';
+end;
+
+{$ENDIF}
+
+//--------------------------------------------------------------------
+//                System proc replacements
+//--------------------------------------------------------------------
+
+type
+  POverwrittenData = ^TOverwrittenData;
+  TOverwrittenData = record
+    Location: Pointer;
+    OldCode: array[0..6] of Byte;
+  end;
+
+procedure OverwriteProcedure(OldProcedure, NewProcedure: pointer; Data: POverwrittenData = nil);
+{ OverwriteProcedure originally from Igor Siticov }
+{ Modified by Jacques Garcia Vazquez }
+var
+  x: PAnsiChar;
+  y: integer;
+  ov2, ov: cardinal;
+  p: pointer;
+begin
+  if Assigned(Data) and (Data.Location <> nil) then
+    exit; { procedure already overwritten }
+
+  // need six bytes in place of 5
+  x := PAnsiChar(OldProcedure);
+  if not VirtualProtect(Pointer(x), 6, PAGE_EXECUTE_READWRITE, @ov) then
+    RaiseLastOSError;
+
+  // if a jump is present then a redirect is found
+  // $FF25 = jmp dword ptr [xxx]
+  // This redirect is normally present in bpl files, but not in exe files
+  p := OldProcedure;
+
+  if Word(p^) = $25FF then
+  begin
+    Inc(Integer(p), 2); // skip the jump
+    // get the jump address p^ and dereference it p^^
+    p := Pointer(Pointer(p^)^);
+
+    // release the memory
+    if not VirtualProtect(Pointer(x), 6, ov, @ov2) then
+      RaiseLastOSError;
+
+    // re protect the correct one
+    x := PAnsiChar(p);
+    if not VirtualProtect(Pointer(x), 6, PAGE_EXECUTE_READWRITE, @ov) then
+      RaiseLastOSError;
+  end;
+
+  if Assigned(Data) then
+  begin
+    Move(x^, Data.OldCode, 6);
+    { Assign Location last so that Location <> nil only if OldCode is properly initialized. }
+    Data.Location := x;
+  end;
+
+  x[0] := AnsiChar($E9);
+  y := integer(NewProcedure) - integer(p) - 5;
+  x[1] := AnsiChar(y and 255);
+  x[2] := AnsiChar((y shr 8) and 255);
+  x[3] := AnsiChar((y shr 16) and 255);
+  x[4] := AnsiChar((y shr 24) and 255);
+
+  if not VirtualProtect(Pointer(x), 6, ov, @ov2) then
+    RaiseLastOSError;
+end;
+
+procedure RestoreProcedure(OriginalProc: Pointer; Data: TOverwrittenData);
+var
+  ov, ov2: Cardinal;
+begin
+  if Data.Location <> nil then begin
+    if not VirtualProtect(Data.Location, 6, PAGE_EXECUTE_READWRITE, @ov) then
+      RaiseLastOSError;
+    Move(Data.OldCode, Data.Location^, 6);
+    if not VirtualProtect(Data.Location, 6, ov, @ov2) then
+      RaiseLastOSError;
+  end;
+end;
+
+function Addr_System_EndThread: Pointer;
+begin
+  Result := @System.EndThread;
+end;
+
+function Addr_System_LoadResString: Pointer;
+begin
+  Result := @System.LoadResString{TNT-ALLOW LoadResString};
+end;
+
+function Addr_System_WStrFromPCharLen: Pointer;
+asm
+  mov eax, offset System.@WStrFromPCharLen;
+end;
+
+{$IFNDEF COMPILER_9_UP}
+function Addr_System_LStrFromPWCharLen: Pointer;
+asm
+  mov eax, offset System.@LStrFromPWCharLen;
+end;
+
+function Addr_System_WStrToString: Pointer;
+asm
+  mov eax, offset System.@WStrToString;
+end;
+{$ENDIF}
+
+function Addr_System_VarFromLStr: Pointer;
+asm
+  mov eax, offset System.@VarFromLStr;
+end;
+
+function Addr_System_WStrCat3: Pointer;
+asm
+  mov eax, offset System.@WStrCat3;
+end;
+
+var
+  System_EndThread_Code,
+  System_LoadResString_Code,
+  System_WStrFromPCharLen_Code,
+  {$IFNDEF COMPILER_9_UP}
+  System_LStrFromPWCharLen_Code,
+  System_WStrToString_Code,
+  {$ENDIF}
+  System_VarFromLStr_Code
+  {$IFNDEF COMPILER_9_UP}
+  ,
+  System_WStrCat3_Code,
+  SysUtils_WideFmtStr_Code
+  {$ENDIF}
+  : TOverwrittenData;
+
+procedure InstallEndThreadOverride;
+begin
+  OverwriteProcedure(Addr_System_EndThread,  @Custom_System_EndThread,  @System_EndThread_Code);
+end;
+
+procedure InstallStringConversionOverrides;
+begin
+  OverwriteProcedure(Addr_System_WStrFromPCharLen,  @Custom_System_WStrFromPCharLen,  @System_WStrFromPCharLen_Code);
+  {$IFNDEF COMPILER_9_UP}
+  OverwriteProcedure(Addr_System_LStrFromPWCharLen, @Custom_System_LStrFromPWCharLen, @System_LStrFromPWCharLen_Code);
+  OverwriteProcedure(Addr_System_WStrToString,      @Custom_System_WStrToString,      @System_WStrToString_Code);
+  {$ENDIF}
+end;
+
+procedure InstallWideResourceStrings;
+begin
+  OverwriteProcedure(Addr_System_LoadResString,     @Custom_System_LoadResString,     @System_LoadResString_Code);
+  OverwriteProcedure(Addr_System_VarFromLStr,       @Custom_System_VarFromLStr,       @System_VarFromLStr_Code);
+end;
+
+{$IFNDEF COMPILER_9_UP}
+procedure InstallWideStringConcatenationFix;
+begin
+  OverwriteProcedure(Addr_System_WStrCat3,          @Custom_System_WStrCat3,          @System_WStrCat3_Code);
+end;
+
+procedure InstallWideFormatFixes;
+begin
+  OverwriteProcedure(@SysUtils.WideFmtStr, @TntSysUtils.Tnt_WideFmtStr, @SysUtils_WideFmtStr_Code);
+end;
+{$ENDIF}
+
+procedure InstallTntSystemUpdates(Updates: TTntSystemUpdateSet = AllTntSystemUpdates);
+begin
+  InstallEndThreadOverride;
+  if tsWideResourceStrings in Updates then begin
+    InstallStringConversionOverrides;
+    InstallWideResourceStrings;
+  end;
+  {$IFNDEF COMPILER_9_UP}
+    if tsFixImplicitCodePage in Updates then begin
+      InstallStringConversionOverrides;
+      { CP_ACP is the code page used by the non-Unicode Windows API. }
+      GDefaultSystemCodePage := CP_ACP{TNT-ALLOW CP_ACP};
+    end;
+    if tsFixWideStrConcat in Updates then begin
+      InstallWideStringConcatenationFix;
+    end;
+    if tsFixWideFormat in Updates then begin
+      InstallWideFormatFixes;
+    end;
+  {$ENDIF}
+end;
+
+{$IFNDEF COMPILER_9_UP}
+var
+  StartupDefaultUserCodePage: Cardinal;
+{$ENDIF}
+
+procedure UninstallSystemOverrides;
+begin
+  RestoreProcedure(Addr_System_EndThread,  System_EndThread_Code);
+  // String Conversion
+  RestoreProcedure(Addr_System_WStrFromPCharLen,  System_WStrFromPCharLen_Code);
+  {$IFNDEF COMPILER_9_UP}
+  RestoreProcedure(Addr_System_LStrFromPWCharLen, System_LStrFromPWCharLen_Code);
+  RestoreProcedure(Addr_System_WStrToString,      System_WStrToString_Code);
+  GDefaultSystemCodePage := StartupDefaultUserCodePage;
+  {$ENDIF}
+  // Wide resourcestring
+  RestoreProcedure(Addr_System_LoadResString,     System_LoadResString_Code);
+  RestoreProcedure(Addr_System_VarFromLStr,       System_VarFromLStr_Code);
+  {$IFNDEF COMPILER_9_UP}
+  // WideString concat fix
+  RestoreProcedure(Addr_System_WStrCat3,          System_WStrCat3_Code);
+  // WideFormat fixes
+  RestoreProcedure(@SysUtils.WideFmtStr, SysUtils_WideFmtStr_Code);
+  {$ENDIF}
+end;
+
+{$ENDIF USE_SYSTEM_OVERRIDES}
+
+initialization
+  {$IFDEF COMPILER_9_UP}
+    {$DEFINE USE_GETACP}
+  {$ENDIF}
+  {$IFDEF FPC}
+    {$DEFINE USE_GETACP}
+  {$ENDIF}
+  {$IFDEF USE_GETACP}
+  GDefaultSystemCodePage := GetACP;
+  {$ELSE}
+    {$IFDEF COMPILER_7_UP}
+    if (Win32Platform = VER_PLATFORM_WIN32_NT) and (Win32MajorVersion >= 5) then
+      GDefaultSystemCodePage := CP_THREAD_ACP // Win 2K/XP/...
+    else
+      GDefaultSystemCodePage := LCIDToCodePage(GetThreadLocale); // Win NT4/95/98/ME
+    {$ELSE}
+    GDefaultSystemCodePage := CP_ACP{TNT-ALLOW CP_ACP};
+    {$ENDIF}
+  {$ENDIF}
+  {$IFDEF USE_SYSTEM_OVERRIDES}
+  {$IFNDEF COMPILER_9_UP}
+  StartupDefaultUserCodePage := DefaultSystemCodePage;
+  {$ENDIF}
+  IsDebugging := DebugHook > 0;
+  {$ENDIF USE_SYSTEM_OVERRIDES}
+
+finalization
+  {$IFDEF USE_SYSTEM_OVERRIDES}
+  UninstallSystemOverrides;
+  FreeTntSystemThreadVars; { Make MemorySleuth happy. }
+  {$ENDIF USE_SYSTEM_OVERRIDES}
+
+end.
diff --git a/Lua/src/lib/TntUnicodeControls/TntWideStrUtils.pas b/Lua/src/lib/TntUnicodeControls/TntWideStrUtils.pas
new file mode 100644
index 00000000..99f63aea
--- /dev/null
+++ b/Lua/src/lib/TntUnicodeControls/TntWideStrUtils.pas
@@ -0,0 +1,455 @@
+
+{*****************************************************************************}
+{                                                                             }
+{    Tnt Delphi Unicode Controls                                              }
+{      http://www.tntware.com/delphicontrols/unicode/                         }
+{        Version: 2.3.0                                                       }
+{                                                                             }
+{    Copyright (c) 2002-2007, Troy Wolbrink (troy.wolbrink@tntware.com)       }
+{                                                                             }
+{*****************************************************************************}
+
+unit TntWideStrUtils;
+
+{$IFDEF FPC}
+  {$MODE Delphi}
+{$ENDIF}
+
+{$INCLUDE TntCompilers.inc}
+
+interface
+
+{ Wide string manipulation functions }
+
+{$IFNDEF COMPILER_9_UP}
+function WStrAlloc(Size: Cardinal): PWideChar;
+function WStrBufSize(const Str: PWideChar): Cardinal;
+{$ENDIF}
+{$IFNDEF COMPILER_10_UP}
+function WStrMove(Dest: PWideChar; const Source: PWideChar; Count: Cardinal): PWideChar;
+{$ENDIF}
+{$IFNDEF COMPILER_9_UP}
+function WStrNew(const Str: PWideChar): PWideChar;
+procedure WStrDispose(Str: PWideChar);
+{$ENDIF}
+//---------------------------------------------------------------------------------------------
+{$IFNDEF COMPILER_9_UP}
+function WStrLen(Str: PWideChar): Cardinal;
+function WStrEnd(Str: PWideChar): PWideChar;
+{$ENDIF}
+{$IFNDEF COMPILER_10_UP}
+function WStrCat(Dest: PWideChar; const Source: PWideChar): PWideChar;
+{$ENDIF}
+{$IFNDEF COMPILER_9_UP}
+function WStrCopy(Dest, Source: PWideChar): PWideChar;
+function WStrLCopy(Dest, Source: PWideChar; MaxLen: Cardinal): PWideChar;
+function WStrPCopy(Dest: PWideChar; const Source: WideString): PWideChar;
+function WStrPLCopy(Dest: PWideChar; const Source: WideString; MaxLen: Cardinal): PWideChar;
+{$ENDIF}
+{$IFNDEF COMPILER_10_UP}
+function WStrScan(const Str: PWideChar; Chr: WideChar): PWideChar;
+// WStrComp and WStrPos were introduced as broken in Delphi 2006, but fixed in Delphi 2006 Update 2
+function WStrComp(Str1, Str2: PWideChar): Integer;
+function WStrPos(Str, SubStr: PWideChar): PWideChar;
+{$ENDIF}
+function Tnt_WStrComp(Str1, Str2: PWideChar): Integer; deprecated;
+function Tnt_WStrPos(Str, SubStr: PWideChar): PWideChar; deprecated;
+
+{ ------------ introduced --------------- }
+function WStrECopy(Dest, Source: PWideChar): PWideChar;
+function WStrLComp(Str1, Str2: PWideChar; MaxLen: Cardinal): Integer;
+function WStrLIComp(Str1, Str2: PWideChar; MaxLen: Cardinal): Integer;
+function WStrIComp(Str1, Str2: PWideChar): Integer;
+function WStrLower(Str: PWideChar): PWideChar;
+function WStrUpper(Str: PWideChar): PWideChar;
+function WStrRScan(const Str: PWideChar; Chr: WideChar): PWideChar;
+function WStrLCat(Dest: PWideChar; const Source: PWideChar; MaxLen: Cardinal): PWideChar;
+function WStrPas(const Str: PWideChar): WideString;
+
+{ SysUtils.pas } //-------------------------------------------------------------------------
+
+{$IFNDEF COMPILER_10_UP}
+function WideLastChar(const S: WideString): PWideChar;
+function WideQuotedStr(const S: WideString; Quote: WideChar): WideString;
+{$ENDIF}
+{$IFNDEF COMPILER_9_UP}
+function WideExtractQuotedStr(var Src: PWideChar; Quote: WideChar): Widestring;
+{$ENDIF}
+{$IFNDEF COMPILER_10_UP}
+function WideDequotedStr(const S: WideString; AQuote: WideChar): WideString;
+{$ENDIF}
+
+implementation
+
+uses
+  {$IFDEF COMPILER_9_UP} WideStrUtils, {$ENDIF} Math, Windows, TntWindows;
+
+{$IFNDEF COMPILER_9_UP}
+function WStrAlloc(Size: Cardinal): PWideChar;
+begin
+  Size := SizeOf(Cardinal) + (Size * SizeOf(WideChar));
+  GetMem(Result, Size);
+  PCardinal(Result)^ := Size;
+  Inc(PAnsiChar(Result), SizeOf(Cardinal));
+end;
+
+function WStrBufSize(const Str: PWideChar): Cardinal;
+var
+  P: PWideChar;
+begin
+  P := Str;
+  Dec(PAnsiChar(P), SizeOf(Cardinal));
+  Result := PCardinal(P)^ - SizeOf(Cardinal);
+  Result := Result div SizeOf(WideChar);
+end;
+{$ENDIF}
+
+{$IFNDEF COMPILER_10_UP}
+function WStrMove(Dest: PWideChar; const Source: PWideChar; Count: Cardinal): PWideChar;
+var
+  Length: Integer;
+begin
+  Result := Dest;
+  Length := Count * SizeOf(WideChar);
+  Move(Source^, Dest^, Length);
+end;
+{$ENDIF}
+
+{$IFNDEF COMPILER_9_UP}
+function WStrNew(const Str: PWideChar): PWideChar;
+var
+  Size: Cardinal;
+begin
+  if Str = nil then Result := nil else
+  begin
+    Size := WStrLen(Str) + 1;
+    Result := WStrMove(WStrAlloc(Size), Str, Size);
+  end;
+end;
+
+procedure WStrDispose(Str: PWideChar);
+begin
+  if Str <> nil then
+  begin
+    Dec(PAnsiChar(Str), SizeOf(Cardinal));
+    FreeMem(Str, Cardinal(Pointer(Str)^));
+  end;
+end;
+{$ENDIF}
+
+//---------------------------------------------------------------------------------------------
+
+{$IFNDEF COMPILER_9_UP}
+function WStrLen(Str: PWideChar): Cardinal;
+begin
+  Result := WStrEnd(Str) - Str;
+end;
+
+function WStrEnd(Str: PWideChar): PWideChar;
+begin
+  // returns a pointer to the end of a null terminated string
+  Result := Str;
+  While Result^ <> #0 do
+    Inc(Result);
+end;
+{$ENDIF}
+
+{$IFNDEF COMPILER_10_UP}
+function WStrCat(Dest: PWideChar; const Source: PWideChar): PWideChar;
+begin
+  Result := Dest;
+  WStrCopy(WStrEnd(Dest), Source);
+end;
+{$ENDIF}
+
+{$IFNDEF COMPILER_9_UP}
+function WStrCopy(Dest, Source: PWideChar): PWideChar;
+begin
+  Result := WStrLCopy(Dest, Source, MaxInt);
+end;
+
+function WStrLCopy(Dest, Source: PWideChar; MaxLen: Cardinal): PWideChar;
+var
+  Count: Cardinal;
+begin
+  // copies a specified maximum number of characters from Source to Dest
+  Result := Dest;
+  Count := 0;
+  While (Count < MaxLen) and (Source^ <> #0) do begin
+    Dest^ := Source^;
+    Inc(Source);
+    Inc(Dest);
+    Inc(Count);
+  end;
+  Dest^ := #0;
+end;
+
+function WStrPCopy(Dest: PWideChar; const Source: WideString): PWideChar;
+begin
+  Result := WStrLCopy(Dest, PWideChar(Source), Length(Source));
+end;
+
+function WStrPLCopy(Dest: PWideChar; const Source: WideString; MaxLen: Cardinal): PWideChar;
+begin
+  Result := WStrLCopy(Dest, PWideChar(Source), MaxLen);
+end;
+{$ENDIF}
+
+{$IFNDEF COMPILER_10_UP}
+function WStrScan(const Str: PWideChar; Chr: WideChar): PWideChar;
+begin
+  Result := Str;
+  while Result^ <> Chr do
+  begin
+    if Result^ = #0 then
+    begin
+      Result := nil;
+      Exit;
+    end;
+    Inc(Result);
+  end;
+end;
+
+function WStrComp(Str1, Str2: PWideChar): Integer;
+begin
+  Result := WStrLComp(Str1, Str2, MaxInt);
+end;
+
+function WStrPos(Str, SubStr: PWideChar): PWideChar;
+var
+  PSave: PWideChar;
+  P: PWideChar;
+  PSub: PWideChar;
+begin
+  // returns a pointer to the first occurance of SubStr in Str
+  Result := nil;
+  if (Str <> nil) and (Str^ <> #0) and (SubStr <> nil) and (SubStr^ <> #0) then begin
+    P := Str;
+    While P^ <> #0 do begin
+      if P^ = SubStr^ then begin
+        // investigate possibility here
+        PSave := P;
+        PSub := SubStr;
+        While (P^ = PSub^) do begin
+          Inc(P);
+          Inc(PSub);
+          if (PSub^ = #0) then begin
+            Result := PSave;
+            exit; // found a match
+          end;
+          if (P^ = #0) then
+            exit; // no match, hit end of string
+        end;
+        P := PSave;
+      end;
+      Inc(P);
+    end;
+  end;
+end;
+{$ENDIF}
+
+function Tnt_WStrComp(Str1, Str2: PWideChar): Integer; deprecated;
+begin
+  Result := WStrComp(Str1, Str2);
+end;
+
+function Tnt_WStrPos(Str, SubStr: PWideChar): PWideChar; deprecated;
+begin
+  Result := WStrPos(Str, SubStr);
+end;
+
+//------------------------------------------------------------------------------
+
+function WStrECopy(Dest, Source: PWideChar): PWideChar;
+begin
+  Result := WStrEnd(WStrCopy(Dest, Source));
+end;
+
+function WStrComp_EX(Str1, Str2: PWideChar; MaxLen: Cardinal; dwCmpFlags: Cardinal): Integer;
+var
+  Len1, Len2: Integer;
+begin
+  if MaxLen = Cardinal(MaxInt) then begin
+    Len1 := -1;
+    Len2 := -1;
+  end else begin
+    Len1 := Min(WStrLen(Str1), MaxLen);
+    Len2 := Min(WStrLen(Str2), MaxLen);
+  end;
+  Result := Tnt_CompareStringW(GetThreadLocale, dwCmpFlags, Str1, Len1, Str2, Len2) - 2;
+end;
+
+function WStrLComp(Str1, Str2: PWideChar; MaxLen: Cardinal): Integer;
+begin
+  Result := WStrComp_EX(Str1, Str2, MaxLen, 0);
+end;
+
+function WStrLIComp(Str1, Str2: PWideChar; MaxLen: Cardinal): Integer;
+begin
+  Result := WStrComp_EX(Str1, Str2, MaxLen, NORM_IGNORECASE);
+end;
+
+function WStrIComp(Str1, Str2: PWideChar): Integer;
+begin
+  Result := WStrLIComp(Str1, Str2, MaxInt);
+end;
+
+function WStrLower(Str: PWideChar): PWideChar;
+begin
+  Result := Str;
+  Tnt_CharLowerBuffW(Str, WStrLen(Str))
+end;
+
+function WStrUpper(Str: PWideChar): PWideChar;
+begin
+  Result := Str;
+  Tnt_CharUpperBuffW(Str, WStrLen(Str))
+end;
+
+function WStrRScan(const Str: PWideChar; Chr: WideChar): PWideChar;
+var
+  MostRecentFound: PWideChar;
+begin
+  if Chr = #0 then
+    Result := WStrEnd(Str)
+  else
+  begin
+    Result := nil;
+    MostRecentFound := Str;
+    while True do
+    begin
+      while MostRecentFound^ <> Chr do
+      begin
+        if MostRecentFound^ = #0 then
+          Exit;
+        Inc(MostRecentFound);
+      end;
+      Result := MostRecentFound;
+      Inc(MostRecentFound);
+    end;
+  end;
+end;
+
+function WStrLCat(Dest: PWideChar; const Source: PWideChar; MaxLen: Cardinal): PWideChar;
+begin
+  Result := Dest;
+  WStrLCopy(WStrEnd(Dest), Source, MaxLen - WStrLen(Dest));
+end;
+
+function WStrPas(const Str: PWideChar): WideString;
+begin
+  Result := Str;
+end;
+
+//---------------------------------------------------------------------------------------------
+
+{$IFNDEF COMPILER_10_UP}
+function WideLastChar(const S: WideString): PWideChar;
+begin
+  if S = '' then
+    Result := nil
+  else
+    Result := @S[Length(S)];
+end;
+
+function WideQuotedStr(const S: WideString; Quote: WideChar): WideString;
+var
+  P, Src,
+  Dest: PWideChar;
+  AddCount: Integer;
+begin
+  AddCount := 0;
+  P := WStrScan(PWideChar(S), Quote);
+  while (P <> nil) do
+  begin
+    Inc(P);
+    Inc(AddCount);
+    P := WStrScan(P, Quote);
+  end;
+
+  if AddCount = 0 then
+    Result := Quote + S + Quote
+  else
+  begin
+    SetLength(Result, Length(S) + AddCount + 2);
+    Dest := PWideChar(Result);
+    Dest^ := Quote;
+    Inc(Dest);
+    Src := PWideChar(S);
+    P := WStrScan(Src, Quote);
+    repeat
+      Inc(P);
+      Move(Src^, Dest^, 2 * (P - Src));
+      Inc(Dest, P - Src);
+      Dest^ := Quote;
+      Inc(Dest);
+      Src := P;
+      P := WStrScan(Src, Quote);
+    until P = nil;
+    P := WStrEnd(Src);
+    Move(Src^, Dest^, 2 * (P - Src));
+    Inc(Dest, P - Src);
+    Dest^ := Quote;
+  end;
+end;
+{$ENDIF}
+
+{$IFNDEF COMPILER_9_UP}
+function WideExtractQuotedStr(var Src: PWideChar; Quote: WideChar): Widestring;
+var
+  P, Dest: PWideChar;
+  DropCount: Integer;
+begin
+  Result := '';
+  if (Src = nil) or (Src^ <> Quote) then Exit;
+  Inc(Src);
+  DropCount := 1;
+  P := Src;
+  Src := WStrScan(Src, Quote);
+  while Src <> nil do   // count adjacent pairs of quote chars
+  begin
+    Inc(Src);
+    if Src^ <> Quote then Break;
+    Inc(Src);
+    Inc(DropCount);
+    Src := WStrScan(Src, Quote);
+  end;
+  if Src = nil then Src := WStrEnd(P);
+  if ((Src - P) <= 1) then Exit;
+  if DropCount = 1 then
+    SetString(Result, P, Src - P - 1)
+  else
+  begin
+    SetLength(Result, Src - P - DropCount);
+    Dest := PWideChar(Result);
+    Src := WStrScan(P, Quote);
+    while Src <> nil do
+    begin
+      Inc(Src);
+      if Src^ <> Quote then Break;
+      Move(P^, Dest^, (Src - P) * SizeOf(WideChar));
+      Inc(Dest, Src - P);
+      Inc(Src);
+      P := Src;
+      Src := WStrScan(Src, Quote);
+    end;
+    if Src = nil then Src := WStrEnd(P);
+    Move(P^, Dest^, (Src - P - 1) * SizeOf(WideChar));
+  end;
+end;
+{$ENDIF}
+
+{$IFNDEF COMPILER_10_UP}
+function WideDequotedStr(const S: WideString; AQuote: WideChar): WideString;
+var
+  LText : PWideChar;
+begin
+  LText := PWideChar(S);
+  Result := WideExtractQuotedStr(LText, AQuote);
+  if Result = '' then
+    Result := S;
+end;
+{$ENDIF}
+
+
+end.
diff --git a/Lua/src/lib/TntUnicodeControls/TntWideStrings.pas b/Lua/src/lib/TntUnicodeControls/TntWideStrings.pas
new file mode 100644
index 00000000..75132d22
--- /dev/null
+++ b/Lua/src/lib/TntUnicodeControls/TntWideStrings.pas
@@ -0,0 +1,846 @@
+
+{*****************************************************************************}
+{                                                                             }
+{    Tnt Delphi Unicode Controls                                              }
+{      http://www.tntware.com/delphicontrols/unicode/                         }
+{        Version: 2.3.0                                                       }
+{                                                                             }
+{    Copyright (c) 2002-2007, Troy Wolbrink (troy.wolbrink@tntware.com)       }
+{                                                                             }
+{*****************************************************************************}
+
+unit TntWideStrings;
+
+{$IFDEF FPC}
+  {$MODE Delphi}
+{$ENDIF}
+
+{$INCLUDE TntCompilers.inc}
+
+interface
+
+{$IFDEF COMPILER_10_UP}
+  {$MESSAGE FATAL 'Do not refer to TntWideStrings.pas.  It works correctly in Delphi 2006.'}
+{$ENDIF}
+
+uses
+  Classes;
+
+{******************************************************************************}
+{                                                                              }
+{  Delphi 2005 introduced TWideStrings in WideStrings.pas.                     }
+{    Unfortunately, it was not ready for prime time.                           }
+{      Setting CommaText is not consistent, and it relies on CharNextW         }
+{         Which is only available on Windows NT+.                              }
+{                                                                              }
+{******************************************************************************}
+
+type
+  TWideStrings = class;
+
+{ IWideStringsAdapter interface }
+{ Maintains link between TWideStrings and IWideStrings implementations }
+
+  IWideStringsAdapter = interface
+    ['{25FE0E3B-66CB-48AA-B23B-BCFA67E8F5DA}']
+    procedure ReferenceStrings(S: TWideStrings);
+    procedure ReleaseStrings;
+  end;
+
+  TWideStringsEnumerator = class
+  private
+    FIndex: Integer;
+    FStrings: TWideStrings;
+  public
+    constructor Create(AStrings: TWideStrings);
+    function GetCurrent: WideString;
+    function MoveNext: Boolean;
+    property Current: WideString read GetCurrent;
+  end;
+
+{$IFDEF FPC}
+  TStringsDefined = set of (
+    sdDelimiter, sdQuoteChar, sdNameValueSeparator, sdLineBreak,
+    sdStrictDelimiter);
+{$ENDIF}
+
+{$DEFINE NAMEVALUESEPARATOR_RW}
+{$IFNDEF COMPILER_7_UP}
+  {$UNDEF NAMEVALUESEPARATOR_RW}
+{$ENDIF}
+
+{ TWideStrings class }
+
+  TWideStrings = class(TPersistent)
+  private
+    FDefined: TStringsDefined;
+    FDelimiter: WideChar;
+    FQuoteChar: WideChar;
+    {$IFDEF NAMEVALUESEPARATOR_RW}
+    FNameValueSeparator: WideChar;
+    {$ENDIF}
+    FUpdateCount: Integer;
+    FAdapter: IWideStringsAdapter;
+    function GetCommaText: WideString;
+    function GetDelimitedText: WideString;
+    function GetName(Index: Integer): WideString;
+    function GetValue(const Name: WideString): WideString;
+    procedure ReadData(Reader: TReader);
+    procedure SetCommaText(const Value: WideString);
+    procedure SetDelimitedText(const Value: WideString);
+    procedure SetStringsAdapter(const Value: IWideStringsAdapter);
+    procedure SetValue(const Name, Value: WideString);
+    procedure WriteData(Writer: TWriter);
+    function GetDelimiter: WideChar;
+    procedure SetDelimiter(const Value: WideChar);
+    function GetQuoteChar: WideChar;
+    procedure SetQuoteChar(const Value: WideChar);
+    function GetNameValueSeparator: WideChar;
+    {$IFDEF NAMEVALUESEPARATOR_RW}
+    procedure SetNameValueSeparator(const Value: WideChar);
+    {$ENDIF}
+    function GetValueFromIndex(Index: Integer): WideString;
+    procedure SetValueFromIndex(Index: Integer; const Value: WideString);
+  protected
+    procedure AssignTo(Dest: TPersistent); override;
+    procedure DefineProperties(Filer: TFiler); override;
+    procedure Error(const Msg: WideString; Data: Integer); overload;
+    procedure Error(Msg: PResStringRec; Data: Integer); overload;
+    function ExtractName(const S: WideString): WideString;
+    function Get(Index: Integer): WideString; virtual; abstract;
+    function GetCapacity: Integer; virtual;
+    function GetCount: Integer; virtual; abstract;
+    function GetObject(Index: Integer): TObject; virtual;
+    function GetTextStr: WideString; virtual;
+    procedure Put(Index: Integer; const S: WideString); virtual;
+    procedure PutObject(Index: Integer; AObject: TObject); virtual;
+    procedure SetCapacity(NewCapacity: Integer); virtual;
+    procedure SetTextStr(const Value: WideString); virtual;
+    procedure SetUpdateState(Updating: Boolean); virtual;
+    property UpdateCount: Integer read FUpdateCount;
+    function CompareStrings(const S1, S2: WideString): Integer; virtual;
+  public
+    destructor Destroy; override;
+    function Add(const S: WideString): Integer; virtual;
+    function AddObject(const S: WideString; AObject: TObject): Integer; virtual;
+    procedure Append(const S: WideString);
+    procedure AddStrings(Strings: TStrings{TNT-ALLOW TStrings}); overload; virtual;
+    procedure AddStrings(Strings: TWideStrings); overload; virtual;
+    procedure Assign(Source: TPersistent); override;
+    procedure BeginUpdate;
+    procedure Clear; virtual; abstract;
+    procedure Delete(Index: Integer); virtual; abstract;
+    procedure EndUpdate;
+    function Equals(Strings: TWideStrings): Boolean;
+    procedure Exchange(Index1, Index2: Integer); virtual;
+    function GetEnumerator: TWideStringsEnumerator;
+    function GetTextW: PWideChar; virtual;
+    function IndexOf(const S: WideString): Integer; virtual;
+    function IndexOfName(const Name: WideString): Integer; virtual;
+    function IndexOfObject(AObject: TObject): Integer; virtual;
+    procedure Insert(Index: Integer; const S: WideString); virtual; abstract;
+    procedure InsertObject(Index: Integer; const S: WideString;
+      AObject: TObject); virtual;
+    procedure LoadFromFile(const FileName: WideString); virtual;
+    procedure LoadFromStream(Stream: TStream); virtual;
+    procedure Move(CurIndex, NewIndex: Integer); virtual;
+    procedure SaveToFile(const FileName: WideString); virtual;
+    procedure SaveToStream(Stream: TStream); virtual;
+    procedure SetTextW(const Text: PWideChar); virtual;
+    property Capacity: Integer read GetCapacity write SetCapacity;
+    property CommaText: WideString read GetCommaText write SetCommaText;
+    property Count: Integer read GetCount;
+    property Delimiter: WideChar read GetDelimiter write SetDelimiter;
+    property DelimitedText: WideString read GetDelimitedText write SetDelimitedText;
+    property Names[Index: Integer]: WideString read GetName;
+    property Objects[Index: Integer]: TObject read GetObject write PutObject;
+    property QuoteChar: WideChar read GetQuoteChar write SetQuoteChar;
+    property Values[const Name: WideString]: WideString read GetValue write SetValue;
+    property ValueFromIndex[Index: Integer]: WideString read GetValueFromIndex write SetValueFromIndex;
+    property NameValueSeparator: WideChar read GetNameValueSeparator {$IFDEF NAMEVALUESEPARATOR_RW} write SetNameValueSeparator {$ENDIF};
+    property Strings[Index: Integer]: WideString read Get write Put; default;
+    property Text: WideString read GetTextStr write SetTextStr;
+    property StringsAdapter: IWideStringsAdapter read FAdapter write SetStringsAdapter;
+  end;
+
+  PWideStringItem = ^TWideStringItem;
+  TWideStringItem = record
+    FString: WideString;
+    FObject: TObject;
+  end;
+
+  PWideStringItemList = ^TWideStringItemList;
+  TWideStringItemList = array[0..MaxListSize] of TWideStringItem;
+
+implementation
+
+uses
+  Windows, SysUtils, TntSystem, {$IFDEF COMPILER_9_UP} WideStrUtils, {$ELSE} TntWideStrUtils, {$ENDIF}
+  TntSysUtils, TntClasses;
+
+{ TWideStringsEnumerator }
+
+constructor TWideStringsEnumerator.Create(AStrings: TWideStrings);
+begin
+  inherited Create;
+  FIndex := -1;
+  FStrings := AStrings;
+end;
+
+function TWideStringsEnumerator.GetCurrent: WideString;
+begin
+  Result := FStrings[FIndex];
+end;
+
+function TWideStringsEnumerator.MoveNext: Boolean;
+begin
+  Result := FIndex < FStrings.Count - 1;
+  if Result then
+    Inc(FIndex);
+end;
+
+{ TWideStrings }
+
+destructor TWideStrings.Destroy;
+begin
+  StringsAdapter := nil;
+  inherited;
+end;
+
+function TWideStrings.Add(const S: WideString): Integer;
+begin
+  Result := GetCount;
+  Insert(Result, S);
+end;
+
+function TWideStrings.AddObject(const S: WideString; AObject: TObject): Integer;
+begin
+  Result := Add(S);
+  PutObject(Result, AObject);
+end;
+
+procedure TWideStrings.Append(const S: WideString);
+begin
+  Add(S);
+end;
+
+procedure TWideStrings.AddStrings(Strings: TStrings{TNT-ALLOW TStrings});
+var
+  I: Integer;
+begin
+  BeginUpdate;
+  try
+    for I := 0 to Strings.Count - 1 do
+      AddObject(Strings[I], Strings.Objects[I]);
+  finally
+    EndUpdate;
+  end;
+end;
+
+procedure TWideStrings.AddStrings(Strings: TWideStrings);
+var
+  I: Integer;
+begin
+  BeginUpdate;
+  try
+    for I := 0 to Strings.Count - 1 do
+      AddObject(Strings[I], Strings.Objects[I]);
+  finally
+    EndUpdate;
+  end;
+end;
+
+procedure TWideStrings.Assign(Source: TPersistent);
+begin
+  if Source is TWideStrings then
+  begin
+    BeginUpdate;
+    try
+      Clear;
+      FDefined := TWideStrings(Source).FDefined;
+      {$IFDEF NAMEVALUESEPARATOR_RW}
+      FNameValueSeparator := TWideStrings(Source).FNameValueSeparator;
+      {$ENDIF}
+      FQuoteChar := TWideStrings(Source).FQuoteChar;
+      FDelimiter := TWideStrings(Source).FDelimiter;
+      AddStrings(TWideStrings(Source));
+    finally
+      EndUpdate;
+    end;
+  end
+  else if Source is TStrings{TNT-ALLOW TStrings} then
+  begin
+    BeginUpdate;
+    try
+      Clear;
+      {$IFDEF NAMEVALUESEPARATOR_RW}
+      FNameValueSeparator := WideChar(TStrings{TNT-ALLOW TStrings}(Source).NameValueSeparator);
+      {$ENDIF}
+      FQuoteChar := WideChar(TStrings{TNT-ALLOW TStrings}(Source).QuoteChar);
+      FDelimiter := WideChar(TStrings{TNT-ALLOW TStrings}(Source).Delimiter);
+      AddStrings(TStrings{TNT-ALLOW TStrings}(Source));
+    finally
+      EndUpdate;
+    end;
+  end
+  else
+    inherited Assign(Source);
+end;
+
+procedure TWideStrings.AssignTo(Dest: TPersistent);
+var
+  I: Integer;
+begin
+  if Dest is TWideStrings then Dest.Assign(Self)
+  else if Dest is TStrings{TNT-ALLOW TStrings} then
+  begin
+    TStrings{TNT-ALLOW TStrings}(Dest).BeginUpdate;
+    try
+      TStrings{TNT-ALLOW TStrings}(Dest).Clear;
+      {$IFDEF NAMEVALUESEPARATOR_RW}
+      TStrings{TNT-ALLOW TStrings}(Dest).NameValueSeparator := AnsiChar(NameValueSeparator);
+      {$ENDIF}
+      TStrings{TNT-ALLOW TStrings}(Dest).QuoteChar := AnsiChar(QuoteChar);
+      TStrings{TNT-ALLOW TStrings}(Dest).Delimiter := AnsiChar(Delimiter);
+      for I := 0 to Count - 1 do
+        TStrings{TNT-ALLOW TStrings}(Dest).AddObject(Strings[I], Objects[I]);
+    finally
+      TStrings{TNT-ALLOW TStrings}(Dest).EndUpdate;
+    end;
+  end
+  else
+    inherited AssignTo(Dest);
+end;
+
+procedure TWideStrings.BeginUpdate;
+begin
+  if FUpdateCount = 0 then SetUpdateState(True);
+  Inc(FUpdateCount);
+end;
+
+procedure TWideStrings.DefineProperties(Filer: TFiler);
+
+  function DoWrite: Boolean;
+  begin
+    if Filer.Ancestor <> nil then
+    begin
+      Result := True;
+      if Filer.Ancestor is TWideStrings then
+        Result := not Equals(TWideStrings(Filer.Ancestor))
+    end
+    else Result := Count > 0;
+  end;
+
+begin
+  Filer.DefineProperty('Strings', ReadData, WriteData, DoWrite);
+end;
+
+procedure TWideStrings.EndUpdate;
+begin
+  Dec(FUpdateCount);
+  if FUpdateCount = 0 then SetUpdateState(False);
+end;
+
+function TWideStrings.Equals(Strings: TWideStrings): Boolean;
+var
+  I, Count: Integer;
+begin
+  Result := False;
+  Count := GetCount;
+  if Count <> Strings.GetCount then Exit;
+  for I := 0 to Count - 1 do if Get(I) <> Strings.Get(I) then Exit;
+  Result := True;
+end;
+
+procedure TWideStrings.Error(const Msg: WideString; Data: Integer);
+
+  function ReturnAddr: Pointer;
+  asm
+          MOV     EAX,[EBP+4]
+  end;
+
+begin
+  raise EStringListError.CreateFmt(Msg, [Data]) at ReturnAddr;
+end;
+
+procedure TWideStrings.Error(Msg: PResStringRec; Data: Integer);
+begin
+  Error(WideLoadResString(Msg), Data);
+end;
+
+procedure TWideStrings.Exchange(Index1, Index2: Integer);
+var
+  TempObject: TObject;
+  TempString: WideString;
+begin
+  BeginUpdate;
+  try
+    TempString := Strings[Index1];
+    TempObject := Objects[Index1];
+    Strings[Index1] := Strings[Index2];
+    Objects[Index1] := Objects[Index2];
+    Strings[Index2] := TempString;
+    Objects[Index2] := TempObject;
+  finally
+    EndUpdate;
+  end;
+end;
+
+function TWideStrings.ExtractName(const S: WideString): WideString;
+var
+  P: Integer;
+begin
+  Result := S;
+  P := Pos(NameValueSeparator, Result);
+  if P <> 0 then
+    SetLength(Result, P-1) else
+    SetLength(Result, 0);
+end;
+
+function TWideStrings.GetCapacity: Integer;
+begin  // descendents may optionally override/replace this default implementation
+  Result := Count;
+end;
+
+function TWideStrings.GetCommaText: WideString;
+var
+  LOldDefined: TStringsDefined;
+  LOldDelimiter: WideChar;
+  LOldQuoteChar: WideChar;
+begin
+  LOldDefined := FDefined;
+  LOldDelimiter := FDelimiter;
+  LOldQuoteChar := FQuoteChar;
+  Delimiter := ',';
+  QuoteChar := '"';
+  try
+    Result := GetDelimitedText;
+  finally
+    FDelimiter := LOldDelimiter;
+    FQuoteChar := LOldQuoteChar;
+    FDefined := LOldDefined;
+  end;
+end;
+
+function TWideStrings.GetDelimitedText: WideString;
+var
+  S: WideString;
+  P: PWideChar;
+  I, Count: Integer;
+begin
+  Count := GetCount;
+  if (Count = 1) and (Get(0) = '') then
+    Result := WideString(QuoteChar) + QuoteChar
+  else
+  begin
+    Result := '';
+    for I := 0 to Count - 1 do
+    begin
+      S := Get(I);
+      P := PWideChar(S);
+      while not ((P^ in [WideChar(#0)..WideChar(' ')]) or (P^ = QuoteChar) or (P^ = Delimiter)) do
+        Inc(P);
+      if (P^ <> #0) then S := WideQuotedStr(S, QuoteChar);
+      Result := Result + S + Delimiter;
+    end;
+    System.Delete(Result, Length(Result), 1);
+  end;
+end;
+
+function TWideStrings.GetName(Index: Integer): WideString;
+begin
+  Result := ExtractName(Get(Index));
+end;
+
+function TWideStrings.GetObject(Index: Integer): TObject;
+begin
+  Result := nil;
+end;
+
+function TWideStrings.GetEnumerator: TWideStringsEnumerator;
+begin
+  Result := TWideStringsEnumerator.Create(Self);
+end;
+
+function TWideStrings.GetTextW: PWideChar;
+begin
+  Result := WStrNew(PWideChar(GetTextStr));
+end;
+
+function TWideStrings.GetTextStr: WideString;
+var
+  I, L, Size, Count: Integer;
+  P: PWideChar;
+  S, LB: WideString;
+begin
+  Count := GetCount;
+  Size := 0;
+  LB := sLineBreak;
+  for I := 0 to Count - 1 do Inc(Size, Length(Get(I)) + Length(LB));
+  SetString(Result, nil, Size);
+  P := Pointer(Result);
+  for I := 0 to Count - 1 do
+  begin
+    S := Get(I);
+    L := Length(S);
+    if L <> 0 then
+    begin
+      System.Move(Pointer(S)^, P^, L * SizeOf(WideChar));
+      Inc(P, L);
+    end;
+    L := Length(LB);
+    if L <> 0 then
+    begin
+      System.Move(Pointer(LB)^, P^, L * SizeOf(WideChar));
+      Inc(P, L);
+    end;
+  end;
+end;
+
+function TWideStrings.GetValue(const Name: WideString): WideString;
+var
+  I: Integer;
+begin
+  I := IndexOfName(Name);
+  if I >= 0 then
+    Result := Copy(Get(I), Length(Name) + 2, MaxInt) else
+    Result := '';
+end;
+
+function TWideStrings.IndexOf(const S: WideString): Integer;
+begin
+  for Result := 0 to GetCount - 1 do
+    if CompareStrings(Get(Result), S) = 0 then Exit;
+  Result := -1;
+end;
+
+function TWideStrings.IndexOfName(const Name: WideString): Integer;
+var
+  P: Integer;
+  S: WideString;
+begin
+  for Result := 0 to GetCount - 1 do
+  begin
+    S := Get(Result);
+    P := Pos(NameValueSeparator, S);
+    if (P <> 0) and (CompareStrings(Copy(S, 1, P - 1), Name) = 0) then Exit;
+  end;
+  Result := -1;
+end;
+
+function TWideStrings.IndexOfObject(AObject: TObject): Integer;
+begin
+  for Result := 0 to GetCount - 1 do
+    if GetObject(Result) = AObject then Exit;
+  Result := -1;
+end;
+
+procedure TWideStrings.InsertObject(Index: Integer; const S: WideString;
+  AObject: TObject);
+begin
+  Insert(Index, S);
+  PutObject(Index, AObject);
+end;
+
+procedure TWideStrings.LoadFromFile(const FileName: WideString);
+var
+  Stream: TStream;
+begin
+  Stream := TTntFileStream.Create(FileName, fmOpenRead or fmShareDenyWrite);
+  try
+    LoadFromStream(Stream);
+  finally
+    Stream.Free;
+  end;
+end;
+
+procedure TWideStrings.LoadFromStream(Stream: TStream);
+var
+  Size: Integer;
+  S: WideString;
+begin
+  BeginUpdate;
+  try
+    Size := Stream.Size - Stream.Position;
+    SetString(S, nil, Size div SizeOf(WideChar));
+    Stream.Read(Pointer(S)^, Length(S) * SizeOf(WideChar));
+    SetTextStr(S);
+  finally
+    EndUpdate;
+  end;
+end;
+
+procedure TWideStrings.Move(CurIndex, NewIndex: Integer);
+var
+  TempObject: TObject;
+  TempString: WideString;
+begin
+  if CurIndex <> NewIndex then
+  begin
+    BeginUpdate;
+    try
+      TempString := Get(CurIndex);
+      TempObject := GetObject(CurIndex);
+      Delete(CurIndex);
+      InsertObject(NewIndex, TempString, TempObject);
+    finally
+      EndUpdate;
+    end;
+  end;
+end;
+
+procedure TWideStrings.Put(Index: Integer; const S: WideString);
+var
+  TempObject: TObject;
+begin
+  TempObject := GetObject(Index);
+  Delete(Index);
+  InsertObject(Index, S, TempObject);
+end;
+
+procedure TWideStrings.PutObject(Index: Integer; AObject: TObject);
+begin
+end;
+
+procedure TWideStrings.ReadData(Reader: TReader);
+begin
+  if Reader.NextValue in [vaString, vaLString] then
+    SetTextStr(Reader.ReadString) {JCL compatiblity}
+  else if Reader.NextValue = vaWString then
+    SetTextStr(Reader.ReadWideString) {JCL compatiblity}
+  else begin
+    BeginUpdate;
+    try
+      Clear;
+      Reader.ReadListBegin;
+      while not Reader.EndOfList do
+        if Reader.NextValue in [vaString, vaLString] then
+          Add(Reader.ReadString) {TStrings compatiblity}
+        else
+          Add(Reader.ReadWideString);
+      Reader.ReadListEnd;
+    finally
+      EndUpdate;
+    end;
+  end;
+end;
+
+procedure TWideStrings.SaveToFile(const FileName: WideString);
+var
+  Stream: TStream;
+begin
+  Stream := TTntFileStream.Create(FileName, fmCreate);
+  try
+    SaveToStream(Stream);
+  finally
+    Stream.Free;
+  end;
+end;
+
+procedure TWideStrings.SaveToStream(Stream: TStream);
+var
+  SW: WideString;
+begin
+  SW := GetTextStr;
+  Stream.WriteBuffer(PWideChar(SW)^, Length(SW) * SizeOf(WideChar));
+end;
+
+procedure TWideStrings.SetCapacity(NewCapacity: Integer);
+begin
+  // do nothing - descendents may optionally implement this method
+end;
+
+procedure TWideStrings.SetCommaText(const Value: WideString);
+begin
+  Delimiter := ',';
+  QuoteChar := '"';
+  SetDelimitedText(Value);
+end;
+
+procedure TWideStrings.SetStringsAdapter(const Value: IWideStringsAdapter);
+begin
+  if FAdapter <> nil then FAdapter.ReleaseStrings;
+  FAdapter := Value;
+  if FAdapter <> nil then FAdapter.ReferenceStrings(Self);
+end;
+
+procedure TWideStrings.SetTextW(const Text: PWideChar);
+begin
+  SetTextStr(Text);
+end;
+
+procedure TWideStrings.SetTextStr(const Value: WideString);
+var
+  P, Start: PWideChar;
+  S: WideString;
+begin
+  BeginUpdate;
+  try
+    Clear;
+    P := Pointer(Value);
+    if P <> nil then
+      while P^ <> #0 do
+      begin
+        Start := P;
+        while not (P^ in [WideChar(#0), WideChar(#10), WideChar(#13)]) and (P^ <> WideLineSeparator) do
+          Inc(P);
+        SetString(S, Start, P - Start);
+        Add(S);
+        if P^ = #13 then Inc(P);
+        if P^ = #10 then Inc(P);
+        if P^ = WideLineSeparator then Inc(P);
+      end;
+  finally
+    EndUpdate;
+  end;
+end;
+
+procedure TWideStrings.SetUpdateState(Updating: Boolean);
+begin
+end;
+
+procedure TWideStrings.SetValue(const Name, Value: WideString);
+var
+  I: Integer;
+begin
+  I := IndexOfName(Name);
+  if Value <> '' then
+  begin
+    if I < 0 then I := Add('');
+    Put(I, Name + NameValueSeparator + Value);
+  end else
+  begin
+    if I >= 0 then Delete(I);
+  end;
+end;
+
+procedure TWideStrings.WriteData(Writer: TWriter);
+var
+  I: Integer;
+begin
+  Writer.WriteListBegin;
+  for I := 0 to Count-1 do begin
+    Writer.WriteWideString(Get(I));
+  end;
+  Writer.WriteListEnd;
+end;
+
+procedure TWideStrings.SetDelimitedText(const Value: WideString);
+var
+  P, P1: PWideChar;
+  S: WideString;
+begin
+  BeginUpdate;
+  try
+    Clear;
+    P := PWideChar(Value);
+    while P^ in [WideChar(#1)..WideChar(' ')] do
+      Inc(P);
+    while P^ <> #0 do
+    begin
+      if P^ = QuoteChar then
+        S := WideExtractQuotedStr(P, QuoteChar)
+      else
+      begin
+        P1 := P;
+        while (P^ > ' ') and (P^ <> Delimiter) do
+          Inc(P);
+        SetString(S, P1, P - P1);
+      end;
+      Add(S);
+      while P^ in [WideChar(#1)..WideChar(' ')] do
+        Inc(P);
+      if P^ = Delimiter then
+      begin
+        P1 := P;
+        Inc(P1);
+        if P1^ = #0 then
+          Add('');
+        repeat
+          Inc(P);
+        until not (P^ in [WideChar(#1)..WideChar(' ')]);
+      end;
+    end;
+  finally
+    EndUpdate;
+  end;
+end;
+
+function TWideStrings.GetDelimiter: WideChar;
+begin
+  if not (sdDelimiter in FDefined) then
+    Delimiter := ',';
+  Result := FDelimiter;
+end;
+
+function TWideStrings.GetQuoteChar: WideChar;
+begin
+  if not (sdQuoteChar in FDefined) then
+    QuoteChar := '"';
+  Result := FQuoteChar;
+end;
+
+procedure TWideStrings.SetDelimiter(const Value: WideChar);
+begin
+  if (FDelimiter <> Value) or not (sdDelimiter in FDefined) then
+  begin
+    Include(FDefined, sdDelimiter);
+    FDelimiter := Value;
+  end
+end;
+
+procedure TWideStrings.SetQuoteChar(const Value: WideChar);
+begin
+  if (FQuoteChar <> Value) or not (sdQuoteChar in FDefined) then
+  begin
+    Include(FDefined, sdQuoteChar);
+    FQuoteChar := Value;
+  end
+end;
+
+function TWideStrings.CompareStrings(const S1, S2: WideString): Integer;
+begin
+  Result := WideCompareText(S1, S2);
+end;
+
+function TWideStrings.GetNameValueSeparator: WideChar;
+begin
+  {$IFDEF NAMEVALUESEPARATOR_RW}
+  if not (sdNameValueSeparator in FDefined) then
+    NameValueSeparator := '=';
+  Result := FNameValueSeparator;
+  {$ELSE}
+  Result := '=';
+  {$ENDIF}
+end;
+
+{$IFDEF NAMEVALUESEPARATOR_RW}
+procedure TWideStrings.SetNameValueSeparator(const Value: WideChar);
+begin
+  if (FNameValueSeparator <> Value) or not (sdNameValueSeparator in FDefined) then
+  begin
+    Include(FDefined, sdNameValueSeparator);
+    FNameValueSeparator := Value;
+  end
+end;
+{$ENDIF}
+
+function TWideStrings.GetValueFromIndex(Index: Integer): WideString;
+begin
+  if Index >= 0 then
+    Result := Copy(Get(Index), Length(Names[Index]) + 2, MaxInt) else
+    Result := '';
+end;
+
+procedure TWideStrings.SetValueFromIndex(Index: Integer; const Value: WideString);
+begin
+  if Value <> '' then
+  begin
+    if Index < 0 then Index := Add('');
+    Put(Index, Names[Index] + NameValueSeparator + Value);
+  end
+  else
+    if Index >= 0 then Delete(Index);
+end;
+
+end.
diff --git a/Lua/src/lib/TntUnicodeControls/TntWindows.pas b/Lua/src/lib/TntUnicodeControls/TntWindows.pas
new file mode 100644
index 00000000..8fd7ec88
--- /dev/null
+++ b/Lua/src/lib/TntUnicodeControls/TntWindows.pas
@@ -0,0 +1,1501 @@
+
+{*****************************************************************************}
+{                                                                             }
+{    Tnt Delphi Unicode Controls                                              }
+{      http://www.tntware.com/delphicontrols/unicode/                         }
+{        Version: 2.3.0                                                       }
+{                                                                             }
+{    Copyright (c) 2002-2007, Troy Wolbrink (troy.wolbrink@tntware.com)       }
+{                                                                             }
+{*****************************************************************************}
+
+unit TntWindows;
+
+{$IFDEF FPC}
+  {$MODE Delphi}
+{$ENDIF}
+
+{$INCLUDE TntCompilers.inc}
+
+interface
+
+uses
+  Windows, ShellApi, ShlObj;
+
+// ......... compatibility
+
+const
+  DT_NOFULLWIDTHCHARBREAK = $00080000;
+
+const
+  INVALID_FILE_ATTRIBUTES = DWORD(-1);
+
+// ................ ANSI TYPES ................
+{TNT-WARN LPSTR}
+{TNT-WARN PLPSTR}
+{TNT-WARN LPCSTR}
+{TNT-WARN LPCTSTR}
+{TNT-WARN LPTSTR}
+
+// ........ EnumResourceTypesW, EnumResourceNamesW and EnumResourceLanguagesW are supposed ....
+// ........ to work on Win95/98/ME but have caused access violations in testing on Win95 ......
+// .. TNT--WARN EnumResourceTypes ..
+// .. TNT--WARN EnumResourceTypesA ..
+// .. TNT--WARN EnumResourceNames ..
+// .. TNT--WARN EnumResourceNamesA ..
+// .. TNT--WARN EnumResourceLanguages ..
+// .. TNT--WARN EnumResourceLanguagesA ..
+
+//------------------------------------------------------------------------------------------
+
+// ......... The Unicode form of these functions are supported on Windows 95/98/ME .........
+{TNT-WARN ExtTextOut}
+{TNT-WARN ExtTextOutA}
+{TNT-WARN Tnt_ExtTextOutW}
+
+{TNT-WARN FindResource}
+{TNT-WARN FindResourceA}
+{TNT-WARN Tnt_FindResourceW}
+
+{TNT-WARN FindResourceEx}
+{TNT-WARN FindResourceExA}
+{TNT-WARN Tnt_FindResourceExW}
+
+{TNT-WARN GetCharWidth}
+{TNT-WARN GetCharWidthA}
+{TNT-WARN Tnt_GetCharWidthW}
+
+{TNT-WARN GetCommandLine}
+{TNT-WARN GetCommandLineA}
+{TNT-WARN Tnt_GetCommandLineW}
+
+{TNT-WARN GetTextExtentPoint}
+{TNT-WARN GetTextExtentPointA}
+{TNT-WARN Tnt_GetTextExtentPointW}
+
+{TNT-WARN GetTextExtentPoint32}
+{TNT-WARN GetTextExtentPoint32A}
+{TNT-WARN Tnt_GetTextExtentPoint32W}
+
+{TNT-WARN lstrcat}
+{TNT-WARN lstrcatA}
+{TNT-WARN Tnt_lstrcatW}
+
+{TNT-WARN lstrcpy}
+{TNT-WARN lstrcpyA}
+{TNT-WARN Tnt_lstrcpyW}
+
+{TNT-WARN lstrlen}
+{TNT-WARN lstrlenA}
+{TNT-WARN Tnt_lstrlenW}
+
+{TNT-WARN MessageBox}
+{TNT-WARN MessageBoxA}
+{TNT-WARN Tnt_MessageBoxW}
+
+{TNT-WARN MessageBoxEx}
+{TNT-WARN MessageBoxExA}
+{TNT-WARN Tnt_MessageBoxExA}
+
+{TNT-WARN TextOut}
+{TNT-WARN TextOutA}
+{TNT-WARN Tnt_TextOutW}
+
+//------------------------------------------------------------------------------------------
+
+{TNT-WARN LOCALE_USER_DEFAULT} // <-- use GetThreadLocale
+{TNT-WARN LOCALE_SYSTEM_DEFAULT} // <-- use GetThreadLocale
+
+//------------------------------------------------------------------------------------------
+//                                     compatiblity
+//------------------------------------------------------------------------------------------
+{$IFNDEF COMPILER_9_UP}
+type
+  {$IFDEF FPC}
+  TStartupInfoA = STARTUPINFO;
+  TStartupInfoW = STARTUPINFO;
+  {$ELSE}
+  TStartupInfoA = _STARTUPINFOA;
+  TStartupInfoW = record
+    cb: DWORD;
+    lpReserved: PWideChar;
+    lpDesktop: PWideChar;
+    lpTitle: PWideChar;
+    dwX: DWORD;
+    dwY: DWORD;
+    dwXSize: DWORD;
+    dwYSize: DWORD;
+    dwXCountChars: DWORD;
+    dwYCountChars: DWORD;
+    dwFillAttribute: DWORD;
+    dwFlags: DWORD;
+    wShowWindow: Word;
+    cbReserved2: Word;
+    lpReserved2: PByte;
+    hStdInput: THandle;
+    hStdOutput: THandle;
+    hStdError: THandle;
+  end;
+  {$ENDIF}
+
+function CreateProcessW{TNT-ALLOW CreateProcessW}(lpApplicationName: PWideChar; lpCommandLine: PWideChar;
+  lpProcessAttributes, lpThreadAttributes: PSecurityAttributes;
+  bInheritHandles: BOOL; dwCreationFlags: DWORD; lpEnvironment: Pointer;
+  lpCurrentDirectory: PWideChar; const lpStartupInfo: TStartupInfoW;
+  var lpProcessInformation: TProcessInformation): BOOL; stdcall; external kernel32 name 'CreateProcessW';
+
+{$ENDIF}
+
+{$IFDEF FPC}
+type
+  TCurrencyFmtA = CURRENCYFMT;
+  TCurrencyFmtW = CURRENCYFMT;
+  PCurrencyFmtA = ^TCurrencyFmtA;
+  PCurrencyFmtW = ^TCurrencyFmtW;
+{$ENDIF}
+
+//------------------------------------------------------------------------------------------
+
+{TNT-WARN SetWindowText}
+{TNT-WARN SetWindowTextA}
+{TNT-WARN SetWindowTextW}
+function Tnt_SetWindowTextW(hWnd: HWND; lpString: PWideChar): BOOL;
+
+{TNT-WARN RemoveDirectory}
+{TNT-WARN RemoveDirectoryA}
+{TNT-WARN RemoveDirectoryW}
+function Tnt_RemoveDirectoryW(lpPathName: PWideChar): BOOL;
+
+{TNT-WARN GetShortPathName}
+{TNT-WARN GetShortPathNameA}
+{TNT-WARN GetShortPathNameW}
+function Tnt_GetShortPathNameW(lpszLongPath: PWideChar; lpszShortPath: PWideChar;
+  cchBuffer: DWORD): DWORD;
+
+{TNT-WARN GetFullPathName}
+{TNT-WARN GetFullPathNameA}
+{TNT-WARN GetFullPathNameW}
+function Tnt_GetFullPathNameW(lpFileName: PWideChar; nBufferLength: DWORD;
+  lpBuffer: PWideChar; var lpFilePart: PWideChar): DWORD;
+
+{TNT-WARN CreateFile}
+{TNT-WARN CreateFileA}
+{TNT-WARN CreateFileW}
+function Tnt_CreateFileW(lpFileName: PWideChar; dwDesiredAccess, dwShareMode: DWORD;
+  lpSecurityAttributes: PSecurityAttributes; dwCreationDisposition, dwFlagsAndAttributes: DWORD;
+    hTemplateFile: THandle): THandle;
+
+{TNT-WARN FindFirstFile}
+{TNT-WARN FindFirstFileA}
+{TNT-WARN FindFirstFileW}
+function Tnt_FindFirstFileW(lpFileName: PWideChar; var lpFindFileData: TWIN32FindDataW): THandle;
+
+{TNT-WARN FindNextFile}
+{TNT-WARN FindNextFileA}
+{TNT-WARN FindNextFileW}
+function Tnt_FindNextFileW(hFindFile: THandle; var lpFindFileData: TWIN32FindDataW): BOOL;
+
+{TNT-WARN GetFileAttributes}
+{TNT-WARN GetFileAttributesA}
+{TNT-WARN GetFileAttributesW}
+function Tnt_GetFileAttributesW(lpFileName: PWideChar): DWORD;
+
+{TNT-WARN SetFileAttributes}
+{TNT-WARN SetFileAttributesA}
+{TNT-WARN SetFileAttributesW}
+function Tnt_SetFileAttributesW(lpFileName: PWideChar; dwFileAttributes: DWORD): BOOL;
+
+{TNT-WARN CreateDirectory}
+{TNT-WARN CreateDirectoryA}
+{TNT-WARN CreateDirectoryW}
+function Tnt_CreateDirectoryW(lpPathName: PWideChar;
+  lpSecurityAttributes: PSecurityAttributes): BOOL;
+
+{TNT-WARN MoveFile}
+{TNT-WARN MoveFileA}
+{TNT-WARN MoveFileW}
+function Tnt_MoveFileW(lpExistingFileName, lpNewFileName: PWideChar): BOOL;
+
+{TNT-WARN CopyFile}
+{TNT-WARN CopyFileA}
+{TNT-WARN CopyFileW}
+function Tnt_CopyFileW(lpExistingFileName, lpNewFileName: PWideChar; bFailIfExists: BOOL): BOOL;
+
+{TNT-WARN DeleteFile}
+{TNT-WARN DeleteFileA}
+{TNT-WARN DeleteFileW}
+function Tnt_DeleteFileW(lpFileName: PWideChar): BOOL;
+
+{TNT-WARN DrawText}
+{TNT-WARN DrawTextA}
+{TNT-WARN DrawTextW}
+function Tnt_DrawTextW(hDC: HDC; lpString: PWideChar; nCount: Integer;
+  var lpRect: TRect; uFormat: UINT): Integer;
+
+{TNT-WARN GetDiskFreeSpace}
+{TNT-WARN GetDiskFreeSpaceA}
+{TNT-WARN GetDiskFreeSpaceW}
+function Tnt_GetDiskFreeSpaceW(lpRootPathName: PWideChar; var lpSectorsPerCluster,
+  lpBytesPerSector, lpNumberOfFreeClusters, lpTotalNumberOfClusters: DWORD): BOOL;
+
+{TNT-WARN GetVolumeInformation}
+{TNT-WARN GetVolumeInformationA}
+{TNT-WARN GetVolumeInformationW}  
+function Tnt_GetVolumeInformationW(lpRootPathName: PWideChar; lpVolumeNameBuffer: PWideChar;
+  nVolumeNameSize: DWORD; lpVolumeSerialNumber: PDWORD;
+    var lpMaximumComponentLength, lpFileSystemFlags: DWORD; lpFileSystemNameBuffer: PWideChar;
+      nFileSystemNameSize: DWORD): BOOL;
+
+{TNT-WARN GetModuleFileName}
+{TNT-WARN GetModuleFileNameA}
+{TNT-WARN GetModuleFileNameW}
+function Tnt_GetModuleFileNameW(hModule: HINST; lpFilename: PWideChar; nSize: DWORD): DWORD;
+
+{TNT-WARN GetTempPath}
+{TNT-WARN GetTempPathA}
+{TNT-WARN GetTempPathW}
+function Tnt_GetTempPathW(nBufferLength: DWORD; lpBuffer: PWideChar): DWORD;
+
+{TNT-WARN GetTempFileName}
+{TNT-WARN GetTempFileNameA}
+{TNT-WARN GetTempFileNameW}
+function Tnt_GetTempFileNameW(lpPathName, lpPrefixString: PWideChar; uUnique: UINT;
+  lpTempFileName: PWideChar): UINT;
+
+{TNT-WARN GetWindowsDirectory}
+{TNT-WARN GetWindowsDirectoryA}
+{TNT-WARN GetWindowsDirectoryW}
+function Tnt_GetWindowsDirectoryW(lpBuffer: PWideChar; uSize: UINT): UINT;
+
+{TNT-WARN GetSystemDirectory}
+{TNT-WARN GetSystemDirectoryA}
+{TNT-WARN GetSystemDirectoryW}
+function Tnt_GetSystemDirectoryW(lpBuffer: PWideChar; uSize: UINT): UINT;
+
+{TNT-WARN GetCurrentDirectory}
+{TNT-WARN GetCurrentDirectoryA}
+{TNT-WARN GetCurrentDirectoryW}
+function Tnt_GetCurrentDirectoryW(nBufferLength: DWORD; lpBuffer: PWideChar): DWORD;
+
+{TNT-WARN SetCurrentDirectory}
+{TNT-WARN SetCurrentDirectoryA}
+{TNT-WARN SetCurrentDirectoryW}
+function Tnt_SetCurrentDirectoryW(lpPathName: PWideChar): BOOL;
+
+{TNT-WARN GetComputerName}
+{TNT-WARN GetComputerNameA}
+{TNT-WARN GetComputerNameW}
+function Tnt_GetComputerNameW(lpBuffer: PWideChar; var nSize: DWORD): BOOL;
+
+{TNT-WARN GetUserName}
+{TNT-WARN GetUserNameA}
+{TNT-WARN GetUserNameW}
+function Tnt_GetUserNameW(lpBuffer: PWideChar; var nSize: DWORD): BOOL;
+
+{TNT-WARN ShellExecute}
+{TNT-WARN ShellExecuteA}
+{TNT-WARN ShellExecuteW}
+function Tnt_ShellExecuteW(hWnd: HWND; Operation, FileName, Parameters,
+  Directory: PWideChar; ShowCmd: Integer): HINST;
+
+{TNT-WARN LoadLibrary}
+{TNT-WARN LoadLibraryA}
+{TNT-WARN LoadLibraryW}
+function Tnt_LoadLibraryW(lpLibFileName: PWideChar): HMODULE;
+
+{TNT-WARN LoadLibraryEx}
+{TNT-WARN LoadLibraryExA}
+{TNT-WARN LoadLibraryExW}
+function Tnt_LoadLibraryExW(lpLibFileName: PWideChar; hFile: THandle; dwFlags: DWORD): HMODULE;
+
+{TNT-WARN CreateProcess}
+{TNT-WARN CreateProcessA}
+{TNT-WARN CreateProcessW}
+function Tnt_CreateProcessW(lpApplicationName: PWideChar; lpCommandLine: PWideChar;
+  lpProcessAttributes, lpThreadAttributes: PSecurityAttributes;
+    bInheritHandles: BOOL; dwCreationFlags: DWORD; lpEnvironment: Pointer;
+      lpCurrentDirectory: PWideChar; const lpStartupInfo: TStartupInfoW;
+        var lpProcessInformation: TProcessInformation): BOOL;
+
+{TNT-WARN GetCurrencyFormat}
+{TNT-WARN GetCurrencyFormatA}
+{TNT-WARN GetCurrencyFormatW}
+function Tnt_GetCurrencyFormatW(Locale: LCID; dwFlags: DWORD; lpValue: PWideChar;
+  lpFormat: PCurrencyFmtW; lpCurrencyStr: PWideChar; cchCurrency: Integer): Integer;
+
+{TNT-WARN CompareString}
+{TNT-WARN CompareStringA}
+{TNT-WARN CompareStringW}
+function Tnt_CompareStringW(Locale: LCID; dwCmpFlags: DWORD; lpString1: PWideChar;
+  cchCount1: Integer; lpString2: PWideChar; cchCount2: Integer): Integer;
+
+{TNT-WARN CharUpper}
+{TNT-WARN CharUpperA}
+{TNT-WARN CharUpperW}
+function Tnt_CharUpperW(lpsz: PWideChar): PWideChar;
+
+{TNT-WARN CharUpperBuff}
+{TNT-WARN CharUpperBuffA}
+{TNT-WARN CharUpperBuffW}
+function Tnt_CharUpperBuffW(lpsz: PWideChar; cchLength: DWORD): DWORD;
+
+{TNT-WARN CharLower}
+{TNT-WARN CharLowerA}
+{TNT-WARN CharLowerW}
+function Tnt_CharLowerW(lpsz: PWideChar): PWideChar;
+
+{TNT-WARN CharLowerBuff}
+{TNT-WARN CharLowerBuffA}
+{TNT-WARN CharLowerBuffW}
+function Tnt_CharLowerBuffW(lpsz: PWideChar; cchLength: DWORD): DWORD;
+
+{TNT-WARN GetStringTypeEx}
+{TNT-WARN GetStringTypeExA}
+{TNT-WARN GetStringTypeExW}
+function Tnt_GetStringTypeExW(Locale: LCID; dwInfoType: DWORD;
+  lpSrcStr: PWideChar; cchSrc: Integer; var lpCharType): BOOL;
+
+{TNT-WARN LoadString}
+{TNT-WARN LoadStringA}
+{TNT-WARN LoadStringW}
+function Tnt_LoadStringW(hInstance: HINST; uID: UINT; lpBuffer: PWideChar; nBufferMax: Integer): Integer;
+
+{$IFDEF FPC}
+type
+  TMenuItemInfoW   = TMENUITEMINFO;
+  tagMenuItemINFOW = tagMENUITEMINFO;
+{$ENDIF}
+
+{TNT-WARN InsertMenuItem}
+{TNT-WARN InsertMenuItemA}
+{TNT-WARN InsertMenuItemW}
+function Tnt_InsertMenuItemW(hMenu: HMENU; uItem: DWORD; fByPosition: BOOL; lpmii: tagMenuItemINFOW): BOOL;
+
+{TNT-WARN ExtractIconEx}
+{TNT-WARN ExtractIconExA}
+{TNT-WARN ExtractIconExW}
+function Tnt_ExtractIconExW(lpszFile: PWideChar; nIconIndex: Integer;
+  var phiconLarge, phiconSmall: HICON; nIcons: UINT): UINT;
+
+{TNT-WARN ExtractAssociatedIcon}
+{TNT-WARN ExtractAssociatedIconA}
+{TNT-WARN ExtractAssociatedIconW}
+function Tnt_ExtractAssociatedIconW(hInst: HINST; lpIconPath: PWideChar;
+  var lpiIcon: Word): HICON;
+
+{TNT-WARN GetFileVersionInfoSize}
+{TNT-WARN GetFileVersionInfoSizeA}
+{TNT-WARN GetFileVersionInfoSizeW}
+function Tnt_GetFileVersionInfoSizeW(lptstrFilename: PWideChar; var lpdwHandle: DWORD): DWORD;
+
+{TNT-WARN GetFileVersionInfo}
+{TNT-WARN GetFileVersionInfoA}
+{TNT-WARN GetFileVersionInfoW}
+function Tnt_GetFileVersionInfoW(lptstrFilename: PWideChar; dwHandle, dwLen: DWORD;
+  lpData: Pointer): BOOL;
+
+const
+  VQV_FIXEDFILEINFO = '\';
+  VQV_VARFILEINFO_TRANSLATION = '\VarFileInfo\Translation';
+  VQV_STRINGFILEINFO = '\StringFileInfo';
+
+  VER_COMMENTS         = 'Comments';
+  VER_INTERNALNAME     = 'InternalName';
+  VER_PRODUCTNAME      = 'ProductName';
+  VER_COMPANYNAME      = 'CompanyName';
+  VER_LEGALCOPYRIGHT   = 'LegalCopyright';
+  VER_PRODUCTVERSION   = 'ProductVersion';
+  VER_FILEDESCRIPTION  = 'FileDescription';
+  VER_LEGALTRADEMARKS  = 'LegalTrademarks';
+  VER_PRIVATEBUILD     = 'PrivateBuild';
+  VER_FILEVERSION      = 'FileVersion';
+  VER_ORIGINALFILENAME = 'OriginalFilename';
+  VER_SPECIALBUILD     = 'SpecialBuild';
+
+{TNT-WARN VerQueryValue}
+{TNT-WARN VerQueryValueA}
+{TNT-WARN VerQueryValueW}
+function Tnt_VerQueryValueW(pBlock: Pointer; lpSubBlock: PWideChar;
+  var lplpBuffer: Pointer; var puLen: UINT): BOOL;
+
+type
+{$IFDEF FPC}
+  PSHNAMEMAPPINGA = ^SHNAMEMAPPINGA;
+  SHNAMEMAPPINGA = record
+    pszOldPath : LPSTR;
+    pszNewPath : LPSTR;
+    cchOldPath : longint;
+    cchNewPath : longint;
+  end;
+
+  PSHNAMEMAPPINGW = ^SHNAMEMAPPINGW;
+  SHNAMEMAPPINGW = record
+    pszOldPath : LPWSTR;
+    pszNewPath : LPWSTR;
+    cchOldPath : longint;
+    cchNewPath : longint;
+  end;
+{$ENDIF}
+
+  TSHNameMappingHeaderA = record
+   cNumOfMappings: Cardinal;
+   lpNM: PSHNAMEMAPPINGA;
+  end;
+  PSHNameMappingHeaderA = ^TSHNameMappingHeaderA;
+
+  TSHNameMappingHeaderW = record
+   cNumOfMappings: Cardinal;
+   lpNM: PSHNAMEMAPPINGW;
+  end;
+  PSHNameMappingHeaderW = ^TSHNameMappingHeaderW;
+
+{TNT-WARN SHFileOperation}
+{TNT-WARN SHFileOperationA}
+{TNT-WARN SHFileOperationW} // <-- no stub on early Windows 95
+function Tnt_SHFileOperationW(var lpFileOp: TSHFileOpStructW): Integer;
+
+{TNT-WARN SHFreeNameMappings}
+procedure Tnt_SHFreeNameMappings(hNameMappings: THandle);
+
+{TNT-WARN SHBrowseForFolder}
+{TNT-WARN SHBrowseForFolderA}
+{TNT-WARN SHBrowseForFolderW} // <-- no stub on early Windows 95
+function Tnt_SHBrowseForFolderW(var lpbi: TBrowseInfoW): PItemIDList;
+
+{TNT-WARN SHGetPathFromIDList}
+{TNT-WARN SHGetPathFromIDListA}
+{TNT-WARN SHGetPathFromIDListW} // <-- no stub on early Windows 95
+function Tnt_SHGetPathFromIDListW(pidl: PItemIDList; pszPath: PWideChar): BOOL;
+
+{TNT-WARN SHGetFileInfo}
+{TNT-WARN SHGetFileInfoA}
+{TNT-WARN SHGetFileInfoW} // <-- no stub on early Windows 95
+function Tnt_SHGetFileInfoW(pszPath: PWideChar; dwFileAttributes: DWORD;
+  var psfi: TSHFileInfoW; cbFileInfo, uFlags: UINT): DWORD;
+
+// ......... introduced .........
+function Tnt_Is_IntResource(ResStr: LPCWSTR): Boolean;
+
+function LANGIDFROMLCID(lcid: LCID): WORD;
+function MAKELANGID(usPrimaryLanguage, usSubLanguage: WORD): WORD;
+function MAKELCID(wLanguageID: WORD; wSortID: WORD = SORT_DEFAULT): LCID;
+function PRIMARYLANGID(lgid: WORD): WORD;
+function SORTIDFROMLCID(lcid: LCID): WORD;
+function SUBLANGID(lgid: WORD): WORD;
+
+implementation
+
+uses
+  SysUtils, Math, TntSysUtils,
+  {$IFDEF COMPILER_9_UP} WideStrUtils, {$ENDIF} TntWideStrUtils;
+
+function _PAnsiCharWithNil(const S: AnsiString): PAnsiChar;
+begin
+  if S = '' then
+    Result := nil {Win9x needs nil for some parameters instead of empty strings}
+  else
+    Result := PAnsiChar(S);
+end;
+
+function _PWideCharWithNil(const S: WideString): PWideChar;
+begin
+  if S = '' then
+    Result := nil {Win9x needs nil for some parameters instead of empty strings}
+  else
+    Result := PWideChar(S);
+end;
+
+function _WStr(lpString: PWideChar; cchCount: Integer): WideString;
+begin
+  if cchCount = -1 then
+    Result := lpString
+  else
+    Result := Copy(WideString(lpString), 1, cchCount);
+end;
+
+procedure _MakeWideWin32FindData(var WideFindData: TWIN32FindDataW; AnsiFindData: TWIN32FindDataA);
+begin
+  CopyMemory(@WideFindData, @AnsiFindData,
+    PtrUInt(@WideFindData.cFileName) - PtrUInt(@WideFindData));
+  WStrPCopy(WideFindData.cFileName, AnsiFindData.cFileName);
+  WStrPCopy(WideFindData.cAlternateFileName, AnsiFindData.cAlternateFileName);
+end;
+
+function Tnt_SetWindowTextW(hWnd: HWND; lpString: PWideChar): BOOL;
+begin
+  if Win32PlatformIsUnicode then
+    Result := SetWindowTextW{TNT-ALLOW SetWindowTextW}(hWnd, lpString)
+  else
+    Result := SetWindowTextA{TNT-ALLOW SetWindowTextA}(hWnd, PAnsiChar(AnsiString(lpString)));
+end;
+
+//-----------------------------
+
+type
+  TPathLengthResultOption = (poAllowDirectoryMode, poZeroSmallBuff, poExactCopy, poExactCopySubPaths);
+  TPathLengthResultOptions = set of TPathLengthResultOption;
+
+procedure _ExactStrCopyW(pDest, pSource: PWideChar; Count: Integer);
+var
+  i: integer;
+begin
+  for i := 1 to Count do begin
+    pDest^ := pSource^;
+    Inc(PSource);
+    Inc(pDest);
+  end;
+end;
+
+procedure _ExactCopySubPaths(pDest, pSource: PWideChar; Count: Integer);
+var
+  i: integer;
+  OriginalSource: PWideChar;
+  PNextSlash: PWideChar;
+begin
+  if Count >= 4 then begin
+    OriginalSource := pSource;
+    PNextSlash := WStrScan(pSource, '\');
+    for i := 1 to Count - 1 do begin
+      // determine next path delimiter
+      if pSource > pNextSlash then begin
+        PNextSlash := WStrScan(pSource, '\');
+      end;
+      // leave if no more sub paths
+      if (PNextSlash = nil)
+      or ((pNextSlash - OriginalSource) >= Count) then begin
+        exit;
+      end;
+      // copy char
+      pDest^ := pSource^;
+      Inc(PSource);
+      Inc(pDest);
+    end;
+  end;
+end;
+
+function _HandlePathLengthResult(nBufferLength: DWORD; lpBuffer: PWideChar; const AnsiBuff: AnsiString; Options: TPathLengthResultOptions): Integer;
+var
+  WideBuff: WideString;
+begin
+  WideBuff := AnsiBuff;
+  if nBufferLength > Cardinal(Length(WideBuff)) then begin
+    // normal
+    Result := Length(WideBuff);
+    WStrLCopy(lpBuffer, PWideChar(WideBuff), nBufferLength);
+  end else if (poExactCopy in Options) then begin
+    // exact
+    Result := nBufferLength;
+    _ExactStrCopyW(lpBuffer, PWideChar(WideBuff), nBufferLength);
+  end else begin
+    // other
+    if (poAllowDirectoryMode in Options)
+    and (nBufferLength = Cardinal(Length(WideBuff))) then begin
+      Result := Length(WideBuff) + 1;
+      WStrLCopy(lpBuffer, PWideChar(WideBuff), nBufferLength - 1);
+    end else begin
+      Result := Length(WideBuff) + 1;
+      if (nBufferLength > 0) then begin
+        if (poZeroSmallBuff in Options) then
+          lpBuffer^ := #0
+        else if (poExactCopySubPaths in Options) then
+          _ExactCopySubPaths(lpBuffer, PWideChar(WideBuff), nBufferLength);
+      end;
+    end;
+  end;
+end;
+
+function _HandleStringLengthResult(nBufferLength: DWORD; lpBuffer: PWideChar; const AnsiBuff: AnsiString; Options: TPathLengthResultOptions): Integer;
+var
+  WideBuff: WideString;
+begin
+  WideBuff := AnsiBuff;
+  if nBufferLength >= Cardinal(Length(WideBuff)) then begin
+    // normal
+    Result := Length(WideBuff);
+    WStrLCopy(lpBuffer, PWideChar(WideBuff), nBufferLength);
+  end else if nBufferLength = 0 then
+    Result := Length(WideBuff)
+  else
+    Result := 0;
+end;
+
+//-------------------------------------------
+
+function Tnt_RemoveDirectoryW(lpPathName: PWideChar): BOOL;
+begin
+  if Win32PlatformIsUnicode then
+    Result := RemoveDirectoryW{TNT-ALLOW RemoveDirectoryW}(PWideChar(lpPathName))
+  else
+    Result := RemoveDirectoryA{TNT-ALLOW RemoveDirectoryA}(PAnsiChar(AnsiString(lpPathName)));
+end;
+
+function Tnt_GetShortPathNameW(lpszLongPath: PWideChar; lpszShortPath: PWideChar;
+  cchBuffer: DWORD): DWORD;
+var
+  AnsiBuff: AnsiString;
+begin
+  if Win32PlatformIsUnicode then
+    Result := GetShortPathNameW{TNT-ALLOW GetShortPathNameW}(lpszLongPath, lpszShortPath, cchBuffer)
+  else begin
+    SetLength(AnsiBuff, MAX_PATH * 2);
+    SetLength(AnsiBuff, GetShortPathNameA{TNT-ALLOW GetShortPathNameA}(PAnsiChar(AnsiString(lpszLongPath)),
+      PAnsiChar(AnsiBuff), Length(AnsiBuff)));
+    Result := _HandlePathLengthResult(cchBuffer, lpszShortPath, AnsiBuff, [poExactCopySubPaths]);
+  end;
+end;
+
+function Tnt_GetFullPathNameW(lpFileName: PWideChar; nBufferLength: DWORD;
+  lpBuffer: PWideChar; var lpFilePart: PWideChar): DWORD;
+var
+  AnsiBuff: AnsiString;
+  AnsiFilePart: PAnsiChar;
+  AnsiLeadingChars: Integer;
+  WideLeadingChars: Integer;
+begin
+  if Win32PlatformIsUnicode then
+    Result := GetFullPathNameW{TNT-ALLOW GetFullPathNameW}(lpFileName, nBufferLength, lpBuffer, lpFilePart)
+  else begin
+    SetLength(AnsiBuff, MAX_PATH * 2);
+    SetLength(AnsiBuff, GetFullPathNameA{TNT-ALLOW GetFullPathNameA}(PAnsiChar(AnsiString(lpFileName)),
+      Length(AnsiBuff), PAnsiChar(AnsiBuff), AnsiFilePart));
+    Result := _HandlePathLengthResult(nBufferLength, lpBuffer, AnsiBuff, [poZeroSmallBuff]);
+    // deal w/ lpFilePart
+    if (AnsiFilePart = nil) or (nBufferLength < Result) then
+      lpFilePart := nil
+    else begin
+      AnsiLeadingChars := AnsiFilePart - PAnsiChar(AnsiBuff);
+      WideLeadingChars := Length(WideString(Copy(AnsiBuff, 1, AnsiLeadingChars)));
+      lpFilePart := lpBuffer + WideLeadingChars;
+    end;
+  end;
+end;
+
+function Tnt_CreateFileW(lpFileName: PWideChar; dwDesiredAccess, dwShareMode: DWORD;
+  lpSecurityAttributes: PSecurityAttributes; dwCreationDisposition, dwFlagsAndAttributes: DWORD;
+    hTemplateFile: THandle): THandle;
+begin
+  if Win32PlatformIsUnicode then
+    Result := CreateFileW{TNT-ALLOW CreateFileW}(lpFileName, dwDesiredAccess, dwShareMode,
+      lpSecurityAttributes, dwCreationDisposition, dwFlagsAndAttributes, hTemplateFile)
+  else
+    Result := CreateFileA{TNT-ALLOW CreateFileA}(PAnsiChar(AnsiString(lpFileName)), dwDesiredAccess, dwShareMode,
+      lpSecurityAttributes, dwCreationDisposition, dwFlagsAndAttributes, hTemplateFile)
+end;
+
+function Tnt_FindFirstFileW(lpFileName: PWideChar; var lpFindFileData: TWIN32FindDataW): THandle;
+var
+  Ansi_lpFindFileData: TWIN32FindDataA;
+begin
+  if Win32PlatformIsUnicode then
+    Result := FindFirstFileW{TNT-ALLOW FindFirstFileW}(lpFileName, lpFindFileData)
+  else begin
+    Result := FindFirstFileA{TNT-ALLOW FindFirstFileA}(PAnsiChar(AnsiString(lpFileName)),
+      Ansi_lpFindFileData);
+    if Result <> INVALID_HANDLE_VALUE then
+      _MakeWideWin32FindData(lpFindFileData, Ansi_lpFindFileData);
+  end;
+end;
+
+function Tnt_FindNextFileW(hFindFile: THandle; var lpFindFileData: TWIN32FindDataW): BOOL;
+var
+  Ansi_lpFindFileData: TWIN32FindDataA;
+begin
+  if Win32PlatformIsUnicode then
+    Result := FindNextFileW{TNT-ALLOW FindNextFileW}(hFindFile, lpFindFileData)
+  else begin
+    Result := FindNextFileA{TNT-ALLOW FindNextFileA}(hFindFile, Ansi_lpFindFileData);
+    if Result then
+      _MakeWideWin32FindData(lpFindFileData, Ansi_lpFindFileData);
+  end;
+end;
+
+function Tnt_GetFileAttributesW(lpFileName: PWideChar): DWORD;
+begin
+  if Win32PlatformIsUnicode then
+    Result := GetFileAttributesW{TNT-ALLOW GetFileAttributesW}(lpFileName)
+  else
+    Result := GetFileAttributesA{TNT-ALLOW GetFileAttributesA}(PAnsiChar(AnsiString(lpFileName)));
+end;
+
+function Tnt_SetFileAttributesW(lpFileName: PWideChar; dwFileAttributes: DWORD): BOOL;
+begin
+  if Win32PlatformIsUnicode then
+    Result := SetFileAttributesW{TNT-ALLOW SetFileAttributesW}(lpFileName, dwFileAttributes)
+  else
+    Result := SetFileAttributesA{TNT-ALLOW SetFileAttributesA}(PAnsiChar(AnsiString(lpFileName)), dwFileAttributes);
+end;
+
+function Tnt_CreateDirectoryW(lpPathName: PWideChar;
+  lpSecurityAttributes: PSecurityAttributes): BOOL;
+begin
+  if Win32PlatformIsUnicode then
+    Result := CreateDirectoryW{TNT-ALLOW CreateDirectoryW}(lpPathName, lpSecurityAttributes)
+  else
+    Result := CreateDirectoryA{TNT-ALLOW CreateDirectoryA}(PAnsiChar(AnsiString(lpPathName)), lpSecurityAttributes);
+end;
+
+function Tnt_MoveFileW(lpExistingFileName, lpNewFileName: PWideChar): BOOL;
+begin
+  if Win32PlatformIsUnicode then
+    Result := MoveFileW{TNT-ALLOW MoveFileW}(lpExistingFileName, lpNewFileName)
+  else
+    Result := MoveFileA{TNT-ALLOW MoveFileA}(PAnsiChar(AnsiString(lpExistingFileName)), PAnsiChar(AnsiString(lpNewFileName)));
+end;
+
+function Tnt_CopyFileW(lpExistingFileName, lpNewFileName: PWideChar; bFailIfExists: BOOL): BOOL;
+begin
+  if Win32PlatformIsUnicode then
+    Result := CopyFileW{TNT-ALLOW CopyFileW}(lpExistingFileName, lpNewFileName, bFailIfExists)
+  else
+    Result := CopyFileA{TNT-ALLOW CopyFileA}(PAnsiChar(AnsiString(lpExistingFileName)),
+      PAnsiChar(AnsiString(lpNewFileName)), bFailIfExists);
+end;
+
+function Tnt_DeleteFileW(lpFileName: PWideChar): BOOL;
+begin
+  if Win32PlatformIsUnicode then
+    Result := DeleteFileW{TNT-ALLOW DeleteFileW}(lpFileName)
+  else
+    Result := DeleteFileA{TNT-ALLOW DeleteFileA}(PAnsiChar(AnsiString(lpFileName)));
+end;
+
+function Tnt_DrawTextW(hDC: HDC; lpString: PWideChar; nCount: Integer;
+  var lpRect: TRect; uFormat: UINT): Integer;
+begin
+  if Win32PlatformIsUnicode then
+    Result := DrawTextW{TNT-ALLOW DrawTextW}(hDC, lpString, nCount, lpRect, uFormat)
+  else
+    Result := DrawTextA{TNT-ALLOW DrawTextA}(hDC,
+      PAnsiChar(AnsiString(_WStr(lpString, nCount))), -1, lpRect, uFormat);
+end;
+
+function Tnt_GetDiskFreeSpaceW(lpRootPathName: PWideChar; var lpSectorsPerCluster,
+  lpBytesPerSector, lpNumberOfFreeClusters, lpTotalNumberOfClusters: DWORD): BOOL;
+begin
+  if Win32PlatformIsUnicode then
+    Result := GetDiskFreeSpaceW{TNT-ALLOW GetDiskFreeSpaceW}(lpRootPathName,
+      lpSectorsPerCluster, lpBytesPerSector, lpNumberOfFreeClusters, lpTotalNumberOfClusters)
+  else
+    Result := GetDiskFreeSpaceA{TNT-ALLOW GetDiskFreeSpaceA}(PAnsiChar(AnsiString(lpRootPathName)),
+      lpSectorsPerCluster, lpBytesPerSector, lpNumberOfFreeClusters, lpTotalNumberOfClusters)
+end;
+
+function Tnt_GetVolumeInformationW(lpRootPathName: PWideChar; lpVolumeNameBuffer: PWideChar;
+  nVolumeNameSize: DWORD; lpVolumeSerialNumber: PDWORD;
+    var lpMaximumComponentLength, lpFileSystemFlags: DWORD; lpFileSystemNameBuffer: PWideChar;
+      nFileSystemNameSize: DWORD): BOOL;
+var
+  AnsiFileSystemNameBuffer: AnsiString;
+  AnsiVolumeNameBuffer: AnsiString;
+  AnsiBuffLen: DWORD;
+begin
+  if Win32PlatformIsUnicode then
+    Result := GetVolumeInformationW{TNT-ALLOW GetVolumeInformationW}(lpRootPathName, lpVolumeNameBuffer, nVolumeNameSize, lpVolumeSerialNumber, lpMaximumComponentLength, lpFileSystemFlags, lpFileSystemNameBuffer, nFileSystemNameSize)
+  else begin
+    SetLength(AnsiVolumeNameBuffer, MAX_COMPUTERNAME_LENGTH + 1);
+    SetLength(AnsiFileSystemNameBuffer, MAX_COMPUTERNAME_LENGTH + 1);
+    AnsiBuffLen := Length(AnsiFileSystemNameBuffer);
+    Result := GetVolumeInformationA{TNT-ALLOW GetVolumeInformationA}(PAnsiChar(AnsiString(lpRootPathName)), PAnsiChar(AnsiVolumeNameBuffer), AnsiBuffLen, lpVolumeSerialNumber, lpMaximumComponentLength, lpFileSystemFlags, PAnsiChar(AnsiFileSystemNameBuffer), AnsiBuffLen);
+    if Result then begin
+      SetLength(AnsiFileSystemNameBuffer, AnsiBuffLen);
+      if (nFileSystemNameSize <= AnsiBuffLen) or (Length(AnsiFileSystemNameBuffer) = 0) then
+        Result := False
+      else begin
+        WStrPLCopy(lpFileSystemNameBuffer, AnsiFileSystemNameBuffer, nFileSystemNameSize);
+        WStrPLCopy(lpVolumeNameBuffer, AnsiVolumeNameBuffer, nVolumeNameSize);
+      end;
+    end;
+  end;
+end;
+
+function Tnt_GetModuleFileNameW(hModule: HINST; lpFilename: PWideChar; nSize: DWORD): DWORD;
+var
+  AnsiBuff: AnsiString;
+begin
+  if Win32PlatformIsUnicode then
+    Result := GetModuleFileNameW{TNT-ALLOW GetModuleFileNameW}(hModule, lpFilename, nSize)
+  else begin
+    SetLength(AnsiBuff, MAX_PATH);
+    SetLength(AnsiBuff, GetModuleFileNameA{TNT-ALLOW GetModuleFileNameA}(hModule, PAnsiChar(AnsiBuff), Length(AnsiBuff)));
+    Result := _HandlePathLengthResult(nSize, lpFilename, AnsiBuff, [poExactCopy]);
+  end;
+end;
+
+function Tnt_GetTempPathW(nBufferLength: DWORD; lpBuffer: PWideChar): DWORD;
+var
+  AnsiBuff: AnsiString;
+begin
+  if Win32PlatformIsUnicode then
+    Result := GetTempPathW{TNT-ALLOW GetTempPathW}(nBufferLength, lpBuffer)
+  else begin
+    SetLength(AnsiBuff, MAX_PATH);
+    SetLength(AnsiBuff, GetTempPathA{TNT-ALLOW GetTempPathA}(Length(AnsiBuff), PAnsiChar(AnsiBuff)));
+    Result := _HandlePathLengthResult(nBufferLength, lpBuffer, AnsiBuff, [poAllowDirectoryMode, poZeroSmallBuff]);
+  end;
+end;
+
+function Tnt_GetTempFileNameW(lpPathName, lpPrefixString: PWideChar; uUnique: UINT;
+  lpTempFileName: PWideChar): UINT;
+var
+  AnsiBuff: AnsiString;
+begin
+  if Win32PlatformIsUnicode then
+    Result := GetTempFileNameW{TNT-ALLOW GetTempFileNameW}(lpPathName, lpPrefixString, uUnique, lpTempFileName)
+  else begin
+    SetLength(AnsiBuff, MAX_PATH);
+    Result := GetTempFileNameA{TNT-ALLOW GetTempFileNameA}(PAnsiChar(AnsiString(lpPathName)), PAnsiChar(lpPrefixString), uUnique, PAnsiChar(AnsiBuff));
+    AnsiBuff := PAnsiChar(AnsiBuff);
+    _HandlePathLengthResult(MAX_PATH, lpTempFileName, AnsiBuff, [poZeroSmallBuff]);
+  end;
+end;
+
+function Tnt_GetWindowsDirectoryW(lpBuffer: PWideChar; uSize: UINT): UINT;
+var
+  AnsiBuff: AnsiString;
+begin
+  if Win32PlatformIsUnicode then
+    Result := GetWindowsDirectoryW{TNT-ALLOW GetWindowsDirectoryW}(lpBuffer, uSize)
+  else begin
+    SetLength(AnsiBuff, MAX_PATH);
+    SetLength(AnsiBuff, GetWindowsDirectoryA{TNT-ALLOW GetWindowsDirectoryA}(PAnsiChar(AnsiBuff), Length(AnsiBuff)));
+    Result := _HandlePathLengthResult(uSize, lpBuffer, AnsiBuff, []);
+  end;
+end;
+
+function Tnt_GetSystemDirectoryW(lpBuffer: PWideChar; uSize: UINT): UINT;
+var
+  AnsiBuff: AnsiString;
+begin
+  if Win32PlatformIsUnicode then
+    Result := GetSystemDirectoryW{TNT-ALLOW GetSystemDirectoryW}(lpBuffer, uSize)
+  else begin
+    SetLength(AnsiBuff, MAX_PATH);
+    SetLength(AnsiBuff, GetSystemDirectoryA{TNT-ALLOW GetSystemDirectoryA}(PAnsiChar(AnsiBuff), Length(AnsiBuff)));
+    Result := _HandlePathLengthResult(uSize, lpBuffer, AnsiBuff, []);
+  end;
+end;
+
+function Tnt_GetCurrentDirectoryW(nBufferLength: DWORD; lpBuffer: PWideChar): DWORD;
+var
+  AnsiBuff: AnsiString;
+begin
+  if Win32PlatformIsUnicode then
+    Result := GetCurrentDirectoryW{TNT-ALLOW GetCurrentDirectoryW}(nBufferLength, lpBuffer)
+  else begin
+    SetLength(AnsiBuff, MAX_PATH);
+    SetLength(AnsiBuff, GetCurrentDirectoryA{TNT-ALLOW GetCurrentDirectoryA}(Length(AnsiBuff), PAnsiChar(AnsiBuff)));
+    Result := _HandlePathLengthResult(nBufferLength, lpBuffer, AnsiBuff, [poAllowDirectoryMode, poZeroSmallBuff]);
+  end;
+end;
+
+function Tnt_SetCurrentDirectoryW(lpPathName: PWideChar): BOOL;
+begin
+  if Win32PlatformIsUnicode then
+    Result := SetCurrentDirectoryW{TNT-ALLOW SetCurrentDirectoryW}(lpPathName)
+  else
+    Result := SetCurrentDirectoryA{TNT-ALLOW SetCurrentDirectoryA}(PAnsiChar(AnsiString(lpPathName)));
+end;
+
+function Tnt_GetComputerNameW(lpBuffer: PWideChar; var nSize: DWORD): BOOL;
+var
+  AnsiBuff: AnsiString;
+  AnsiBuffLen: DWORD;
+begin
+  if Win32PlatformIsUnicode then
+    Result := GetComputerNameW{TNT-ALLOW GetComputerNameW}(lpBuffer, nSize)
+  else begin
+    SetLength(AnsiBuff, MAX_COMPUTERNAME_LENGTH + 1);
+    AnsiBuffLen := Length(AnsiBuff);
+    Result := GetComputerNameA{TNT-ALLOW GetComputerNameA}(PAnsiChar(AnsiBuff), AnsiBuffLen);
+    if Result then begin
+      SetLength(AnsiBuff, AnsiBuffLen);
+      if (nSize <= AnsiBuffLen) or (Length(AnsiBuff) = 0) then begin
+        nSize := AnsiBuffLen + 1;
+        Result := False;
+      end else begin
+        WStrPLCopy(lpBuffer, AnsiBuff, nSize);
+        nSize := WStrLen(lpBuffer);
+      end;
+    end;
+  end;
+end;
+
+function Tnt_GetUserNameW(lpBuffer: PWideChar; var nSize: DWORD): BOOL;
+var
+  AnsiBuff: AnsiString;
+  AnsiBuffLen: DWORD;
+begin
+  if Win32PlatformIsUnicode then
+    Result := GetUserNameW{TNT-ALLOW GetUserNameW}(lpBuffer, nSize)
+  else begin
+    SetLength(AnsiBuff, 255);
+    AnsiBuffLen := Length(AnsiBuff);
+    Result := GetUserNameA{TNT-ALLOW GetUserNameA}(PAnsiChar(AnsiBuff), AnsiBuffLen);
+    if Result then begin
+      SetLength(AnsiBuff, AnsiBuffLen);
+      if (nSize <= AnsiBuffLen) or (Length(AnsiBuff) = 0) then begin
+        nSize := AnsiBuffLen + 1;
+        Result := False;
+      end else begin
+        WStrPLCopy(lpBuffer, AnsiBuff, nSize);
+        nSize := WStrLen(lpBuffer);
+      end;
+    end;
+  end;
+end;
+
+function Tnt_ShellExecuteW(hWnd: HWND; Operation, FileName, Parameters,
+  Directory: PWideChar; ShowCmd: Integer): HINST;
+begin
+  if Win32PlatformIsUnicode then
+    Result := ShellExecuteW{TNT-ALLOW ShellExecuteW}(hWnd, _PWideCharWithNil(WideString(Operation)),
+      FileName, Parameters,
+        Directory, ShowCmd)
+  else begin
+    Result := ShellExecuteA{TNT-ALLOW ShellExecuteA}(hWnd, _PAnsiCharWithNil(AnsiString(Operation)),
+      _PAnsiCharWithNil(AnsiString(FileName)), _PAnsiCharWithNil(AnsiString(Parameters)),
+        _PAnsiCharWithNil(AnsiString(Directory)), ShowCmd)
+  end;
+end;
+
+function Tnt_LoadLibraryW(lpLibFileName: PWideChar): HMODULE;
+begin
+  if Win32PlatformIsUnicode then
+    Result := LoadLibraryW{TNT-ALLOW LoadLibraryW}(lpLibFileName)
+  else
+    Result := LoadLibraryA{TNT-ALLOW LoadLibraryA}(PAnsiChar(AnsiString(lpLibFileName)));
+end;
+
+function Tnt_LoadLibraryExW(lpLibFileName: PWideChar; hFile: THandle; dwFlags: DWORD): HMODULE;
+begin
+  if Win32PlatformIsUnicode then
+    Result := LoadLibraryExW{TNT-ALLOW LoadLibraryExW}(lpLibFileName, hFile, dwFlags)
+  else
+    Result := LoadLibraryExA{TNT-ALLOW LoadLibraryExA}(PAnsiChar(AnsiString(lpLibFileName)), hFile, dwFlags);
+end;
+
+function Tnt_CreateProcessW(lpApplicationName: PWideChar; lpCommandLine: PWideChar;
+  lpProcessAttributes, lpThreadAttributes: PSecurityAttributes;
+    bInheritHandles: BOOL; dwCreationFlags: DWORD; lpEnvironment: Pointer;
+      lpCurrentDirectory: PWideChar; const lpStartupInfo: TStartupInfoW;
+        var lpProcessInformation: TProcessInformation): BOOL;
+var
+  AnsiStartupInfo: TStartupInfoA;
+begin
+  if Win32PlatformIsUnicode then begin
+    Result := CreateProcessW{TNT-ALLOW CreateProcessW}(lpApplicationName, lpCommandLine,
+      lpProcessAttributes, lpThreadAttributes, bInheritHandles, dwCreationFlags, lpEnvironment,
+        lpCurrentDirectory, lpStartupInfo, lpProcessInformation)
+  end else begin
+    CopyMemory(@AnsiStartupInfo, @lpStartupInfo, SizeOf(TStartupInfo));
+    AnsiStartupInfo.lpReserved := _PAnsiCharWithNil(AnsiString(lpStartupInfo.lpReserved));
+    AnsiStartupInfo.lpDesktop := _PAnsiCharWithNil(AnsiString(lpStartupInfo.lpDesktop));
+    AnsiStartupInfo.lpTitle := _PAnsiCharWithNil(AnsiString(lpStartupInfo.lpTitle));
+    Result := CreateProcessA{TNT-ALLOW CreateProcessA}(_PAnsiCharWithNil(AnsiString(lpApplicationName)),
+      _PAnsiCharWithNil(AnsiString(lpCommandLine)),
+        lpProcessAttributes, lpThreadAttributes, bInheritHandles, dwCreationFlags, lpEnvironment,
+          _PAnsiCharWithNil(AnsiString(lpCurrentDirectory)), AnsiStartupInfo, lpProcessInformation);
+  end;
+end;
+
+function Tnt_GetCurrencyFormatW(Locale: LCID; dwFlags: DWORD; lpValue: PWideChar;
+  lpFormat: PCurrencyFmtW; lpCurrencyStr: PWideChar; cchCurrency: Integer): Integer;
+const
+  MAX_ANSI_BUFF_SIZE = 64; // can a currency string actually be larger?
+var
+  AnsiFormat: TCurrencyFmtA;
+  PAnsiFormat: PCurrencyFmtA;
+  AnsiBuff: AnsiString;
+begin
+  if Win32PlatformIsUnicode then
+    Result := GetCurrencyFormatW{TNT-ALLOW GetCurrencyFormatW}(Locale, dwFlags, lpValue,
+        {$IFNDEF FPC} lpFormat {$ELSE} PCurrencyFmt(lpFormat) {$ENDIF},
+        lpCurrencyStr, cchCurrency)
+  else begin
+    if lpFormat = nil then
+      PAnsiFormat := nil
+    else begin
+      ZeroMemory(@AnsiFormat, SizeOf(AnsiFormat));
+      AnsiFormat.NumDigits        := lpFormat.NumDigits;
+      AnsiFormat.LeadingZero      := lpFormat.LeadingZero;
+      AnsiFormat.Grouping         := lpFormat.Grouping;
+      AnsiFormat.lpDecimalSep     := PAnsiChar(AnsiString(lpFormat.lpDecimalSep));
+      AnsiFormat.lpThousandSep    := PAnsiChar(AnsiString(lpFormat.lpThousandSep));
+      AnsiFormat.NegativeOrder    := lpFormat.NegativeOrder;
+      AnsiFormat.PositiveOrder    := lpFormat.PositiveOrder;
+      AnsiFormat.lpCurrencySymbol := PAnsiChar(AnsiString(lpFormat.lpCurrencySymbol));
+      PAnsiFormat := @AnsiFormat;
+    end;
+    SetLength(AnsiBuff, MAX_ANSI_BUFF_SIZE);
+    SetLength(AnsiBuff, GetCurrencyFormatA{TNT-ALLOW GetCurrencyFormatA}(Locale, dwFlags,
+      PAnsiChar(AnsiString(lpValue)), PAnsiFormat, PAnsiChar(AnsiBuff), MAX_ANSI_BUFF_SIZE));
+    Result := _HandleStringLengthResult(cchCurrency, lpCurrencyStr, AnsiBuff, []);
+  end;
+end;
+
+function Tnt_CompareStringW(Locale: LCID; dwCmpFlags: DWORD; lpString1: PWideChar;
+  cchCount1: Integer; lpString2: PWideChar; cchCount2: Integer): Integer;
+var
+  WideStr1, WideStr2: WideString;
+  AnsiStr1, AnsiStr2: AnsiString;
+begin
+  if Win32PlatformIsUnicode then
+    Result := CompareStringW{TNT-ALLOW CompareStringW}(Locale, dwCmpFlags, lpString1, cchCount1, lpString2, cchCount2)
+  else begin
+    WideStr1 := _WStr(lpString1, cchCount1);
+    WideStr2 := _WStr(lpString2, cchCount2);
+    if (dwCmpFlags = 0) then begin
+      // binary comparison
+      if WideStr1 < WideStr2 then
+        Result := 1
+      else if WideStr1 = WideStr2 then
+        Result := 2
+      else
+        Result := 3;
+    end else begin
+      AnsiStr1 := WideStr1;
+      AnsiStr2 := WideStr2;
+      Result := CompareStringA{TNT-ALLOW CompareStringA}(Locale, dwCmpFlags,
+        PAnsiChar(AnsiStr1), -1, PAnsiChar(AnsiStr2), -1);
+    end;
+  end;
+end;
+
+function Tnt_CharUpperW(lpsz: PWideChar): PWideChar;
+var
+  AStr: AnsiString;
+  WStr: WideString;
+begin
+  if Win32PlatformIsUnicode then
+    Result := CharUpperW{TNT-ALLOW CharUpperW}(lpsz)
+  else begin
+    if HiWord(Cardinal(lpsz)) = 0 then begin
+      // literal char mode
+      Result := lpsz;
+      if IsWideCharMappableToAnsi(WideChar(lpsz)) then begin
+        AStr := WideChar(lpsz); // single character may be more than one byte
+        CharUpperA{TNT-ALLOW CharUpperA}(PAnsiChar(AStr));
+        WStr := AStr; // should always be single wide char
+        if Length(WStr) = 1 then
+          Result := PWideChar(WStr[1]);
+      end
+    end else begin
+      // null-terminated string mode
+      Result := lpsz;
+      while lpsz^ <> #0 do begin
+        lpsz^ := WideChar(Tnt_CharUpperW(PWideChar(lpsz^)));
+        Inc(lpsz);
+      end;
+    end;
+  end;
+end;
+
+function Tnt_CharUpperBuffW(lpsz: PWideChar; cchLength: DWORD): DWORD;
+var
+  i: integer;
+begin
+  if Win32PlatformIsUnicode then
+    Result := CharUpperBuffW{TNT-ALLOW CharUpperBuffW}(lpsz, cchLength)
+  else begin
+    Result := cchLength;
+    for i := 1 to cchLength do begin
+      lpsz^ := WideChar(Tnt_CharUpperW(PWideChar(lpsz^)));
+      Inc(lpsz);
+    end;
+  end;
+end;
+
+function Tnt_CharLowerW(lpsz: PWideChar): PWideChar;
+var
+  AStr: AnsiString;
+  WStr: WideString;
+begin
+  if Win32PlatformIsUnicode then
+    Result := CharLowerW{TNT-ALLOW CharLowerW}(lpsz)
+  else begin
+    if HiWord(Cardinal(lpsz)) = 0 then begin
+      // literal char mode
+      Result := lpsz;
+      if IsWideCharMappableToAnsi(WideChar(lpsz)) then begin
+        AStr := WideChar(lpsz); // single character may be more than one byte
+        CharLowerA{TNT-ALLOW CharLowerA}(PAnsiChar(AStr));
+        WStr := AStr; // should always be single wide char
+        if Length(WStr) = 1 then
+          Result := PWideChar(WStr[1]);
+      end
+    end else begin
+      // null-terminated string mode
+      Result := lpsz;
+      while lpsz^ <> #0 do begin
+        lpsz^ := WideChar(Tnt_CharLowerW(PWideChar(lpsz^)));
+        Inc(lpsz);
+      end;
+    end;
+  end;
+end;
+
+function Tnt_CharLowerBuffW(lpsz: PWideChar; cchLength: DWORD): DWORD;
+var
+  i: integer;
+begin
+  if Win32PlatformIsUnicode then
+    Result := CharLowerBuffW{TNT-ALLOW CharLowerBuffW}(lpsz, cchLength)
+  else begin
+    Result := cchLength;
+    for i := 1 to cchLength do begin
+      lpsz^ := WideChar(Tnt_CharLowerW(PWideChar(lpsz^)));
+      Inc(lpsz);
+    end;
+  end;
+end;
+
+function Tnt_GetStringTypeExW(Locale: LCID; dwInfoType: DWORD;
+  lpSrcStr: PWideChar; cchSrc: Integer; var lpCharType): BOOL; 
+var
+  AStr: AnsiString;
+begin
+  if Win32PlatformIsUnicode then
+    Result := GetStringTypeExW{TNT-ALLOW GetStringTypeExW}(Locale, dwInfoType, lpSrcStr, cchSrc, lpCharType)
+  else begin
+    AStr := _WStr(lpSrcStr, cchSrc);
+    Result := GetStringTypeExA{TNT-ALLOW GetStringTypeExA}(Locale, dwInfoType,
+      PAnsiChar(AStr), -1, lpCharType);
+  end;
+end;
+
+function Win9x_LoadStringW(hInstance: HINST; uID: UINT; lpBuffer: PWideChar; nBufferMax: Integer): Integer;
+// This function originated by the WINE Project.
+//   It was translated to Pascal by Francisco Leong.
+//     It was further modified by Troy Wolbrink.
+var
+  hmem: HGLOBAL;
+  hrsrc: THandle;
+  p: PWideChar;
+  string_num, i: Integer;
+  block: Integer;
+begin
+  Result := 0;
+  // Netscape v3 fix...
+  if (HIWORD(uID) = $FFFF) then begin
+    uID := UINT(-(Integer(uID)));
+  end;
+  // figure block, string_num
+  block := ((uID shr 4) and $FFFF) + 1; // bits 4 - 19, mask out bits 20 - 31, inc by 1
+  string_num := uID and $000F;
+  // get handle & pointer to string block
+  hrsrc := FindResource{TNT-ALLOW FindResource}(hInstance, MAKEINTRESOURCE(block), RT_STRING);
+  if (hrsrc <> 0) then
+  begin
+    hmem := LoadResource(hInstance, hrsrc);
+    if (hmem <> 0) then
+    begin
+      p := LockResource(hmem);
+      // walk the block to the requested string
+      for i := 0 to string_num - 1 do begin
+        p := p + Integer(p^) + 1;
+      end;
+      Result := Integer(p^); { p points to the length of string }
+      Inc(p); { p now points to the actual string }
+      if (lpBuffer <> nil) and (nBufferMax > 0) then
+      begin
+        Result := min(nBufferMax - 1, Result); { max length to copy }
+        if (Result > 0) then begin
+          CopyMemory(lpBuffer, p, Result * sizeof(WideChar));
+        end;
+        lpBuffer[Result] := WideChar(0); { null terminate }
+      end;
+    end;
+  end;
+end;
+
+function Tnt_LoadStringW(hInstance: HINST; uID: UINT; lpBuffer: PWideChar; nBufferMax: Integer): Integer;
+begin
+  if Win32PlatformIsUnicode then
+    Result := Windows.LoadStringW{TNT-ALLOW LoadStringW}(hInstance, uID, lpBuffer, nBufferMax)
+  else
+    Result := Win9x_LoadStringW(hInstance, uID, lpBuffer, nBufferMax);
+end;
+
+function Tnt_InsertMenuItemW(hMenu: HMENU; uItem: DWORD; fByPosition: BOOL; lpmii: TMenuItemInfoW): BOOL;
+begin
+  if Win32PlatformIsUnicode then
+    Result := InsertMenuItemW{TNT-ALLOW InsertMenuItemW}(hMenu, uItem, fByPosition,
+        {$IFDEF FPC}@{$ENDIF}lpmii)
+  else begin
+    TMenuItemInfoA(lpmii).dwTypeData := PAnsiChar(AnsiString(lpmii.dwTypeData));
+    Result := InsertMenuItemA{TNT-ALLOW InsertMenuItemA}(hMenu, uItem, fByPosition,
+        {$IFDEF FPC}@{$ENDIF}TMenuItemInfoA(lpmii));
+  end;
+end;
+
+function Tnt_ExtractIconExW(lpszFile: PWideChar; nIconIndex: Integer;
+  var phiconLarge, phiconSmall: HICON; nIcons: UINT): UINT;
+begin
+  if Win32PlatformIsUnicode then
+    Result := ExtractIconExW{TNT-ALLOW ExtractIconExW}(lpszFile,
+      nIconIndex, phiconLarge, phiconSmall, nIcons)
+  else
+    Result := ExtractIconExA{TNT-ALLOW ExtractIconExA}(PAnsiChar(AnsiString(lpszFile)),
+      nIconIndex, phiconLarge, phiconSmall, nIcons);
+end;
+
+function Tnt_ExtractAssociatedIconW(hInst: HINST; lpIconPath: PWideChar;
+  var lpiIcon: Word): HICON;
+begin
+  if Win32PlatformIsUnicode then
+    Result := ExtractAssociatedIconW{TNT-ALLOW ExtractAssociatedIconW}(hInst,
+      lpIconPath, {$IFDEF FPC}@{$ENDIF}lpiIcon)
+  else
+    Result := ExtractAssociatedIconA{TNT-ALLOW ExtractAssociatedIconA}(hInst,
+      PAnsiChar(AnsiString(lpIconPath)), {$IFDEF FPC}@{$ENDIF}lpiIcon)
+end;
+
+function Tnt_GetFileVersionInfoSizeW(lptstrFilename: PWideChar; var lpdwHandle: DWORD): DWORD;
+begin
+  if Win32PlatformIsUnicode then
+    Result := GetFileVersionInfoSizeW{TNT-ALLOW GetFileVersionInfoSizeW}(lptstrFilename, lpdwHandle)
+  else
+    Result := GetFileVersionInfoSizeA{TNT-ALLOW GetFileVersionInfoSizeA}(PAnsiChar(AnsiString(lptstrFilename)), lpdwHandle);
+end;
+
+function Tnt_GetFileVersionInfoW(lptstrFilename: PWideChar; dwHandle, dwLen: DWORD;
+  lpData: Pointer): BOOL;
+begin
+  if Win32PlatformIsUnicode then
+    Result := GetFileVersionInfoW{TNT-ALLOW GetFileVersionInfoW}(lptstrFilename, dwHandle, dwLen, lpData)
+  else
+    Result := GetFileVersionInfoA{TNT-ALLOW GetFileVersionInfoA}(PAnsiChar(AnsiString(lptstrFilename)), dwHandle, dwLen, lpData);
+end;
+
+var
+  Last_VerQueryValue_String: WideString;
+
+function Tnt_VerQueryValueW(pBlock: Pointer; lpSubBlock: PWideChar;
+  var lplpBuffer: Pointer; var puLen: UINT): BOOL;
+var
+  AnsiBuff: AnsiString;
+begin
+  if Win32PlatformIsUnicode then
+    Result := VerQueryValueW{TNT-ALLOW VerQueryValueW}(pBlock, lpSubBlock, lplpBuffer, puLen)
+  else begin
+    Result := VerQueryValueA{TNT-ALLOW VerQueryValueA}(pBlock, PAnsiChar(AnsiString(lpSubBlock)), lplpBuffer, puLen);
+    if WideTextPos(VQV_STRINGFILEINFO, lpSubBlock) <> 1 then
+    else begin
+      {  /StringFileInfo, convert ansi result to unicode }
+      SetString(AnsiBuff, PAnsiChar(lplpBuffer), puLen);
+      Last_VerQueryValue_String := AnsiBuff;
+      lplpBuffer := PWideChar(Last_VerQueryValue_String);
+      puLen := Length(Last_VerQueryValue_String);
+    end;
+  end;
+end;
+
+//---------------------------------------------------------------------------------------
+//  Wide functions from Shell32.dll should be loaded dynamically (no stub on early Win95)
+//---------------------------------------------------------------------------------------
+
+type
+  TSHFileOperationW = function(var lpFileOp: TSHFileOpStructW): Integer; stdcall;
+  TSHBrowseForFolderW = function(var lpbi: TBrowseInfoW): PItemIDList; stdcall;
+  TSHGetPathFromIDListW = function(pidl: PItemIDList; pszPath: PWideChar): BOOL; stdcall;
+  TSHGetFileInfoW = function(pszPath: PWideChar; dwFileAttributes: DWORD;
+    var psfi: TSHFileInfoW; cbFileInfo, uFlags: UINT): DWORD; stdcall;
+
+var
+  Safe_SHFileOperationW: TSHFileOperationW = nil;
+  Safe_SHBrowseForFolderW: TSHBrowseForFolderW = nil;
+  Safe_SHGetPathFromIDListW: TSHGetPathFromIDListW = nil;
+  Safe_SHGetFileInfoW: TSHGetFileInfoW = nil;
+
+var Shell32DLL: HModule = 0;
+
+procedure LoadWideShell32Procs;
+begin
+  if Shell32DLL = 0 then begin
+    Shell32DLL := WinCheckH(Tnt_LoadLibraryW('shell32.dll'));
+    Safe_SHFileOperationW := WinCheckP(GetProcAddress(Shell32DLL, 'SHFileOperationW'));
+    Safe_SHBrowseForFolderW := WinCheckP(GetProcAddress(Shell32DLL, 'SHBrowseForFolderW'));
+    Safe_SHGetPathFromIDListW := WinCheckP(GetProcAddress(Shell32DLL, 'SHGetPathFromIDListW'));
+    Safe_SHGetFileInfoW := WinCheckP(GetProcAddress(Shell32DLL, 'SHGetFileInfoW'));
+  end;
+end;
+
+function Tnt_SHFileOperationW(var lpFileOp: TSHFileOpStructW): Integer;
+var
+  AnsiFileOp: TSHFileOpStructA;
+  MapCount: Integer;
+  PAnsiMap: PSHNameMappingA;
+  PWideMap: PSHNameMappingW;
+  OldPath: WideString;
+  NewPath: WideString;
+  i: integer;
+begin
+  if Win32PlatformIsUnicode then begin
+    LoadWideShell32Procs;
+    Result := Safe_SHFileOperationW(lpFileOp);
+  end else begin
+    AnsiFileOp := TSHFileOpStructA(lpFileOp);
+    // convert PChar -> PWideChar
+    if lpFileOp.pFrom = nil then
+      AnsiFileOp.pFrom := nil
+    else
+      AnsiFileOp.pFrom := PAnsiChar(AnsiString(ExtractStringArrayStr(lpFileOp.pFrom)));
+    if lpFileOp.pTo = nil then
+      AnsiFileOp.pTo := nil
+    else
+      AnsiFileOp.pTo := PAnsiChar(AnsiString(ExtractStringArrayStr(lpFileOp.pTo)));
+    AnsiFileOp.lpszProgressTitle := PAnsiChar(AnsiString(lpFileOp.lpszProgressTitle));
+    Result := SHFileOperationA{TNT-ALLOW SHFileOperationA}(
+        {$IFDEF FPC}@{$ENDIF}AnsiFileOp);
+    // return struct results
+    lpFileOp.fAnyOperationsAborted := AnsiFileOp.fAnyOperationsAborted;
+    lpFileOp.hNameMappings := nil;
+    if (AnsiFileOp.hNameMappings <> nil)
+    and ((FOF_WANTMAPPINGHANDLE and AnsiFileOp.fFlags) <> 0) then begin
+      // alloc mem
+      MapCount := PSHNameMappingHeaderA(AnsiFileOp.hNameMappings).cNumOfMappings;
+      lpFileOp.hNameMappings :=
+        AllocMem(SizeOf({hNameMappings}Cardinal) + SizeOf(TSHNameMappingW) * MapCount);
+      PSHNameMappingHeaderW(lpFileOp.hNameMappings).cNumOfMappings := MapCount;
+      // init pointers
+      PAnsiMap := PSHNameMappingHeaderA(AnsiFileOp.hNameMappings).lpNM;
+      PWideMap := PSHNameMappingHeaderW(lpFileOp.hNameMappings).lpNM;
+      for i := 1 to MapCount do begin
+        // old path
+        OldPath := Copy(PAnsiMap.pszOldPath, 1, PAnsiMap.cchOldPath);
+        PWideMap.pszOldPath := WStrNew(PWideChar(OldPath));
+        PWideMap.cchOldPath := WStrLen(PWideMap.pszOldPath);
+        // new path
+        NewPath := Copy(PAnsiMap.pszNewPath, 1, PAnsiMap.cchNewPath);
+        PWideMap.pszNewPath := WStrNew(PWideChar(NewPath));
+        PWideMap.cchNewPath := WStrLen(PWideMap.pszNewPath);
+        // next record
+        Inc(PAnsiMap);
+        Inc(PWideMap);
+      end;
+    end;
+  end;
+end;
+
+procedure Tnt_SHFreeNameMappings(hNameMappings: THandle);
+var
+  i: integer;
+  MapCount: Integer;
+  PWideMap: PSHNameMappingW;
+begin
+  if Win32PlatformIsUnicode then
+    SHFreeNameMappings{TNT-ALLOW SHFreeNameMappings}(hNameMappings)
+  else begin
+    // free strings
+    MapCount := PSHNameMappingHeaderW(hNameMappings).cNumOfMappings;
+    PWideMap := PSHNameMappingHeaderW(hNameMappings).lpNM;
+    for i := 1 to MapCount do begin
+      WStrDispose(PWideMap.pszOldPath);
+      WStrDispose(PWideMap.pszNewPath);
+      Inc(PWideMap);
+    end;
+    // free struct
+    FreeMem(Pointer(hNameMappings));
+  end;
+end;
+
+function Tnt_SHBrowseForFolderW(var lpbi: TBrowseInfoW): PItemIDList;
+var
+  AnsiInfo: TBrowseInfoA;
+  AnsiBuffer: array[0..MAX_PATH] of AnsiChar;
+begin
+  if Win32PlatformIsUnicode then begin
+    LoadWideShell32Procs;
+    Result := Safe_SHBrowseForFolderW(lpbi);
+  end else begin
+    AnsiInfo := TBrowseInfoA(lpbi);
+    AnsiInfo.lpszTitle := PAnsiChar(AnsiString(lpbi.lpszTitle));
+    if lpbi.pszDisplayName <> nil then
+      AnsiInfo.pszDisplayName := AnsiBuffer;
+    Result := SHBrowseForFolderA{TNT-ALLOW SHBrowseForFolderA}(
+        {$IFDEF FPC}@{$ENDIF}AnsiInfo);
+    if lpbi.pszDisplayName <> nil then
+      WStrPCopy(lpbi.pszDisplayName, AnsiInfo.pszDisplayName);
+    lpbi.iImage := AnsiInfo.iImage;
+  end;
+end;
+
+function Tnt_SHGetPathFromIDListW(pidl: PItemIDList; pszPath: PWideChar): BOOL;
+var
+  AnsiPath: AnsiString;
+begin
+  if Win32PlatformIsUnicode then begin
+    LoadWideShell32Procs;
+    Result := Safe_SHGetPathFromIDListW(pidl, pszPath);
+  end else begin
+    SetLength(AnsiPath, MAX_PATH);
+    Result := SHGetPathFromIDListA{TNT-ALLOW SHGetPathFromIDListA}(pidl, PAnsiChar(AnsiPath));
+    if Result then
+      WStrPCopy(pszPath, PAnsiChar(AnsiPath))
+  end;
+end;
+
+function Tnt_SHGetFileInfoW(pszPath: PWideChar; dwFileAttributes: DWORD;
+  var psfi: TSHFileInfoW; cbFileInfo, uFlags: UINT): DWORD;
+var
+  SHFileInfoA: TSHFileInfoA;
+begin
+  if Win32PlatformIsUnicode then begin
+    LoadWideShell32Procs;
+    Result := Safe_SHGetFileInfoW(pszPath, dwFileAttributes, psfi, cbFileInfo, uFlags)
+  end else begin
+    Result := SHGetFileInfoA{TNT-ALLOW SHGetFileInfoA}(PAnsiChar(AnsiString(pszPath)),
+      dwFileAttributes, SHFileInfoA, SizeOf(TSHFileInfoA), uFlags);
+    // update pfsi...
+    ZeroMemory(@psfi, SizeOf(TSHFileInfoW));
+    psfi.hIcon := SHFileInfoA.hIcon;
+    psfi.iIcon := SHFileInfoA.iIcon;
+    psfi.dwAttributes := SHFileInfoA.dwAttributes;
+    WStrPLCopy(psfi.szDisplayName, SHFileInfoA.szDisplayName, MAX_PATH);
+    WStrPLCopy(psfi.szTypeName, SHFileInfoA.szTypeName, 80);
+  end;
+end;
+
+
+function Tnt_Is_IntResource(ResStr: LPCWSTR): Boolean;
+begin
+  Result := HiWord(Cardinal(ResStr)) = 0;
+end;
+
+function LANGIDFROMLCID(lcid: LCID): WORD;
+begin
+  Result := LoWord(lcid);
+end;
+
+function MAKELANGID(usPrimaryLanguage, usSubLanguage: WORD): WORD;
+begin
+  Result := (usSubLanguage shl 10) or usPrimaryLanguage;
+end;
+
+function MAKELCID(wLanguageID: WORD; wSortID: WORD = SORT_DEFAULT): LCID;
+begin
+  Result := MakeLong(wLanguageID, wSortID);
+end;
+
+function PRIMARYLANGID(lgid: WORD): WORD;
+begin
+  Result := lgid and $03FF;
+end;
+
+function SORTIDFROMLCID(lcid: LCID): WORD;
+begin
+  Result := HiWord(lcid);
+end;
+
+function SUBLANGID(lgid: WORD): WORD;
+begin
+  Result := lgid shr 10;
+end;
+
+initialization
+
+finalization
+  if Shell32DLL <> 0 then
+    FreeLibrary(Shell32DLL);
+
+end.
diff --git a/Lua/src/lib/collections/CollArray.pas b/Lua/src/lib/collections/CollArray.pas
new file mode 100644
index 00000000..a10ba905
--- /dev/null
+++ b/Lua/src/lib/collections/CollArray.pas
@@ -0,0 +1,183 @@
+unit CollArray;
+
+(*****************************************************************************
+ * Copyright 2003 by Matthew Greet
+ * This library is free software; you can redistribute it and/or modify it
+ * under the terms of the GNU Lesser General Public License as published by the
+ * Free Software Foundation; either version 2.1 of the License, or (at your
+ * option) any later version.
+ *
+ * This library is distributed in the hope that it will be useful, but WITHOUT
+ * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS
+ * FOR A PARTICULAR PURPOSE. See the GNU Lesser General Public License for more
+ * details. (http://opensource.org/licenses/lgpl-license.php)
+ * 
+ * See http://www.warmachine.u-net.com/delphi_collections for updates and downloads.
+ *
+ * $Version: v1.0.3 $
+ * $Revision: 1.2 $
+ * $Log: D:\QVCS Repositories\Delphi Collections\CollArray.qbt $
+ * 
+ *   Colllection implementations based on arrays.
+ * 
+ * Revision 1.2  by: Matthew Greet  Rev date: 12/06/04 20:02:16
+ *   Capacity property.
+ * 
+ * Revision 1.1  by: Matthew Greet  Rev date: 06/04/03 10:30:36
+ *   Size property dropped. 
+ *   Unused abstract functions still implemented.
+ * 
+ * Revision 1.0  by: Matthew Greet  Rev date: 01/03/03 10:50:02
+ *   Initial revision.
+ *
+ * FPC compatibility fixes by: UltraStar Deluxe Team
+ *
+ * $Endlog$
+ *****************************************************************************)
+
+{$IFDEF FPC}
+  {$MODE Delphi}{$H+}
+{$ENDIF}
+ 
+interface
+
+uses
+    Collections;
+
+type
+    TArray = class(TAbstractList)
+    private
+        FArray: array of ICollectable;
+    protected
+        function TrueGetItem(Index: Integer): ICollectable; override;
+        procedure TrueSetItem(Index: Integer; const Value: ICollectable); override;
+        procedure TrueAppend(const Item: ICollectable); override;
+        procedure TrueClear; override;
+        function TrueDelete(Index: Integer): ICollectable; override;
+        procedure TrueInsert(Index: Integer; const Item: ICollectable); override;
+    public
+        constructor Create(NaturalItemsOnly: Boolean); override;
+        constructor Create(const ItemArray: array of ICollectable; NaturalItemsOnly: Boolean = false); override;
+        constructor Create(Size: Integer; NaturalItemsOnly: Boolean = false); overload; virtual;
+        constructor Create(const Collection: ICollection); override;
+        destructor Destroy; override;
+        function GetCapacity: Integer; override;
+        procedure SetCapacity(Value: Integer); override;
+        function GetFixedSize: Boolean; override;
+        function GetSize: Integer; override;
+    end;
+
+implementation
+
+constructor TArray.Create(NaturalItemsOnly: Boolean);
+begin
+    Create(0, NaturalItemsOnly);
+end;
+
+constructor TArray.Create(Size: Integer; NaturalItemsOnly: Boolean = false);
+begin
+    inherited Create(NaturalItemsOnly);
+    SetLength(FArray, Size);
+end;
+
+constructor TArray.Create(const ItemArray: array of ICollectable; NaturalItemsOnly: Boolean);
+var
+    Item: ICollectable;
+    ItemError: TCollectionError;
+    I: Integer;
+begin
+    inherited Create(ItemArray, NaturalItemsOnly);
+    SetLength(FArray, Length(ItemArray));
+    for I := Low(ItemArray) to High(ItemArray) do
+    begin
+        Item := ItemArray[I];
+        ItemError := ItemAllowed(Item);
+        if ItemError <> ceOK then
+        begin
+            CollectionError(ItemError);
+        end
+        else
+            Items[I] := Item;
+    end;
+end;
+
+constructor TArray.Create(const Collection: ICollection);
+var
+    Iterator: IIterator;
+    I: Integer;
+begin
+    inherited Create(Collection);
+    SetLength(FArray, Collection.GetSize);
+    Iterator := Collection.GetIterator;
+    I := 0;
+    while not Iterator.EOF do
+    begin
+        Items[I] := Iterator.CurrentItem;
+        Inc(I);
+        Iterator.Next;
+    end;
+end;
+
+destructor TArray.Destroy;
+var
+    I: Integer;
+begin
+    // Delete interface references to all items
+    for I := Low(FArray) to High(FArray) do
+    begin
+        FArray[I] := nil;
+    end;
+    inherited Destroy;
+end;
+
+function TArray.TrueGetItem(Index: Integer): ICollectable;
+begin
+    Result := FArray[Index];
+end;
+
+procedure TArray.TrueSetItem(Index: Integer; const Value: ICollectable);
+begin
+    FArray[Index] := Value;
+end;
+
+procedure TArray.TrueAppend(const Item: ICollectable);
+begin
+    // Ignored as collection is fixed size
+end;
+
+procedure TArray.TrueClear;
+begin
+    // Ignored as collection is fixed size
+end;
+
+function TArray.TrueDelete(Index: Integer): ICollectable;
+begin
+    // Ignored as collection is fixed size
+end;
+
+procedure TArray.TrueInsert(Index: Integer; const Item: ICollectable);
+begin
+    // Ignored as collection is fixed size
+end;
+
+function TArray.GetCapacity: Integer;
+begin
+    Result := Size;
+end;
+
+procedure TArray.SetCapacity(Value: Integer);
+begin
+    // Ignored
+end;
+
+function TArray.GetFixedSize: Boolean;
+begin
+    Result := true;
+end;
+
+function TArray.GetSize: Integer;
+begin
+    Result := Length(FArray);
+end;
+
+end.
diff --git a/Lua/src/lib/collections/CollHash.pas b/Lua/src/lib/collections/CollHash.pas
new file mode 100644
index 00000000..796fc740
--- /dev/null
+++ b/Lua/src/lib/collections/CollHash.pas
@@ -0,0 +1,1497 @@
+unit CollHash;
+
+(*****************************************************************************
+ * Copyright 2003 by Matthew Greet
+ * This library is free software; you can redistribute it and/or modify it
+ * under the terms of the GNU Lesser General Public License as published by the
+ * Free Software Foundation; either version 2.1 of the License, or (at your
+ * option) any later version.
+ *
+ * This library is distributed in the hope that it will be useful, but WITHOUT
+ * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS
+ * FOR A PARTICULAR PURPOSE. See the GNU Lesser General Public License for more
+ * details. (http://opensource.org/licenses/lgpl-license.php)
+ * 
+ * See http://www.warmachine.u-net.com/delphi_collections for updates and downloads.
+ *
+ * $Version: v1.0.3 $
+ * $Revision: 1.1.1.2 $
+ * $Log: D:\QVCS Repositories\Delphi Collections\CollHash.qbt $
+ * 
+ *   Collection implementations based on hash tables.
+ * 
+ * Revision 1.1.1.2  by: Matthew Greet  Rev date: 12/06/04 20:04:30
+ *   Capacity property.
+ * 
+ * Revision 1.1.1.1  by: Matthew Greet  Rev date: 24/10/03 16:48:16
+ *   v1.0 branch.
+ * 
+ * Revision 1.1  by: Matthew Greet  Rev date: 06/04/03 10:40:16
+ *   Added integer map and string map versions. 
+ *   THashSet uses its own implementation, not THashMap. 
+ *   DefaulMaxLoadFactor changed.
+ * 
+ * Revision 1.0  by: Matthew Greet  Rev date: 01/03/03 10:50:02
+ *   Initial revision.
+ * 
+ * FPC compatibility fixes by: UltraStar Deluxe Team
+ *
+ * $Endlog$
+ *****************************************************************************)
+
+{$IFDEF FPC}
+  {$MODE Delphi}{$H+}
+{$ENDIF}
+ 
+interface
+
+uses
+    Classes, Math,
+    Collections;
+
+const
+    DefaultTableSize = 100;
+    MaxLoadFactorMin = 0.01;        // Minimum allowed value for MaxLoadFactor property.
+    DefaultMaxLoadFactor = 5.0;
+
+type
+    THashMap = class(TAbstractMap)
+    private
+        FArray: TListArray;
+        FCapacity: Integer;
+        FMaxLoadFactor: Double;
+        FSize: Integer;
+        FTableSize: Integer;
+    protected
+        function GetAssociationIterator: IMapIterator; override;
+        procedure SetMaxLoadFactor(Value: Double); virtual;
+        procedure SetTableSize(Value: Integer); virtual;
+        procedure ChangeCapacity(Value: TListArray); virtual;
+        procedure CheckLoadFactor(AlwaysChangeCapacity: Boolean); virtual;
+        function GetHash(const Key: ICollectable): Integer; virtual;
+        function GetKeyPosition(const Key: ICollectable): TCollectionPosition; override;
+        procedure Rehash;
+        procedure TrueClear; override;
+        function TrueGet(Position: TCollectionPosition): IAssociation; override;
+        function TruePut(Position: TCollectionPosition; const Association: IAssociation): IAssociation; override;
+        function TrueRemove2(Position: TCollectionPosition): IAssociation; override;
+    public
+        constructor Create(NaturalItemsOnly: Boolean; NaturalKeysOnly: Boolean); override;
+        destructor Destroy; override;
+        class function GetAlwaysNaturalKeys: Boolean; override;
+        function GetCapacity: Integer; override;
+        procedure SetCapacity(Value: Integer); override;
+        function GetNaturalKeyIID: TGUID; override;
+        function GetSize: Integer; override;
+        property MaxLoadFactor: Double read FMaxLoadFactor write SetMaxLoadFactor;
+        property TableSize: Integer read FTableSize write SetTableSize;
+    end;
+
+    THashSet = class(TAbstractSet)
+    private
+        FArray: TListArray;
+        FCapacity: Integer;
+        FMaxLoadFactor: Double;
+        FSize: Integer;
+        FTableSize: Integer;
+    protected
+        procedure SetMaxLoadFactor(Value: Double); virtual;
+        procedure SetTableSize(Value: Integer); virtual;
+        procedure ChangeCapacity(Value: TListArray); virtual;
+        procedure CheckLoadFactor(AlwaysChangeCapacity: Boolean); virtual;
+        function GetHash(const Item: ICollectable): Integer; virtual;
+        function GetPosition(const Item: ICollectable): TCollectionPosition; override;
+        procedure Rehash;
+        procedure TrueAdd2(Position: TCollectionPosition; const Item: ICollectable); override;
+        procedure TrueClear; override;
+        function TrueGet(Position: TCollectionPosition): ICollectable; override;
+        procedure TrueRemove2(Position: TCollectionPosition); override;
+    public
+        constructor Create(NaturalItemsOnly: Boolean); override;
+        destructor Destroy; override;
+        class function GetAlwaysNaturalItems: Boolean; override;
+        function GetCapacity: Integer; override;
+        procedure SetCapacity(Value: Integer); override;
+        function GetIterator: IIterator; override;
+        function GetNaturalItemIID: TGUID; override;
+        function GetSize: Integer; override;
+        property MaxLoadFactor: Double read FMaxLoadFactor write SetMaxLoadFactor;
+        property TableSize: Integer read FTableSize write SetTableSize;
+    end;
+
+    THashIntegerMap = class(TAbstractIntegerMap)
+    private
+        FArray: TListArray;
+        FCapacity: Integer;
+        FMaxLoadFactor: Double;
+        FSize: Integer;
+        FTableSize: Integer;
+    protected
+        function GetAssociationIterator: IIntegerMapIterator; override;
+        procedure SetMaxLoadFactor(Value: Double); virtual;
+        procedure SetTableSize(Value: Integer); virtual;
+        procedure ChangeCapacity(Value: TListArray); virtual;
+        procedure CheckLoadFactor(AlwaysChangeCapacity: Boolean); virtual;
+        function GetHash(const Key: Integer): Integer; virtual;
+        function GetKeyPosition(const Key: Integer): TCollectionPosition; override;
+        procedure Rehash;
+        procedure TrueClear; override;
+        function TrueGet(Position: TCollectionPosition): IIntegerAssociation; override;
+        function TruePut(Position: TCollectionPosition; const Association: IIntegerAssociation): IIntegerAssociation; override;
+        function TrueRemove2(Position: TCollectionPosition): IIntegerAssociation; override;
+    public
+        constructor Create; override;
+        constructor Create(NaturalItemsOnly: Boolean); override;
+        constructor Create(NaturalItemsOnly: Boolean; TableSize: Integer; MaxLoadFactor: Double = DefaultMaxLoadFactor); overload; virtual;
+        destructor Destroy; override;
+        function GetCapacity: Integer; override;
+        procedure SetCapacity(Value: Integer); override;
+        function GetSize: Integer; override;
+        property MaxLoadFactor: Double read FMaxLoadFactor write SetMaxLoadFactor;
+        property TableSize: Integer read FTableSize write SetTableSize;
+    end;
+
+    THashStringMap = class(TAbstractStringMap)
+    private
+        FArray: TListArray;
+        FCapacity: Integer;
+        FMaxLoadFactor: Double;
+        FSize: Integer;
+        FTableSize: Integer;
+    protected
+        function GetAssociationIterator: IStringMapIterator; override;
+        procedure SetMaxLoadFactor(Value: Double); virtual;
+        procedure SetTableSize(Value: Integer); virtual;
+        procedure ChangeCapacity(Value: TListArray); virtual;
+        procedure CheckLoadFactor(AlwaysChangeCapacity: Boolean); virtual;
+        function GetHash(const Key: String): Integer; virtual;
+        function GetKeyPosition(const Key: String): TCollectionPosition; override;
+        procedure Rehash;
+        procedure TrueClear; override;
+        function TrueGet(Position: TCollectionPosition): IStringAssociation; override;
+        function TruePut(Position: TCollectionPosition; const Association: IStringAssociation): IStringAssociation; override;
+        function TrueRemove2(Position: TCollectionPosition): IStringAssociation; override;
+    public
+        constructor Create; override;
+        constructor Create(NaturalItemsOnly: Boolean); override;
+        constructor Create(NaturalItemsOnly: Boolean; TableSize: Integer; MaxLoadFactor: Double = DefaultMaxLoadFactor); overload; virtual;
+        destructor Destroy; override;
+        function GetCapacity: Integer; override;
+        procedure SetCapacity(Value: Integer); override;
+        function GetSize: Integer; override;
+        property MaxLoadFactor: Double read FMaxLoadFactor write SetMaxLoadFactor;
+        property TableSize: Integer read FTableSize write SetTableSize;
+    end;
+
+implementation
+
+const
+    (* (sqrt(5) - 1)/2
+        See Introduction to Algorithms in Pascal, 1995, by Thomas W. Parsons,
+        published by John Wiley & Sons, Inc, ISBN 0-471-11600-9
+    *)
+    HashFactor = 0.618033988749894848204586834365638;
+
+type
+    THashIterator = class(TAbstractIterator)
+    private
+        FHashSet: THashSet;
+        FHash: Integer;
+        FChainIndex: Integer;
+    protected
+        constructor Create(HashSet: THashSet);
+        function TrueFirst: ICollectable; override;
+        function TrueNext: ICollectable; override;
+        procedure TrueRemove; override;
+    end;
+
+    THashAssociationIterator = class(TAbstractAssociationIterator)
+    private
+        FHashMap: THashMap;
+        FHash: Integer;
+        FChainIndex: Integer;
+    protected
+        constructor Create(HashMap: THashMap);
+        function TrueFirst: IAssociation; override;
+        function TrueNext: IAssociation; override;
+        procedure TrueRemove; override;
+    end;
+
+    THashIntegerIterator = class(TAbstractIntegerAssociationIterator)
+    private
+        FHashIntegerMap: THashIntegerMap;
+        FHash: Integer;
+        FChainIndex: Integer;
+    protected
+        constructor Create(HashIntegerMap: THashIntegerMap);
+        function TrueFirst: IIntegerAssociation; override;
+        function TrueNext: IIntegerAssociation; override;
+        procedure TrueRemove; override;
+    end;
+
+    THashStringIterator = class(TAbstractStringAssociationIterator)
+    private
+        FHashStringMap: THashStringMap;
+        FHash: Integer;
+        FChainIndex: Integer;
+    protected
+        constructor Create(HashStringMap: THashStringMap);
+        function TrueFirst: IStringAssociation; override;
+        function TrueNext: IStringAssociation; override;
+        procedure TrueRemove; override;
+    end;
+
+    THashPosition = class(TCollectionPosition)
+    private
+        FChain: TList;
+        FIndex: Integer;
+    public
+        constructor Create(Found: Boolean; Chain: TList; Index: Integer);
+        property Chain: TList read FChain;
+        property Index: Integer read FIndex;
+    end;
+
+{ THashMap }
+constructor THashMap.Create(NaturalItemsOnly: Boolean; NaturalKeysOnly: Boolean);
+var
+    I: Integer;
+begin
+    // Force use of natural keys
+    inherited Create(NaturalItemsOnly, true);
+    FTableSize := DefaultTableSize;
+    FMaxLoadFactor := DefaultMaxLoadFactor;
+    SetLength(FArray, FTableSize);
+    for I := Low(FArray) to High(FArray) do
+        FArray[I] := TList.Create;
+    FCapacity := 0;
+    FSize := 0;
+    ChangeCapacity(FArray);
+end;
+
+destructor THashMap.Destroy;
+var
+    I: Integer;
+begin
+    for I := Low(FArray) to High(FArray) do
+        FArray[I].Free;
+    FArray := nil;
+    inherited Destroy;
+end;
+
+class function THashMap.GetAlwaysNaturalKeys: Boolean;
+begin
+    Result := true;
+end;
+
+function THashMap.GetNaturalKeyIID: TGUID;
+begin
+    Result := HashableIID;
+end;
+
+function THashMap.GetAssociationIterator: IMapIterator;
+begin
+    Result := THashAssociationIterator.Create(Self);
+end;
+
+procedure THashMap.SetTableSize(Value: Integer);
+begin
+    if (FTableSize <> Value) and (Value >= 1) then
+    begin
+        FTableSize := Value;
+        Rehash;
+    end;
+end;
+
+procedure THashMap.SetMaxLoadFactor(Value: Double);
+begin
+    if (FMaxLoadFactor <> Value) and (Value >= MaxLoadFactorMin) then
+    begin
+        FMaxLoadFactor := Value;
+        CheckLoadFactor(false);
+    end;
+end;
+
+procedure THashMap.ChangeCapacity(Value: TListArray);
+var
+    Chain: TList;
+    I, Total, ChainCapacity: Integer;
+begin
+    if FCapacity mod FTableSize = 0 then
+        ChainCapacity := Trunc(FCapacity / FTableSize)
+    else
+        ChainCapacity := Trunc(FCapacity / FTableSize) + 1;
+    Total := 0;
+    for I := Low(Value) to High(Value) do
+    begin
+        Chain := Value[I];
+        Chain.Capacity := ChainCapacity;
+        Total := Total + Chain.Capacity;
+    end;
+    FCapacity := Total;
+end;
+
+procedure THashMap.CheckLoadFactor(AlwaysChangeCapacity: Boolean);
+var
+    LoadFactor: Double;
+begin
+    LoadFactor := Capacity / TableSize;
+    if LoadFactor > MaxLoadFactor then
+        TableSize := Trunc(Capacity / Max(MaxLoadFactor, MaxLoadFactorMin))
+    else if AlwaysChangeCapacity then
+        ChangeCapacity(FArray);
+end;
+
+function THashMap.GetHash(const Key: ICollectable): Integer;
+var
+    Hashable: IHashable;
+    HashCode: Cardinal;
+begin
+    Key.QueryInterface(IHashable, Hashable);
+    HashCode := Hashable.HashCode;
+    Result := Trunc(Frac(HashCode * HashFactor) * TableSize);
+end;
+
+function THashMap.GetKeyPosition(const Key: ICollectable): TCollectionPosition;
+var
+    Chain: TList;
+    I: Integer;
+    Success: Boolean;
+begin
+    Chain := FArray[GetHash(Key)];
+    Success := false;
+    for I := 0 to Chain.Count - 1 do
+    begin
+        Success := KeyComparator.Equals(Key, IAssociation(Chain[I]).GetKey);
+        if Success then
+            Break;
+    end;
+    Result := THashPosition.Create(Success, Chain, I);
+end;
+
+procedure THashMap.Rehash;
+var
+    NewArray: TListArray;
+    OldChain, NewChain: TList;
+    Association: IAssociation;
+    Total: Integer;
+    I, J: Integer;
+    Hash: Integer;
+begin
+    // Create new chains
+    SetLength(NewArray, TableSize);
+    for I := Low(NewArray) to High(NewArray) do
+    begin
+        NewChain := TList.Create;
+        NewArray[I] := NewChain;
+    end;
+    ChangeCapacity(NewArray);
+
+    // Transfer from old chains to new and drop old
+    for I := Low(FArray) to High(FArray) do
+    begin
+        OldChain := FArray[I];
+        for J := 0 to OldChain.Count - 1 do
+        begin
+            Association := IAssociation(OldChain[J]);
+            Hash := GetHash(Association.GetKey);
+            NewArray[Hash].Add(Pointer(Association));
+        end;
+        OldChain.Free;
+    end;
+    FArray := NewArray;
+
+    // Find actual, new capacity
+    Total := 0;
+    for I := Low(FArray) to High(FArray) do
+    begin
+        NewChain := FArray[I];
+        Total := Total + NewChain.Capacity;
+    end;
+    FCapacity := Total;
+end;
+
+procedure THashMap.TrueClear;
+var
+    Association: IAssociation;
+    Chain: TList;
+    I, J: Integer;
+begin
+    for I := Low(FArray) to High(FArray) do
+    begin
+        Chain := FArray[I];
+        for J := 0 to Chain.Count - 1 do
+        begin
+            Association := IAssociation(Chain[J]);
+            Chain[J] := nil;
+            // Storing interface reference as a pointer does not update reference
+            // count automatically, so this must be done manually
+            Association._Release;
+        end;
+        Chain.Clear;
+    end;
+    FSize := 0;
+end;
+
+function THashMap.TrueGet(Position: TCollectionPosition): IAssociation;
+var
+    HashPosition: THashPosition;
+begin
+    HashPosition := THashPosition(Position);
+    Result := IAssociation(HashPosition.Chain.Items[HashPosition.Index]);
+end;
+
+function THashMap.TruePut(Position: TCollectionPosition; const Association: IAssociation): IAssociation;
+var
+    HashPosition: THashPosition;
+    OldAssociation: IAssociation;
+begin
+    HashPosition := THashPosition(Position);
+    if HashPosition.Found then
+    begin
+        OldAssociation := IAssociation(HashPosition.Chain.Items[HashPosition.Index]);
+        HashPosition.Chain.Items[HashPosition.Index] := Pointer(Association);
+        Result := OldAssociation;
+        // Storing interface reference as a pointer does not update reference
+        // count automatically, so this must be done manually
+        Association._AddRef;
+        OldAssociation._Release;
+    end
+    else
+    begin
+        HashPosition.Chain.Add(Pointer(Association));
+        Inc(FSize);
+        Result := nil;
+        // Storing interface reference as a pointer does not update reference
+        // count automatically, so this must be done manually
+        Association._AddRef;
+    end;
+end;
+
+function THashMap.TrueRemove2(Position: TCollectionPosition): IAssociation;
+var
+    Association: IAssociation;
+    HashPosition: THashPosition;
+begin
+    HashPosition := THashPosition(Position);
+    Association := IAssociation(TrueGet(Position));
+    HashPosition.Chain.Delete(HashPosition.Index);
+    Dec(FSize);
+    Result := Association;
+    // Storing interface reference as a pointer does not update reference
+    // count automatically, so this must be done manually
+    Association._Release;
+end;
+
+function THashMap.GetCapacity;
+begin
+    Result := FCapacity;
+end;
+
+procedure THashMap.SetCapacity(Value: Integer);
+begin
+    FCapacity := Value;
+    CheckLoadFactor(true);
+end;
+
+function THashMap.GetSize: Integer;
+begin
+    Result := FSize;
+end;
+
+{ THashSet }
+constructor THashSet.Create(NaturalItemsOnly: Boolean);
+var
+    I: Integer;
+begin
+    // Force use of natural items
+    inherited Create(true);
+    FTableSize := DefaultTableSize;
+    FMaxLoadFactor := DefaultMaxLoadFactor;
+    SetLength(FArray, FTableSize);
+    for I := Low(FArray) to High(FArray) do
+        FArray[I] := TList.Create;
+    FSize := 0;
+end;
+
+destructor THashSet.Destroy;
+var
+    I: Integer;
+begin
+    for I := Low(FArray) to High(FArray) do
+        FArray[I].Free;
+    FArray := nil;
+    inherited Destroy;
+end;
+
+procedure THashSet.SetTableSize(Value: Integer);
+begin
+    if (FTableSize <> Value) and (Value >= 1) then
+    begin
+        FTableSize := Value;
+        Rehash;
+    end;
+end;
+
+procedure THashSet.SetMaxLoadFactor(Value: Double);
+begin
+    if (FMaxLoadFactor <> Value) and (Value >= MaxLoadFactorMin) then
+    begin
+        FMaxLoadFactor := Value;
+        CheckLoadFactor(false);
+    end;
+end;
+
+procedure THashSet.ChangeCapacity(Value: TListArray);
+var
+    Chain: TList;
+    I, Total, ChainCapacity: Integer;
+begin
+    if FCapacity mod FTableSize = 0 then
+        ChainCapacity := Trunc(FCapacity / FTableSize)
+    else
+        ChainCapacity := Trunc(FCapacity / FTableSize) + 1;
+    Total := 0;
+    for I := Low(Value) to High(Value) do
+    begin
+        Chain := Value[I];
+        Chain.Capacity := ChainCapacity;
+        Total := Total + Chain.Capacity;
+    end;
+    FCapacity := Total;
+end;
+
+procedure THashSet.CheckLoadFactor(AlwaysChangeCapacity: Boolean);
+var
+    LoadFactor: Double;
+begin
+    LoadFactor := Capacity / TableSize;
+    if LoadFactor > MaxLoadFactor then
+        TableSize := Trunc(Capacity / Max(MaxLoadFactor, MaxLoadFactorMin))
+    else if AlwaysChangeCapacity then
+        ChangeCapacity(FArray);
+end;
+
+function THashSet.GetHash(const Item: ICollectable): Integer;
+var
+    Hashable: IHashable;
+    HashCode: Cardinal;
+begin
+    Item.QueryInterface(IHashable, Hashable);
+    HashCode := Hashable.HashCode;
+    Result := Trunc(Frac(HashCode * HashFactor) * TableSize);
+end;
+
+function THashSet.GetPosition(const Item: ICollectable): TCollectionPosition;
+var
+    Chain: TList;
+    I: Integer;
+    Success: Boolean;
+begin
+    Chain := FArray[GetHash(Item)];
+    Success := false;
+    for I := 0 to Chain.Count - 1 do
+    begin
+        Success := Comparator.Equals(Item, ICollectable(Chain[I]));
+        if Success then
+            Break;
+    end;
+    Result := THashPosition.Create(Success, Chain, I);
+end;
+
+procedure THashSet.Rehash;
+var
+    NewArray: TListArray;
+    OldChain, NewChain: TList;
+    Item: ICollectable;
+    Total: Integer;
+    I, J: Integer;
+    Hash: Integer;
+begin
+    // Create new chains
+    SetLength(NewArray, TableSize);
+    for I := Low(NewArray) to High(NewArray) do
+    begin
+        NewChain := TList.Create;
+        NewArray[I] := NewChain;
+    end;
+    ChangeCapacity(NewArray);
+
+    // Transfer from old chains to new and drop old
+    for I := Low(FArray) to High(FArray) do
+    begin
+        OldChain := FArray[I];
+        for J := 0 to OldChain.Count - 1 do
+        begin
+            Item := ICollectable(OldChain[J]);
+            Hash := GetHash(Item);
+            NewArray[Hash].Add(Pointer(Item));
+        end;
+        OldChain.Free;
+    end;
+    FArray := NewArray;
+
+    // Find actual, new capacity
+    Total := 0;
+    for I := Low(FArray) to High(FArray) do
+    begin
+        NewChain := FArray[I];
+        Total := Total + NewChain.Capacity;
+    end;
+    FCapacity := Total;
+end;
+
+procedure THashSet.TrueAdd2(Position: TCollectionPosition; const Item: ICollectable);
+var
+    HashPosition: THashPosition;
+begin
+    HashPosition := THashPosition(Position);
+    HashPosition.Chain.Add(Pointer(Item));
+    Inc(FSize);
+    // Storing interface reference as a pointer does not update reference
+    // count automatically, so this must be done manually
+    Item._AddRef;
+end;
+
+procedure THashSet.TrueClear;
+var
+    Item: ICollectable;
+    Chain: TList;
+    I, J: Integer;
+begin
+    for I := Low(FArray) to High(FArray) do
+    begin
+        Chain := FArray[I];
+        for J := 0 to Chain.Count - 1 do
+        begin
+            Item := ICollectable(Chain[J]);
+            Chain[J] := nil;
+            // Storing interface reference as a pointer does not update reference
+            // count automatically, so this must be done manually
+            Item._Release;
+        end;
+        Chain.Clear;
+    end;
+    FSize := 0;
+end;
+
+function THashSet.TrueGet(Position: TCollectionPosition): ICollectable;
+var
+    HashPosition: THashPosition;
+begin
+    HashPosition := THashPosition(Position);
+    Result := ICollectable(HashPosition.Chain.Items[HashPosition.Index]);
+end;
+
+procedure THashSet.TrueRemove2(Position: TCollectionPosition);
+var
+    Item: ICollectable;
+    HashPosition: THashPosition;
+begin
+    HashPosition := THashPosition(Position);
+    Item := TrueGet(Position);
+    HashPosition.Chain.Delete(HashPosition.Index);
+    Dec(FSize);
+    // Storing interface reference as a pointer does not update reference
+    // count automatically, so this must be done manually
+    Item._Release;
+end;
+
+class function THashSet.GetAlwaysNaturalItems: Boolean;
+begin
+    Result := true;
+end;
+
+function THashSet.GetIterator: IIterator;
+begin
+    Result := THashIterator.Create(Self);
+end;
+
+function THashSet.GetNaturalItemIID: TGUID;
+begin
+    Result := HashableIID;
+end;
+
+function THashSet.GetCapacity;
+begin
+    Result := FCapacity;
+end;
+
+procedure THashSet.SetCapacity(Value: Integer);
+begin
+    FCapacity := Value;
+    CheckLoadFactor(true);
+end;
+
+function THashSet.GetSize: Integer;
+begin
+    Result := FSize;
+end;
+
+{ THashIntegerMap }
+constructor THashIntegerMap.Create;
+begin
+    Create(false, DefaultTableSize, DefaultMaxLoadFactor);
+end;
+
+constructor THashIntegerMap.Create(NaturalItemsOnly: Boolean);
+begin
+    Create(NaturalItemsOnly, DefaultTableSize, DefaultMaxLoadFactor);
+end;
+
+constructor THashIntegerMap.Create(NaturalItemsOnly: Boolean; TableSize: Integer; MaxLoadFactor: Double = DefaultMaxLoadFactor);
+var
+    I: Integer;
+begin
+    inherited Create(NaturalItemsOnly);
+    SetLength(FArray, TableSize);
+    for I := Low(FArray) to High(FArray) do
+        FArray[I] := TList.Create;
+    FTableSize := TableSize;
+    FMaxLoadFactor := MaxLoadFactor;
+    FSize := 0;
+end;
+
+destructor THashIntegerMap.Destroy;
+var
+    I: Integer;
+begin
+    for I := Low(FArray) to High(FArray) do
+        FArray[I].Free;
+    FArray := nil;
+    inherited Destroy;
+end;
+
+function THashIntegerMap.GetAssociationIterator: IIntegerMapIterator;
+begin
+    Result := THashIntegerIterator.Create(Self);
+end;
+
+procedure THashIntegerMap.SetTableSize(Value: Integer);
+begin
+    if (FTableSize <> Value) and (Value >= 1) then
+    begin
+        FTableSize := Value;
+        Rehash;
+    end;
+end;
+
+procedure THashIntegerMap.SetMaxLoadFactor(Value: Double);
+begin
+    if (FMaxLoadFactor <> Value) and (Value >= MaxLoadFactorMin) then
+    begin
+        FMaxLoadFactor := Value;
+        CheckLoadFactor(false);
+    end;
+end;
+
+procedure THashIntegerMap.ChangeCapacity;
+var
+    Chain: TList;
+    I, Total, ChainCapacity: Integer;
+begin
+    if FCapacity mod FTableSize = 0 then
+        ChainCapacity := Trunc(FCapacity / FTableSize)
+    else
+        ChainCapacity := Trunc(FCapacity / FTableSize) + 1;
+    Total := 0;
+    for I := Low(Value) to High(Value) do
+    begin
+        Chain := Value[I];
+        Chain.Capacity := ChainCapacity;
+        Total := Total + Chain.Capacity;
+    end;
+    FCapacity := Total;
+end;
+
+procedure THashIntegerMap.CheckLoadFactor(AlwaysChangeCapacity: Boolean);
+var
+    LoadFactor: Double;
+begin
+    LoadFactor := Capacity / TableSize;
+    if LoadFactor > MaxLoadFactor then
+        TableSize := Trunc(Capacity / Max(MaxLoadFactor, MaxLoadFactorMin))
+    else if AlwaysChangeCapacity then
+        ChangeCapacity(FArray);
+end;
+
+function THashIntegerMap.GetHash(const Key: Integer): Integer;
+begin
+    Result := Trunc(Frac(Cardinal(Key) * HashFactor) * TableSize);
+end;
+
+function THashIntegerMap.GetKeyPosition(const Key: Integer): TCollectionPosition;
+var
+    Chain: TList;
+    I: Integer;
+    Success: Boolean;
+begin
+    Chain := FArray[GetHash(Key)];
+    Success := false;
+    for I := 0 to Chain.Count - 1 do
+    begin
+        Success := (Key = IIntegerAssociation(Chain[I]).GetKey);
+        if Success then
+            Break;
+    end;
+    Result := THashPosition.Create(Success, Chain, I);
+end;
+
+procedure THashIntegerMap.Rehash;
+var
+    NewArray: TListArray;
+    OldChain, NewChain: TList;
+    Association: IIntegerAssociation;
+    Total: Integer;
+    I, J: Integer;
+    Hash: Integer;
+begin
+    // Create new chains
+    SetLength(NewArray, TableSize);
+    for I := Low(NewArray) to High(NewArray) do
+    begin
+        NewChain := TList.Create;
+        NewArray[I] := NewChain;
+    end;
+    ChangeCapacity(NewArray);
+
+    // Transfer from old chains to new and drop old
+    for I := Low(FArray) to High(FArray) do
+    begin
+        OldChain := FArray[I];
+        for J := 0 to OldChain.Count - 1 do
+        begin
+            Association := IIntegerAssociation(OldChain[J]);
+            Hash := GetHash(Association.GetKey);
+            NewArray[Hash].Add(Pointer(Association));
+        end;
+        OldChain.Free;
+    end;
+    FArray := NewArray;
+
+    // Find actual, new capacity
+    Total := 0;
+    for I := Low(FArray) to High(FArray) do
+    begin
+        NewChain := FArray[I];
+        Total := Total + NewChain.Capacity;
+    end;
+    FCapacity := Total;
+end;
+
+procedure THashIntegerMap.TrueClear;
+var
+    Association: IIntegerAssociation;
+    Chain: TList;
+    I, J: Integer;
+begin
+    for I := Low(FArray) to High(FArray) do
+    begin
+        Chain := FArray[I];
+        for J := 0 to Chain.Count - 1 do
+        begin
+            Association := IIntegerAssociation(Chain[J]);
+            Chain[J] := nil;
+            // Storing interface reference as a pointer does not update reference
+            // count automatically, so this must be done manually
+            Association._Release;
+        end;
+        Chain.Clear;
+    end;
+    FSize := 0;
+end;
+
+function THashIntegerMap.TrueGet(Position: TCollectionPosition): IIntegerAssociation;
+var
+    HashPosition: THashPosition;
+begin
+    HashPosition := THashPosition(Position);
+    Result := IIntegerAssociation(HashPosition.Chain.Items[HashPosition.Index]);
+end;
+
+function THashIntegerMap.TruePut(Position: TCollectionPosition; const Association: IIntegerAssociation): IIntegerAssociation;
+var
+    HashPosition: THashPosition;
+    OldAssociation: IIntegerAssociation;
+begin
+    HashPosition := THashPosition(Position);
+    if HashPosition.Found then
+    begin
+        OldAssociation := IIntegerAssociation(HashPosition.Chain.Items[HashPosition.Index]);
+        HashPosition.Chain.Items[HashPosition.Index] := Pointer(Association);
+        Result := OldAssociation;
+        // Storing interface reference as a pointer does not update reference
+        // count automatically, so this must be done manually
+        Association._AddRef;
+        OldAssociation._Release;
+    end
+    else
+    begin
+        HashPosition.Chain.Add(Pointer(Association));
+        Inc(FSize);
+        Result := nil;
+        // Storing interface reference as a pointer does not update reference
+        // count automatically, so this must be done manually
+        Association._AddRef;
+    end;
+end;
+
+function THashIntegerMap.TrueRemove2(Position: TCollectionPosition): IIntegerAssociation;
+var
+    Association: IIntegerAssociation;
+    HashPosition: THashPosition;
+begin
+    HashPosition := THashPosition(Position);
+    Association := IIntegerAssociation(TrueGet(Position));
+    HashPosition.Chain.Delete(HashPosition.Index);
+    Dec(FSize);
+    Result := Association;
+    // Storing interface reference as a pointer does not update reference
+    // count automatically, so this must be done manually
+    Association._Release;
+end;
+
+function THashIntegerMap.GetCapacity;
+begin
+    Result := FCapacity;
+end;
+
+procedure THashIntegerMap.SetCapacity(Value: Integer);
+begin
+    FCapacity := Value;
+    CheckLoadFactor(true);
+end;
+
+function THashIntegerMap.GetSize: Integer;
+begin
+    Result := FSize;
+end;
+
+{ THashStringMap }
+constructor THashStringMap.Create;
+begin
+    Create(false, DefaultTableSize, DefaultMaxLoadFactor);
+end;
+
+constructor THashStringMap.Create(NaturalItemsOnly: Boolean);
+begin
+    Create(NaturalItemsOnly, DefaultTableSize, DefaultMaxLoadFactor);
+end;
+
+constructor THashStringMap.Create(NaturalItemsOnly: Boolean; TableSize: Integer; MaxLoadFactor: Double = DefaultMaxLoadFactor);
+var
+    I: Integer;
+begin
+    inherited Create(NaturalItemsOnly);
+    SetLength(FArray, TableSize);
+    for I := Low(FArray) to High(FArray) do
+        FArray[I] := TList.Create;
+    FTableSize := TableSize;
+    FMaxLoadFactor := MaxLoadFactor;
+    FSize := 0;
+end;
+
+destructor THashStringMap.Destroy;
+var
+    I: Integer;
+begin
+    for I := Low(FArray) to High(FArray) do
+        FArray[I].Free;
+    FArray := nil;
+    inherited Destroy;
+end;
+
+function THashStringMap.GetAssociationIterator: IStringMapIterator;
+begin
+    Result := THashStringIterator.Create(Self);
+end;
+
+procedure THashStringMap.SetTableSize(Value: Integer);
+begin
+    if (FTableSize <> Value) and (Value >= 1) then
+    begin
+        FTableSize := Value;
+        Rehash;
+    end;
+end;
+
+procedure THashStringMap.SetMaxLoadFactor(Value: Double);
+begin
+    if (FMaxLoadFactor <> Value) and (Value >= MaxLoadFactorMin) then
+    begin
+        FMaxLoadFactor := Value;
+        CheckLoadFactor(false);
+    end;
+end;
+
+procedure THashStringMap.ChangeCapacity;
+var
+    Chain: TList;
+    I, Total, ChainCapacity: Integer;
+begin
+    if FCapacity mod FTableSize = 0 then
+        ChainCapacity := Trunc(FCapacity / FTableSize)
+    else
+        ChainCapacity := Trunc(FCapacity / FTableSize) + 1;
+    Total := 0;
+    for I := Low(Value) to High(Value) do
+    begin
+        Chain := Value[I];
+        Chain.Capacity := ChainCapacity;
+        Total := Total + Chain.Capacity;
+    end;
+    FCapacity := Total;
+end;
+
+procedure THashStringMap.CheckLoadFactor(AlwaysChangeCapacity: Boolean);
+var
+    LoadFactor: Double;
+begin
+    LoadFactor := Capacity / TableSize;
+    if LoadFactor > MaxLoadFactor then
+        TableSize := Trunc(Capacity / Max(MaxLoadFactor, MaxLoadFactorMin))
+    else if AlwaysChangeCapacity then
+        ChangeCapacity(FArray);
+end;
+
+function THashStringMap.GetHash(const Key: String): Integer;
+var
+    HashCode: Cardinal;
+    I: Integer;
+begin
+    HashCode := 0;
+    for I := 1 to Length(Key) do
+        HashCode := (HashCode shl 1) xor Ord(Key[I]);
+    Result := Trunc(Frac(HashCode * HashFactor) * TableSize);
+end;
+
+function THashStringMap.GetKeyPosition(const Key: String): TCollectionPosition;
+var
+    Chain: TList;
+    I: Integer;
+    Success: Boolean;
+begin
+    Chain := FArray[GetHash(Key)];
+    Success := false;
+    for I := 0 to Chain.Count - 1 do
+    begin
+        Success := (Key = IStringAssociation(Chain[I]).GetKey);
+        if Success then
+            Break;
+    end;
+    Result := THashPosition.Create(Success, Chain, I);
+end;
+
+procedure THashStringMap.Rehash;
+var
+    NewArray: TListArray;
+    OldChain, NewChain: TList;
+    Association: IStringAssociation;
+    Total: Integer;
+    I, J: Integer;
+    Hash: Integer;
+begin
+    // Create new chains
+    SetLength(NewArray, TableSize);
+    for I := Low(NewArray) to High(NewArray) do
+    begin
+        NewChain := TList.Create;
+        NewArray[I] := NewChain;
+    end;
+    ChangeCapacity(NewArray);
+
+    // Transfer from old chains to new and drop old
+    for I := Low(FArray) to High(FArray) do
+    begin
+        OldChain := FArray[I];
+        for J := 0 to OldChain.Count - 1 do
+        begin
+            Association := IStringAssociation(OldChain[J]);
+            Hash := GetHash(Association.GetKey);
+            NewArray[Hash].Add(Pointer(Association));
+        end;
+        OldChain.Free;
+    end;
+    FArray := NewArray;
+
+    // Find actual, new capacity
+    Total := 0;
+    for I := Low(FArray) to High(FArray) do
+    begin
+        NewChain := FArray[I];
+        Total := Total + NewChain.Capacity;
+    end;
+    FCapacity := Total;
+end;
+
+procedure THashStringMap.TrueClear;
+var
+    Association: IStringAssociation;
+    Chain: TList;
+    I, J: Integer;
+begin
+    for I := Low(FArray) to High(FArray) do
+    begin
+        Chain := FArray[I];
+        for J := 0 to Chain.Count - 1 do
+        begin
+            Association := IStringAssociation(Chain[J]);
+            Chain[J] := nil;
+            // Storing interface reference as a pointer does not update reference
+            // count automatically, so this must be done manually
+            Association._Release;
+        end;
+        Chain.Clear;
+    end;
+    FSize := 0;
+end;
+
+function THashStringMap.TrueGet(Position: TCollectionPosition): IStringAssociation;
+var
+    HashPosition: THashPosition;
+begin
+    HashPosition := THashPosition(Position);
+    Result := IStringAssociation(HashPosition.Chain.Items[HashPosition.Index]);
+end;
+
+function THashStringMap.TruePut(Position: TCollectionPosition; const Association: IStringAssociation): IStringAssociation;
+var
+    HashPosition: THashPosition;
+    OldAssociation: IStringAssociation;
+begin
+    HashPosition := THashPosition(Position);
+    if HashPosition.Found then
+    begin
+        OldAssociation := IStringAssociation(HashPosition.Chain.Items[HashPosition.Index]);
+        HashPosition.Chain.Items[HashPosition.Index] := Pointer(Association);
+        Result := OldAssociation;
+        // Storing interface reference as a pointer does not update reference
+        // count automatically, so this must be done manually
+        Association._AddRef;
+        OldAssociation._Release;
+    end
+    else
+    begin
+        HashPosition.Chain.Add(Pointer(Association));
+        Inc(FSize);
+        Result := nil;
+        // Storing interface reference as a pointer does not update reference
+        // count automatically, so this must be done manually
+        Association._AddRef;
+    end;
+end;
+
+function THashStringMap.TrueRemove2(Position: TCollectionPosition): IStringAssociation;
+var
+    Association: IStringAssociation;
+    HashPosition: THashPosition;
+begin
+    HashPosition := THashPosition(Position);
+    Association := IStringAssociation(TrueGet(Position));
+    HashPosition.Chain.Delete(HashPosition.Index);
+    Dec(FSize);
+    Result := Association;
+    // Storing interface reference as a pointer does not update reference
+    // count automatically, so this must be done manually
+    Association._Release;
+end;
+
+function THashStringMap.GetCapacity;
+begin
+    Result := FCapacity;
+end;
+
+procedure THashStringMap.SetCapacity(Value: Integer);
+begin
+    FCapacity := Value;
+    CheckLoadFactor(true);
+end;
+
+function THashStringMap.GetSize: Integer;
+begin
+    Result := FSize;
+end;
+
+{ THashPosition }
+constructor THashPosition.Create(Found: Boolean; Chain: TList; Index: Integer);
+begin
+    inherited Create(Found);
+    FChain := Chain;
+    FIndex := Index;
+end;
+
+{ THashIterator }
+constructor THashIterator.Create(HashSet: THashSet);
+begin
+    inherited Create(true);
+    FHashSet := HashSet;
+    First;
+end;
+
+function THashIterator.TrueFirst: ICollectable;
+var
+    Chain: TList;
+    Success: Boolean;
+begin
+    FHash := 0;
+    FChainIndex := 0;
+    Success := false;
+    while FHash < FHashSet.TableSize do
+    begin
+        Chain := FHashSet.FArray[FHash];
+        Success := Chain.Count > 0;
+        if Success then
+            Break;
+        Inc(FHash);
+    end;
+    if Success then
+        Result := ICollectable(FHashSet.FArray[FHash].Items[FChainIndex])
+    else
+        Result := nil;
+end;
+
+function THashIterator.TrueNext: ICollectable;
+var
+    Chain: TList;
+    Success: Boolean;
+begin
+    Success := false;
+    Chain := FHashSet.FArray[FHash];
+    repeat
+        Inc(FChainIndex);
+        if FChainIndex >= Chain.Count then
+        begin
+            Inc(FHash);
+            FChainIndex := -1;
+            if FHash < FHashSet.TableSize then
+                Chain := FHashSet.FArray[FHash];
+        end
+        else
+            Success := true;
+    until Success or (FHash >= FHashSet.TableSize);
+    if Success then
+        Result := ICollectable(FHashSet.FArray[FHash].Items[FChainIndex])
+    else
+        Result := nil;
+end;
+
+procedure THashIterator.TrueRemove;
+var
+    Item: ICollectable;
+begin
+    Item := ICollectable(FHashSet.FArray[FHash].Items[FChainIndex]);
+    FHashSet.FArray[FHash].Delete(FChainIndex);
+    Dec(FChainIndex);
+    Dec(FHashSet.FSize);
+    // Storing interface reference as a pointer does not update reference
+    // count automatically, so this must be done manually
+    Item._Release;
+end;
+
+
+{ THashAssociationIterator }
+constructor THashAssociationIterator.Create(HashMap: THashMap);
+begin
+    inherited Create(true);
+    FHashMap := HashMap;
+    First;
+end;
+
+function THashAssociationIterator.TrueFirst: IAssociation;
+var
+    Chain: TList;
+    Success: Boolean;
+begin
+    FHash := 0;
+    FChainIndex := 0;
+    Success := false;
+    while FHash < FHashMap.TableSize do
+    begin
+        Chain := FHashMap.FArray[FHash];
+        Success := Chain.Count > 0;
+        if Success then
+            Break;
+        Inc(FHash);
+    end;
+    if Success then
+        Result := IAssociation(FHashMap.FArray[FHash].Items[FChainIndex])
+    else
+        Result := nil;
+end;
+
+function THashAssociationIterator.TrueNext: IAssociation;
+var
+    Chain: TList;
+    Success: Boolean;
+begin
+    Success := false;
+    Chain := FHashMap.FArray[FHash];
+    repeat
+        Inc(FChainIndex);
+        if FChainIndex >= Chain.Count then
+        begin
+            Inc(FHash);
+            FChainIndex := -1;
+            if FHash < FHashMap.TableSize then
+                Chain := FHashMap.FArray[FHash];
+        end
+        else
+            Success := true;
+    until Success or (FHash >= FHashMap.TableSize);
+    if Success then
+        Result := IAssociation(FHashMap.FArray[FHash].Items[FChainIndex])
+    else
+        Result := nil;
+end;
+
+procedure THashAssociationIterator.TrueRemove;
+var
+    Association: IAssociation;
+begin
+    Association := IAssociation(FHashMap.FArray[FHash].Items[FChainIndex]);
+    FHashMap.FArray[FHash].Delete(FChainIndex);
+    Dec(FChainIndex);
+    Dec(FHashMap.FSize);
+    // Storing interface reference as a pointer does not update reference
+    // count automatically, so this must be done manually
+    Association._Release;
+end;
+
+
+{ THashIntegerIterator }
+constructor THashIntegerIterator.Create(HashIntegerMap: THashIntegerMap);
+begin
+    inherited Create(true);
+    FHashIntegerMap := HashIntegerMap;
+    First;
+end;
+
+function THashIntegerIterator.TrueFirst: IIntegerAssociation;
+var
+    Chain: TList;
+    Success: Boolean;
+begin
+    FHash := 0;
+    FChainIndex := 0;
+    Success := false;
+    while FHash < FHashIntegerMap.TableSize do
+    begin
+        Chain := FHashIntegerMap.FArray[FHash];
+        Success := Chain.Count > 0;
+        if Success then
+            Break;
+        Inc(FHash);
+    end;
+    if Success then
+        Result := IIntegerAssociation(FHashIntegerMap.FArray[FHash].Items[FChainIndex])
+    else
+        Result := nil;
+end;
+
+function THashIntegerIterator.TrueNext: IIntegerAssociation;
+var
+    Chain: TList;
+    Success: Boolean;
+begin
+    Success := false;
+    Chain := FHashIntegerMap.FArray[FHash];
+    repeat
+        Inc(FChainIndex);
+        if FChainIndex >= Chain.Count then
+        begin
+            Inc(FHash);
+            FChainIndex := -1;
+            if FHash < FHashIntegerMap.TableSize then
+                Chain := FHashIntegerMap.FArray[FHash];
+        end
+        else
+            Success := true;
+    until Success or (FHash >= FHashIntegerMap.TableSize);
+    if Success then
+        Result := IIntegerAssociation(FHashIntegerMap.FArray[FHash].Items[FChainIndex])
+    else
+        Result := nil;
+end;
+
+procedure THashIntegerIterator.TrueRemove;
+var
+    Association: IIntegerAssociation;
+begin
+    Association := IIntegerAssociation(FHashIntegerMap.FArray[FHash].Items[FChainIndex]);
+    FHashIntegerMap.FArray[FHash].Delete(FChainIndex);
+    Dec(FChainIndex);
+    Dec(FHashIntegerMap.FSize);
+    // Storing interface reference as a pointer does not update reference
+    // count automatically, so this must be done manually
+    Association._Release;
+end;
+
+{ THashStringIterator }
+constructor THashStringIterator.Create(HashStringMap: THashStringMap);
+begin
+    inherited Create(true);
+    FHashStringMap := HashStringMap;
+    First;
+end;
+
+function THashStringIterator.TrueFirst: IStringAssociation;
+var
+    Chain: TList;
+    Success: Boolean;
+begin
+    FHash := 0;
+    FChainIndex := 0;
+    Success := false;
+    while FHash < FHashStringMap.TableSize do
+    begin
+        Chain := FHashStringMap.FArray[FHash];
+        Success := Chain.Count > 0;
+        if Success then
+            Break;
+        Inc(FHash);
+    end;
+    if Success then
+        Result := IStringAssociation(FHashStringMap.FArray[FHash].Items[FChainIndex])
+    else
+        Result := nil;
+end;
+
+function THashStringIterator.TrueNext: IStringAssociation;
+var
+    Chain: TList;
+    Success: Boolean;
+begin
+    Success := false;
+    Chain := FHashStringMap.FArray[FHash];
+    repeat
+        Inc(FChainIndex);
+        if FChainIndex >= Chain.Count then
+        begin
+            Inc(FHash);
+            FChainIndex := -1;
+            if FHash < FHashStringMap.TableSize then
+                Chain := FHashStringMap.FArray[FHash];
+        end
+        else
+            Success := true;
+    until Success or (FHash >= FHashStringMap.TableSize);
+    if Success then
+        Result := IStringAssociation(FHashStringMap.FArray[FHash].Items[FChainIndex])
+    else
+        Result := nil;
+end;
+
+procedure THashStringIterator.TrueRemove;
+var
+    Association: IStringAssociation;
+begin
+    Association := IStringAssociation(FHashStringMap.FArray[FHash].Items[FChainIndex]);
+    FHashStringMap.FArray[FHash].Delete(FChainIndex);
+    Dec(FChainIndex);
+    Dec(FHashStringMap.FSize);
+    // Storing interface reference as a pointer does not update reference
+    // count automatically, so this must be done manually
+    Association._Release;
+end;
+
+
+end.
diff --git a/Lua/src/lib/collections/CollLibrary.pas b/Lua/src/lib/collections/CollLibrary.pas
new file mode 100644
index 00000000..b7e3d268
--- /dev/null
+++ b/Lua/src/lib/collections/CollLibrary.pas
@@ -0,0 +1,131 @@
+unit CollLibrary;
+
+(*****************************************************************************
+ * Copyright 2003 by Matthew Greet
+ * This library is free software; you can redistribute it and/or modify it
+ * under the terms of the GNU Lesser General Public License as published by the
+ * Free Software Foundation; either version 2.1 of the License, or (at your
+ * option) any later version.
+ *
+ * This library is distributed in the hope that it will be useful, but WITHOUT
+ * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS
+ * FOR A PARTICULAR PURPOSE. See the GNU Lesser General Public License for more
+ * details. (http://opensource.org/licenses/lgpl-license.php)
+ * 
+ * See http://www.warmachine.u-net.com/delphi_collections for updates and downloads.
+ *
+ * $Version: v1.0.3 $
+ * $Revision: 1.0.1.1 $
+ * $Log: D:\QVCS Repositories\Delphi Collections\CollLibrary.qbt $
+ * 
+ *   Initial version.
+ * 
+ * Revision 1.0.1.1  by: Matthew Greet  Rev date: 24/10/03 16:48:16
+ *   v1.0 branch.
+ * 
+ * Revision 1.0  by: Matthew Greet  Rev date: 06/04/03 10:40:32
+ *   Initial revision.
+ * 
+ * FPC compatibility fixes by: UltraStar Deluxe Team
+ *
+ * $Endlog$
+ *****************************************************************************)
+
+{$IFDEF FPC}
+  {$MODE Delphi}{$H+}
+{$ENDIF}
+ 
+interface
+
+uses
+    Collections, CollArray, CollHash, CollList, CollPArray, CollWrappers;
+
+type
+    TMiscCollectionLibrary = class
+    public
+        class function ClassNameToClassType(ClassName: String): TAbstractCollectionClass;
+        class function EqualIID(const IID1, IID2: TGUID): Boolean;
+        class function HashCode(Value: String): Integer;
+        class procedure ShuffleArray(var ItemArray: array of ICollectable);
+        class procedure ShuffleList(const List: IList);
+    end;
+
+implementation
+
+{ TMiscCollectionLibrary }
+class function TMiscCollectionLibrary.ClassNameToClassType(ClassName: String): TAbstractCollectionClass;
+begin
+    if ClassName = 'TArray' then
+        Result := TArray
+    else if ClassName = 'THashSet' then
+        Result := THashSet
+    else if ClassName = 'THashMap' then
+        Result := THashMap
+    else if ClassName = 'THashIntegerMap' then
+        Result := THashIntegerMap
+    else if ClassName = 'THashStringMap' then
+        Result := THashStringMap
+    else if ClassName = 'TListSet' then
+        Result := TListSet
+    else if ClassName = 'TListMap' then
+        Result := TListMap
+    else if ClassName = 'TPArrayBag' then
+        Result := TPArrayBag
+    else if ClassName = 'TPArraySet' then
+        Result := TPArraySet
+    else if ClassName = 'TPArrayList' then
+        Result := TPArrayList
+    else if ClassName = 'TPArrayMap' then
+        Result := TPArrayMap
+    else
+        Result := nil;
+end;
+
+class function TMiscCollectionLibrary.EqualIID(const IID1, IID2: TGUID): Boolean;
+begin
+    Result := (IID1.D1 = IID2.D1) and (IID1.D2 = IID2.D2) and (IID1.D3 = IID2.D3) and
+        (IID1.D4[0] = IID2.D4[0]) and (IID1.D4[1] = IID2.D4[1]) and
+        (IID1.D4[2] = IID2.D4[2]) and (IID1.D4[3] = IID2.D4[3]) and
+        (IID1.D4[4] = IID2.D4[4]) and (IID1.D4[5] = IID2.D4[5]) and
+        (IID1.D4[6] = IID2.D4[6]) and (IID1.D4[7] = IID2.D4[7]);
+end;
+
+class function TMiscCollectionLibrary.HashCode(Value: String): Integer;
+var
+    I: Integer;
+begin
+    Result := 0;
+    for I := 1 to Length(Value) do
+        Result := (Result shl 1) xor Ord(Value[I]);
+end;
+
+class procedure TMiscCollectionLibrary.ShuffleArray(var ItemArray: array of ICollectable);
+var
+    Item: ICollectable;
+    ArraySize, I, Index: Integer;
+begin
+    Randomize;
+    ArraySize := Length(ItemArray);
+    for I := 0 to ArraySize - 1 do
+    begin
+        Index := (I + Random(ArraySize - 1) + 1) mod ArraySize;
+        Item := ItemArray[I];
+        ItemArray[I] := ItemArray[Index];
+        ItemArray[Index] := Item;
+    end;
+end;
+
+class procedure TMiscCollectionLibrary.ShuffleList(const List: IList);
+var
+    ListSize, I: Integer;
+begin
+    Randomize;
+    ListSize := List.GetSize;
+    for I := 0 to ListSize - 1 do
+    begin
+        List.Exchange(I, (I + Random(ListSize - 1) + 1) mod ListSize);
+    end;
+end;
+
+
+end.
diff --git a/Lua/src/lib/collections/CollList.pas b/Lua/src/lib/collections/CollList.pas
new file mode 100644
index 00000000..68aa0d66
--- /dev/null
+++ b/Lua/src/lib/collections/CollList.pas
@@ -0,0 +1,270 @@
+unit CollList;
+
+(*****************************************************************************
+ * Copyright 2003 by Matthew Greet
+ * This library is free software; you can redistribute it and/or modify it
+ * under the terms of the GNU Lesser General Public License as published by the
+ * Free Software Foundation; either version 2.1 of the License, or (at your
+ * option) any later version.
+ *
+ * This library is distributed in the hope that it will be useful, but WITHOUT
+ * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS
+ * FOR A PARTICULAR PURPOSE. See the GNU Lesser General Public License for more
+ * details. (http://opensource.org/licenses/lgpl-license.php)
+ * 
+ * See http://www.warmachine.u-net.com/delphi_collections for updates and downloads.
+ *
+ * $Version: v1.0.3 $
+ * $Revision: 1.1.1.2 $
+ * $Log: D:\QVCS Repositories\Delphi Collections\CollList.qbt $
+ * 
+ *   Collection implementations based on sorted TPArrayList instances.
+ * 
+ * Revision 1.1.1.2  by: Matthew Greet  Rev date: 12/06/04 20:05:54
+ *   Capacity property.
+ * 
+ * Revision 1.1.1.1  by: Matthew Greet  Rev date: 14/02/04 17:45:38
+ *   v1.0 branch.
+ * 
+ * Revision 1.1  by: Matthew Greet  Rev date: 06/04/03 10:41:52
+ *   Uses TExposedPArrayList to improve performance.
+ * 
+ * Revision 1.0  by: Matthew Greet  Rev date: 01/03/03 10:50:02
+ *   Initial revision.
+ * 
+ * FPC compatibility fixes by: UltraStar Deluxe Team
+ *
+ * $Endlog$
+ *****************************************************************************)
+
+interface
+
+{$IFDEF FPC}
+  {$MODE Delphi}{$H+}
+{$ENDIF}
+
+uses
+    Collections, CollPArray;
+
+type
+    TListSet = class(TAbstractSet)
+    private
+        FList: TExposedPArrayList;
+    protected
+        function GetPosition(const Item: ICollectable): TCollectionPosition; override;
+        procedure TrueAdd2(Position: TCollectionPosition; const Item: ICollectable); override;
+        procedure TrueClear; override;
+        function TrueGet(Position: TCollectionPosition): ICollectable; override;
+        procedure TrueRemove2(Position: TCollectionPosition); override;
+    public
+        constructor Create(NaturalItemsOnly: Boolean); override;
+        destructor Destroy; override;
+        function GetCapacity: Integer; override;
+        procedure SetCapacity(Value: Integer); override;
+        function GetIterator: IIterator; override;
+        function GetNaturalItemIID: TGUID; override;
+        function GetSize: Integer; override;
+    end;
+
+    TListMap = class(TAbstractMap)
+    private
+        FList: TExposedPArrayList;
+    protected
+        function GetAssociationIterator: IMapIterator; override;
+        function GetKeyPosition(const Key: ICollectable): TCollectionPosition; override;
+        procedure TrueClear; override;
+        function TrueGet(Position: TCollectionPosition): IAssociation; override;
+        function TruePut(Position: TCollectionPosition; const Association: IAssociation): IAssociation; override;
+        function TrueRemove2(Position: TCollectionPosition): IAssociation; override;
+    public
+        constructor Create(NaturalItemsOnly: Boolean; NaturalKeysOnly: Boolean); override;
+        destructor Destroy; override;
+        function GetCapacity: Integer; override;
+        procedure SetCapacity(Value: Integer); override;
+        procedure SetKeyComparator(const Value: IComparator); override;
+        function GetNaturalKeyIID: TGUID; override;
+        function GetSize: Integer; override;
+    end;
+
+implementation
+
+type
+    TListPosition = class(TCollectionPosition)
+    private
+        FSearchResult: TSearchResult;
+    public
+        constructor Create(Found: Boolean; SearchResult: TSearchResult);
+        property SearchResult: TSearchResult read FSearchResult;
+    end;
+
+constructor TListSet.Create(NaturalItemsOnly: Boolean);
+begin
+    inherited Create(NaturalItemsOnly);
+    FList := TExposedPArrayList.Create(NaturalItemsOnly);
+    FList.Comparator := Comparator;
+    FList.Sort;
+end;
+
+destructor TListSet.Destroy;
+begin
+    FList.Free;
+    inherited Destroy;
+end;
+
+function TListSet.GetPosition(const Item: ICollectable): TCollectionPosition;
+var
+    SearchResult: TSearchResult;
+begin
+    SearchResult := FList.Search(Item);
+    Result := TListPosition.Create((SearchResult.ResultType = srFoundAtIndex), SearchResult);
+end;
+
+procedure TListSet.TrueAdd2(Position: TCollectionPosition; const Item: ICollectable);
+var
+    SearchResult: TSearchResult;
+    Index: Integer;
+begin
+    SearchResult := TListPosition(Position).SearchResult;
+    Index := SearchResult.Index;
+    if SearchResult.ResultType = srBeforeIndex then
+        FList.TrueInsert(Index, Item)
+    else
+        FList.TrueAppend(Item);
+end;
+
+procedure TListSet.TrueClear;
+begin
+    FList.Clear;
+end;
+
+function TListSet.TrueGet(Position: TCollectionPosition): ICollectable;
+begin
+    Result := FList.Items[TListPosition(Position).SearchResult.Index];
+end;
+
+procedure TListSet.TrueRemove2(Position: TCollectionPosition);
+begin
+    FList.Delete(TListPosition(Position).SearchResult.Index);
+end;
+
+function TListSet.GetCapacity: Integer;
+begin
+    Result := FList.Capacity;
+end;
+
+procedure TListSet.SetCapacity(Value: Integer);
+begin
+    FList.Capacity := Value;
+end;
+
+function TListSet.GetIterator: IIterator;
+begin
+    Result := FList.GetIterator;
+end;
+
+function TListSet.GetNaturalItemIID: TGUID;
+begin
+    Result := ComparableIID;
+end;
+
+function TListSet.GetSize: Integer;
+begin
+    Result := FList.Size;
+end;
+
+constructor TListMap.Create(NaturalItemsOnly: Boolean; NaturalKeysOnly: Boolean);
+begin
+    inherited Create(NaturalItemsOnly, NaturalKeysOnly);
+    FList := TExposedPArrayList.Create(false);
+    FList.Comparator := AssociationComparator;
+    FList.Sort;
+end;
+
+destructor TListMap.Destroy;
+begin
+    FList.Free;
+    inherited Destroy;
+end;
+
+function TListMap.GetAssociationIterator: IMapIterator;
+begin
+    Result := TAssociationIterator.Create(FList.GetIterator);
+end;
+
+function TListMap.GetKeyPosition(const Key: ICollectable): TCollectionPosition;
+var
+    Association: IAssociation;
+    SearchResult: TSearchResult;
+begin
+    Association := TAssociation.Create(Key, nil);
+    SearchResult := FList.Search(Association);
+    Result := TListPosition.Create((SearchResult.ResultType = srFoundAtIndex), SearchResult);
+end;
+
+procedure TListMap.TrueClear;
+begin
+    FList.Clear;
+end;
+
+function TListMap.TrueGet(Position: TCollectionPosition): IAssociation;
+begin
+    Result := (FList.Items[TListPosition(Position).SearchResult.Index]) as IAssociation;
+end;
+
+function TListMap.TruePut(Position: TCollectionPosition; const Association: IAssociation): IAssociation;
+var
+    SearchResult: TSearchResult;
+    Index: Integer;
+begin
+    SearchResult := TListPosition(Position).SearchResult;
+    Index := SearchResult.Index;
+    if SearchResult.ResultType = srFoundAtIndex then
+    begin
+        Result := (FList.Items[Index]) as IAssociation;
+        FList.Items[Index] := Association;
+    end
+    else if SearchResult.ResultType = srBeforeIndex then
+        FList.TrueInsert(Index, Association)
+    else
+        FList.TrueAppend(Association);
+end;
+
+function TListMap.TrueRemove2(Position: TCollectionPosition): IAssociation;
+begin
+    Result := (FList.Items[TListPosition(Position).SearchResult.Index]) as IAssociation;
+    FList.Delete(TListPosition(Position).SearchResult.Index);
+end;
+
+procedure TListMap.SetKeyComparator(const Value: IComparator);
+begin
+    inherited SetKeyComparator(Value);
+    FList.Sort;
+end;
+
+function TListMap.GetCapacity: Integer;
+begin
+    Result := FList.Capacity;
+end;
+
+procedure TListMap.SetCapacity(Value: Integer);
+begin
+    FList.Capacity := Value;
+end;
+
+function TListMap.GetNaturalKeyIID: TGUID;
+begin
+    Result := ComparableIID;
+end;
+
+function TListMap.GetSize: Integer;
+begin
+    Result := FList.Size;
+end;
+
+constructor TListPosition.Create(Found: Boolean; SearchResult: TSearchResult);
+begin
+    inherited Create(Found);
+    FSearchResult := SearchResult;
+end;
+
+end.
diff --git a/Lua/src/lib/collections/CollPArray.pas b/Lua/src/lib/collections/CollPArray.pas
new file mode 100644
index 00000000..5ebd534b
--- /dev/null
+++ b/Lua/src/lib/collections/CollPArray.pas
@@ -0,0 +1,689 @@
+unit CollPArray;
+
+(*****************************************************************************
+ * Copyright 2003 by Matthew Greet
+ * This library is free software; you can redistribute it and/or modify it
+ * under the terms of the GNU Lesser General Public License as published by the
+ * Free Software Foundation; either version 2.1 of the License, or (at your
+ * option) any later version.
+ *
+ * This library is distributed in the hope that it will be useful, but WITHOUT
+ * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS
+ * FOR A PARTICULAR PURPOSE. See the GNU Lesser General Public License for more
+ * details. (http://opensource.org/licenses/lgpl-license.php)
+ * 
+ * See http://www.warmachine.u-net.com/delphi_collections for updates and downloads.
+ *
+ * $Version: v1.0.3 $
+ * $Revision: 1.2.1.2 $
+ * $Log: D:\QVCS Repositories\Delphi Collections\CollPArray.qbt $
+ * 
+ *   Collection implementations based on TList.
+ * 
+ * Revision 1.2.1.2  by: Matthew Greet  Rev date: 12/06/04 20:08:30
+ *   Capacity property.
+ * 
+ * Revision 1.2.1.1  by: Matthew Greet  Rev date: 14/02/04 17:46:10
+ *   v1.0 branch.
+ * 
+ * Revision 1.2  by: Matthew Greet  Rev date: 28/04/03 15:07:14
+ *   Correctly handles nil items.
+ * 
+ * Revision 1.1  by: Matthew Greet  Rev date: 06/04/03 10:43:16
+ *   Added TPArrayMap and TExposedPArrayList.
+ * 
+ * Revision 1.0  by: Matthew Greet  Rev date: 01/03/03 10:50:02
+ *   Initial revision.
+ * 
+ * FPC compatibility fixes by: UltraStar Deluxe Team
+ *
+ * $Endlog$
+ *****************************************************************************)
+
+{$IFDEF FPC}
+  {$MODE Delphi}{$H+}
+{$ENDIF}
+ 
+interface
+
+uses
+    Classes,
+    Collections;
+
+type
+    TPArrayBag = class(TAbstractBag)
+    private
+        FList: TList;
+    protected
+        function TrueAdd(const Item: ICollectable): Boolean; override;
+        procedure TrueClear; override;
+        function TrueRemove(const Item: ICollectable): ICollectable; override;
+        function TrueRemoveAll(const Item: ICollectable): ICollection; override;
+    public
+        constructor Create(NaturalItemsOnly: Boolean); override;
+        destructor Destroy; override;
+        function GetCapacity: Integer; override;
+        procedure SetCapacity(Value: Integer); override;
+        function GetIterator: IIterator; override;
+        function GetSize: Integer; override;
+        function TrueContains(const Item: ICollectable): Boolean; override;
+    end;
+
+    TPArraySet = class(TAbstractSet)
+    private
+        FList: TList;
+    protected
+        function GetPosition(const Item: ICollectable): TCollectionPosition; override;
+        procedure TrueAdd2(Position: TCollectionPosition; const Item: ICollectable); override;
+        procedure TrueClear; override;
+        function TrueGet(Position: TCollectionPosition): ICollectable; override;
+        procedure TrueRemove2(Position: TCollectionPosition); override;
+    public
+        constructor Create(NaturalItemsOnly: Boolean); override;
+        destructor Destroy; override;
+        function GetCapacity: Integer; override;
+        procedure SetCapacity(Value: Integer); override;
+        function GetIterator: IIterator; override;
+        function GetSize: Integer; override;
+    end;
+
+    TPArrayList = class(TAbstractList)
+    private
+        FList: TList;
+    protected
+        function TrueGetItem(Index: Integer): ICollectable; override;
+        procedure TrueSetItem(Index: Integer; const Item: ICollectable); override;
+        procedure TrueAppend(const Item: ICollectable); override;
+        procedure TrueClear; override;
+        function TrueDelete(Index: Integer): ICollectable; override;
+        procedure TrueInsert(Index: Integer; const Item: ICollectable); override;
+    public
+        constructor Create(NaturalItemsOnly: Boolean); override;
+        destructor Destroy; override;
+        function GetCapacity: Integer; override;
+        procedure SetCapacity(Value: Integer); override;
+        function GetIterator: IIterator; override;
+        function GetSize: Integer; override;
+    end;
+
+    TPArrayMap = class(TAbstractMap)
+    private
+        FList: TList;
+    protected
+        function GetAssociationIterator: IMapIterator; override;
+        function GetKeyPosition(const Key: ICollectable): TCollectionPosition; override;
+        procedure TrueClear; override;
+        function TrueGet(Position: TCollectionPosition): IAssociation; override;
+        function TruePut(Position: TCollectionPosition; const Association: IAssociation): IAssociation; override;
+        function TrueRemove2(Position: TCollectionPosition): IAssociation; override;
+    public
+        constructor Create(NaturalItemsOnly: Boolean; NaturalKeysOnly: Boolean); override;
+        destructor Destroy; override;
+        function GetCapacity: Integer; override;
+        procedure SetCapacity(Value: Integer); override;
+        function GetSize: Integer; override;
+    end;
+
+    // Same as TPArrayList but raises method visibilities so items can be manually
+    // appended or inserted without resetting sort flag.
+    TExposedPArrayList = class(TPArrayList)
+    public
+        procedure TrueAppend(const Item: ICollectable); override;
+        procedure TrueInsert(Index: Integer; const Item: ICollectable); override;
+    end;
+
+
+implementation
+
+type
+    TPArrayIterator = class(TAbstractIterator)
+    private
+        FList: TList;
+        FIndex: Integer;
+    protected
+        constructor Create(List: TList; AllowRemove: Boolean);
+        function TrueFirst: ICollectable; override;
+        function TrueNext: ICollectable; override;
+        procedure TrueRemove; override;
+    end;
+
+    TPArrayAssociationIterator = class(TAbstractAssociationIterator)
+    private
+        FList: TList;
+        FIndex: Integer;
+    protected
+        constructor Create(List: TList; AllowRemove: Boolean);
+        function TrueFirst: IAssociation; override;
+        function TrueNext: IAssociation; override;
+        procedure TrueRemove; override;
+    end;
+
+    TPArrayPosition = class(TCollectionPosition)
+    private
+        FIndex: Integer;
+    public
+        constructor Create(Found: Boolean; Index: Integer);
+        property Index: Integer read FIndex;
+    end;
+
+constructor TPArrayBag.Create(NaturalItemsOnly: Boolean);
+begin
+    inherited Create(NaturalItemsOnly);
+    FList := TList.Create;
+end;
+
+destructor TPArrayBag.Destroy;
+begin
+    FList.Free;
+    inherited Destroy;
+end;
+
+function TPArrayBag.TrueAdd(const Item: ICollectable): Boolean;
+begin
+    FList.Add(Pointer(Item));
+    Result := true;
+    // Storing interface reference as a pointer does not update reference
+    // count automatically, so this must be done manually
+    if Item <> nil then
+        Item._AddRef;
+end;
+
+procedure TPArrayBag.TrueClear;
+var
+    Item: ICollectable;
+    I: Integer;
+begin
+    // Delete all interface references
+    for I := 0 to FList.Count - 1 do
+    begin
+        Item := ICollectable(FList[I]);
+        FList[I] := nil;
+        // Storing interface reference as a pointer does not update reference
+        // count automatically, so this must be done manually
+        if Item <> nil then
+            Item._Release;
+    end;
+    FList.Clear;
+end;
+
+function TPArrayBag.TrueContains(const Item: ICollectable): Boolean;
+var
+    I: Integer;
+    Success: Boolean;
+begin
+    // Sequential search
+    I := 0;
+    Success := false;
+    while (I < FList.Count) and not Success do
+    begin
+        Success := Comparator.Equals(Item, ICollectable(FList[I]));
+        Inc(I);
+    end;
+    Result := Success;
+end;
+
+function TPArrayBag.TrueRemove(const Item: ICollectable): ICollectable;
+var
+    Item2: ICollectable;
+    I: Integer;
+    Found: Boolean;
+begin
+    // Sequential search
+    I := 0;
+    Found := false;
+    Result := nil;
+    while (I < FList.Count) and not Found do
+    begin
+        Item2 := ICollectable(FList[I]);
+        if Comparator.Equals(Item, Item2) then
+        begin
+            Found := true;
+            Result := Item2;
+            FList.Delete(I);
+            // Storing interface reference as a pointer does not update reference
+            // count automatically, so this must be done manually
+            if Item2 <> nil then
+                Item2._Release;
+        end
+        else
+            Inc(I);
+    end;
+end;
+
+function TPArrayBag.TrueRemoveAll(const Item: ICollectable): ICollection;
+var
+    ResultCollection: TPArrayBag;
+    Item2: ICollectable;
+    I: Integer;
+begin
+    // Sequential search
+    I := 0;
+    ResultCollection := TPArrayBag.Create;
+    while I < FList.Count do
+    begin
+        Item2 := ICollectable(FList[I]);
+        if Comparator.Equals(Item, Item2) then
+        begin
+            ResultCollection.Add(Item2);
+            FList.Delete(I);
+            // Storing interface reference as a pointer does not update reference
+            // count automatically, so this must be done manually
+            if Item <> nil then
+                Item._Release;
+        end
+        else
+            Inc(I);
+    end;
+    Result := ResultCollection;
+end;
+
+function TPArrayBag.GetCapacity: Integer;
+begin
+    Result := FList.Capacity;
+end;
+
+procedure TPArrayBag.SetCapacity(Value: Integer);
+begin
+    FList.Capacity := Value;
+end;
+
+function TPArrayBag.GetIterator: IIterator;
+begin
+    Result := TPArrayIterator.Create(FList, true);
+end;
+
+function TPArrayBag.GetSize: Integer;
+begin
+    Result := FList.Count;
+end;
+
+constructor TPArraySet.Create(NaturalItemsOnly: Boolean);
+begin
+    inherited Create(NaturalItemsOnly);
+    FList := TList.Create;
+end;
+
+destructor TPArraySet.Destroy;
+begin
+    FList.Free;
+    inherited Destroy;
+end;
+
+function TPArraySet.GetPosition(const Item: ICollectable): TCollectionPosition;
+var
+    I: Integer;
+    Success: Boolean;
+begin
+    // Sequential search
+    I := 0;
+    Success := false;
+    while (I < FList.Count) do
+    begin
+        Success := Comparator.Equals(Item, ICollectable(FList[I]));
+        if Success then
+            break;
+        Inc(I);
+    end;
+    Result := TPArrayPosition.Create(Success, I);
+end;
+
+procedure TPArraySet.TrueAdd2(Position: TCollectionPosition; const Item: ICollectable);
+begin
+    FList.Add(Pointer(Item));
+    // Storing interface reference as a pointer does not update reference
+    // count automatically, so this must be done manually
+    Item._AddRef;
+end;
+
+procedure TPArraySet.TrueClear;
+var
+    Item: ICollectable;
+    I: Integer;
+begin
+    // Delete all interface references
+    for I := 0 to FList.Count - 1 do
+    begin
+        Item := ICollectable(FList[I]);
+        FList[I] := nil;
+        // Storing interface reference as a pointer does not update reference
+        // count automatically, so this must be done manually
+        Item._Release;
+    end;
+    FList.Clear;
+end;
+
+function TPArraySet.TrueGet(Position: TCollectionPosition): ICollectable;
+begin
+    Result := ICollectable(FList.Items[TPArrayPosition(Position).Index]);
+end;
+
+procedure TPArraySet.TrueRemove2(Position: TCollectionPosition);
+var
+    Item: ICollectable;
+begin
+    Item := ICollectable(FList[TPArrayPosition(Position).Index]);
+    FList.Delete(TPArrayPosition(Position).Index);
+    // Storing interface reference as a pointer does not update reference
+    // count automatically, so this must be done manually
+    Item._Release;
+end;
+
+function TPArraySet.GetCapacity: Integer;
+begin
+    Result := FList.Capacity;
+end;
+
+procedure TPArraySet.SetCapacity(Value: Integer);
+begin
+    FList.Capacity := Value;
+end;
+
+function TPArraySet.GetIterator: IIterator;
+begin
+    Result := TPArrayIterator.Create(FList, true);
+end;
+
+function TPArraySet.GetSize: Integer;
+begin
+    Result := FList.Count;
+end;
+
+constructor TPArrayList.Create(NaturalItemsOnly: Boolean);
+begin
+    inherited Create(NaturalItemsOnly);
+    FList := TList.Create;
+end;
+
+destructor TPArrayList.Destroy;
+begin
+    FList.Free;
+    inherited Destroy;
+end;
+
+function TPArrayList.TrueGetItem(Index: Integer): ICollectable;
+begin
+    Result := ICollectable(FList.Items[Index]);
+end;
+
+procedure TPArrayList.TrueSetItem(Index: Integer; const Item: ICollectable);
+var
+    OldItem: ICollectable;
+begin
+    OldItem := ICollectable(FList[Index]);
+    FList[Index] := Pointer(Item);
+    // Storing interface reference as a pointer does not update reference
+    // count automatically, so this must be done manually
+    if Item <> nil then
+        Item._AddRef;
+    if OldItem <> nil then
+        OldItem._Release;
+end;
+
+procedure TPArrayList.TrueAppend(const Item: ICollectable);
+begin
+    FList.Add(Pointer(Item));
+    // Storing interface reference as a pointer does not update reference
+    // count automatically, so this must be done manually
+    if Item <> nil then
+        Item._AddRef;
+end;
+
+procedure TPArrayList.TrueClear;
+var
+    Item: ICollectable;
+    I: Integer;
+begin
+    // Delete all interface references
+    for I := 0 to FList.Count - 1 do
+    begin
+        Item := ICollectable(FList[I]);
+        FList[I] := nil;
+        // Storing interface reference as a pointer does not update reference
+        // count automatically, so this must be done manually
+        if Item <> nil then
+            Item._Release;
+    end;
+    FList.Clear;
+end;
+
+function TPArrayList.TrueDelete(Index: Integer): ICollectable;
+begin
+    Result := ICollectable(FList[Index]);
+    FList.Delete(Index);
+    // Storing interface reference as a pointer does not update reference
+    // count automatically, so this must be done manually
+    if Result <> nil then
+        Result._Release;
+end;
+
+procedure TPArrayList.TrueInsert(Index: Integer; const Item: ICollectable);
+begin
+    FList.Insert(Index, Pointer(Item));
+    // Storing interface reference as a pointer does not update reference
+    // count automatically, so this must be done manually
+    if Item <> nil then
+        Item._AddRef;
+end;
+
+function TPArrayList.GetCapacity: Integer;
+begin
+    Result := FList.Capacity;
+end;
+
+procedure TPArrayList.SetCapacity(Value: Integer);
+begin
+    FList.Capacity := Value;
+end;
+
+function TPArrayList.GetIterator: IIterator;
+begin
+    Result := TPArrayIterator.Create(FList, true);
+end;
+
+function TPArrayList.GetSize: Integer;
+begin
+    Result := FList.Count;
+end;
+
+constructor TPArrayMap.Create(NaturalItemsOnly: Boolean; NaturalKeysOnly: Boolean);
+begin
+    inherited Create(NaturalItemsOnly, NaturalKeysOnly);
+    FList := TList.Create;
+end;
+
+destructor TPArrayMap.Destroy;
+begin
+    FList.Free;
+    inherited Destroy;
+end;
+
+function TPArrayMap.GetAssociationIterator: IMapIterator;
+begin
+    Result := TPArrayAssociationIterator.Create(FList, true);
+end;
+
+function TPArrayMap.GetKeyPosition(const Key: ICollectable): TCollectionPosition;
+var
+    I: Integer;
+    Success: Boolean;
+begin
+    // Sequential search
+    I := 0;
+    Success := false;
+    while (I < FList.Count) do
+    begin
+        Success := KeyComparator.Equals(Key, IAssociation(FList[I]).GetKey);
+        if Success then
+            break;
+        Inc(I);
+    end;
+    Result := TPArrayPosition.Create(Success, I);
+end;
+
+procedure TPArrayMap.TrueClear;
+var
+    Association: IAssociation;
+    I: Integer;
+begin
+    // Delete all interface references
+    for I := 0 to FList.Count - 1 do
+    begin
+        Association := IAssociation(FList[I]);
+        FList[I] := nil;
+        // Storing interface reference as a pointer does not update reference
+        // count automatically, so this must be done manually
+        Association._Release;
+    end;
+    FList.Clear;
+end;
+
+function TPArrayMap.TrueGet(Position: TCollectionPosition): IAssociation;
+begin
+    Result := IAssociation(FList.Items[TPArrayPosition(Position).Index]);
+end;
+
+function TPArrayMap.TruePut(Position: TCollectionPosition; const Association: IAssociation): IAssociation;
+var
+    OldAssociation: IAssociation;
+    Index: Integer;
+begin
+    if Position.Found then
+    begin
+        Index := (Position as TPArrayPosition).Index;
+        OldAssociation := IAssociation(FList[Index]);
+        FList[Index] := Pointer(Association);
+    end
+    else
+    begin
+        OldAssociation := nil;
+        FList.Add(Pointer(Association));
+    end;
+    Result := OldAssociation;
+    // Storing interface reference as a pointer does not update reference
+    // count automatically, so this must be done manually
+    Association._AddRef;
+    if OldAssociation <> nil then
+        OldAssociation._Release;
+end;
+
+function TPArrayMap.TrueRemove2(Position: TCollectionPosition): IAssociation;
+var
+    OldAssociation: IAssociation;
+begin
+    OldAssociation := IAssociation(FList[TPArrayPosition(Position).Index]);
+    FList.Delete(TPArrayPosition(Position).Index);
+    Result := OldAssociation;
+    // Storing interface reference as a pointer does not update reference
+    // count automatically, so this must be done manually
+    OldAssociation._Release;
+end;
+
+function TPArrayMap.GetCapacity: Integer;
+begin
+    Result := FList.Capacity;
+end;
+
+procedure TPArrayMap.SetCapacity(Value: Integer);
+begin
+    FList.Capacity := Value;
+end;
+
+function TPArrayMap.GetSize: Integer;
+begin
+    Result := FList.Count;
+end;
+
+procedure TExposedPArrayList.TrueAppend(const Item: ICollectable);
+begin
+    inherited TrueAppend(Item);
+end;
+
+procedure TExposedPArrayList.TrueInsert(Index: Integer; const Item: ICollectable);
+begin
+    inherited TrueInsert(Index, Item);
+end;
+
+{ TPArrayIterator }
+constructor TPArrayIterator.Create(List: TList; AllowRemove: Boolean);
+begin
+    inherited Create(AllowRemove);
+    FList := List;
+    FIndex := -1;
+end;
+
+function TPArrayIterator.TrueFirst: ICollectable;
+begin
+    FIndex := 0;
+    if FIndex < FList.Count then
+        Result := ICollectable(FList[FIndex])
+    else
+        Result := nil;
+end;
+
+function TPArrayIterator.TrueNext: ICollectable;
+begin
+    Inc(FIndex);
+    if FIndex < FList.Count then
+        Result := ICollectable(FList[FIndex])
+    else
+        Result := nil;
+end;
+
+procedure TPArrayIterator.TrueRemove;
+var
+    Item: ICollectable;
+begin
+    Item := ICollectable(FList[FIndex]);
+    FList.Delete(FIndex);
+    Dec(FIndex);
+    // Storing interface reference as a pointer does not update reference
+    // count automatically, so this must be done manually
+    Item._Release;
+end;
+
+{ TPArrayAssociationIterator }
+constructor TPArrayAssociationIterator.Create(List: TList; AllowRemove: Boolean);
+begin
+    inherited Create(AllowRemove);
+    FList := List;
+    FIndex := -1;
+end;
+
+function TPArrayAssociationIterator.TrueFirst: IAssociation;
+begin
+    FIndex := 0;
+    if FIndex < FList.Count then
+        Result := IAssociation(FList[FIndex])
+    else
+        Result := nil;
+end;
+
+function TPArrayAssociationIterator.TrueNext: IAssociation;
+begin
+    Inc(FIndex);
+    if FIndex < FList.Count then
+        Result := IAssociation(FList[FIndex])
+    else
+        Result := nil;
+end;
+
+procedure TPArrayAssociationIterator.TrueRemove;
+var
+    Association: IAssociation;
+begin
+    Association := IAssociation(FList[FIndex]);
+    FList.Delete(FIndex);
+    Dec(FIndex);
+    // Storing interface reference as a pointer does not update reference
+    // count automatically, so this must be done manually
+    Association._Release;
+end;
+
+{ TPArrayPosition }
+constructor TPArrayPosition.Create(Found: Boolean; Index: Integer);
+begin
+    inherited Create(Found);
+    FIndex := Index;
+end;
+
+end.
diff --git a/Lua/src/lib/collections/CollWrappers.pas b/Lua/src/lib/collections/CollWrappers.pas
new file mode 100644
index 00000000..513103a2
--- /dev/null
+++ b/Lua/src/lib/collections/CollWrappers.pas
@@ -0,0 +1,876 @@
+unit CollWrappers;
+
+(*****************************************************************************
+ * Copyright 2003 by Matthew Greet
+ * This library is free software; you can redistribute it and/or modify it
+ * under the terms of the GNU Lesser General Public License as published by the
+ * Free Software Foundation; either version 2.1 of the License, or (at your
+ * option) any later version.
+ *
+ * This library is distributed in the hope that it will be useful, but WITHOUT
+ * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS
+ * FOR A PARTICULAR PURPOSE. See the GNU Lesser General Public License for more
+ * details. (http://opensource.org/licenses/lgpl-license.php)
+ *
+ * See http://www.warmachine.u-net.com/delphi_collections for updates and downloads.
+ *
+ * $Version: v1.0.3 $
+ * $Revision: 1.1.1.1 $
+ * $Log: D:\QVCS Repositories\Delphi Collections\CollWrappers.qbt $
+ * 
+ *   Various primitive type wrappers, adapters and abstract base classes for
+ *   natural items.
+ * 
+ * Revision 1.1.1.1  by: Matthew Greet  Rev date: 24/10/03 16:48:16
+ *   v1.0 branch.
+ * 
+ * Revision 1.1  by: Matthew Greet  Rev date: 06/04/03 10:51:04
+ *   Primitive type wrapper interfaces added. 
+ *   Abstract, template classes added. 
+ *   All classes implement reference counting by descending from
+ *   TInterfacedObject. 
+ *   
+ * 
+ * Revision 1.0  by: Matthew Greet  Rev date: 01/03/03 10:50:02
+ *   Initial revision.
+ * 
+ * FPC compatibility fixes by: UltraStar Deluxe Team
+ *
+ * $Endlog$
+ *****************************************************************************)
+
+{$IFDEF FPC}
+  {$MODE Delphi}{$H+}
+{$ENDIF}
+ 
+interface
+
+uses
+    SysUtils,
+    Collections;
+
+type
+    IAssociationWrapper = interface
+        ['{54DF42E0-64F2-11D7-8120-0002E3165EF8}']
+        function GetAutoDestroy: Boolean;
+        procedure SetAutoDestroy(Value: Boolean);
+        function GetKey: ICollectable;
+        function GetValue: TObject;
+        property AutoDestroy: Boolean read GetAutoDestroy write SetAutoDestroy;
+        property Key: ICollectable read GetKey;
+        property Value: TObject read GetValue;
+    end;
+
+    IBoolean = interface
+        ['{62D1D160-64F2-11D7-8120-0002E3165EF8}']
+        function GetValue: Boolean;
+        property Value: Boolean read GetValue;
+    end;
+
+    ICardinal = interface
+        ['{6AF7B1C0-64F2-11D7-8120-0002E3165EF8}']
+        function GetValue: Cardinal;
+        property Value: Cardinal read GetValue;
+    end;
+
+    IChar = interface
+        ['{73AD00E0-64F2-11D7-8120-0002E3165EF8}']
+        function GetValue: Char;
+        property Value: Char read GetValue;
+    end;
+
+    IClass = interface
+        ['{7A84B660-64F2-11D7-8120-0002E3165EF8}']
+        function GetValue: TClass;
+        property Value: TClass read GetValue;
+    end;
+
+    IDouble = interface
+        ['{815C6BE0-64F2-11D7-8120-0002E3165EF8}']
+        function GetValue: Double;
+        property Value: Double read GetValue;
+    end;
+
+    IInteger = interface
+        ['{88ECC300-64F2-11D7-8120-0002E3165EF8}']
+        function GetValue: Integer;
+        property Value: Integer read GetValue;
+    end;
+
+    IIntegerAssociationWrapper = interface
+        ['{8F582220-64F2-11D7-8120-0002E3165EF8}']
+        function GetAutoDestroy: Boolean;
+        procedure SetAutoDestroy(Value: Boolean);
+        function GetKey: Integer;
+        function GetValue: TObject;
+        property AutoDestroy: Boolean read GetAutoDestroy write SetAutoDestroy;
+        property Key: Integer read GetKey;
+        property Value: TObject read GetValue;
+    end;
+
+    IInterfaceWrapper = interface
+        ['{962E5100-64F2-11D7-8120-0002E3165EF8}']
+        function GetValue: IUnknown;
+        property Value: IUnknown read GetValue;
+    end;
+
+    IObject = interface
+        ['{9C675580-64F2-11D7-8120-0002E3165EF8}']
+        function GetAutoDestroy: Boolean;
+        procedure SetAutoDestroy(Value: Boolean);
+        function GetValue: TObject;
+        property Value: TObject read GetValue;
+    end;
+
+    IString = interface
+        ['{A420DF80-64F2-11D7-8120-0002E3165EF8}']
+        function GetValue: String;
+        property Value: String read GetValue;
+    end;
+
+    IStringAssociationWrapper = interface
+        ['{AB98CCA0-64F2-11D7-8120-0002E3165EF8}']
+        function GetAutoDestroy: Boolean;
+        procedure SetAutoDestroy(Value: Boolean);
+        function GetKey: String;
+        function GetValue: TObject;
+        property AutoDestroy: Boolean read GetAutoDestroy write SetAutoDestroy;
+        property Key: String read GetKey;
+        property Value: TObject read GetValue;
+    end;
+
+    TAbstractItem = class(TInterfacedObject, ICollectable)
+    public
+        function GetInstance: TObject; virtual;
+    end;
+
+    TAbstractIntegerMappable = class(TAbstractItem, IEquatable, IIntegerMappable)
+    private
+        FKey: Integer;
+    protected
+        function MakeKey: Integer; virtual; abstract;
+    public
+        procedure AfterConstruction; override;
+        function Equals(const Item: ICollectable): Boolean; virtual;
+        function GetKey: Integer; virtual;
+    end;
+
+    TAbstractMappable = class(TAbstractItem, IEquatable, IMappable)
+    private
+        FKey: ICollectable;
+    protected
+        function MakeKey: ICollectable; virtual; abstract;
+    public
+        destructor Destroy; override;
+        procedure AfterConstruction; override;
+        function Equals(const Item: ICollectable): Boolean; virtual;
+        function GetKey: ICollectable; virtual;
+    end;
+
+    TAbstractStringMappable = class(TAbstractItem, IEquatable, IStringMappable)
+    private
+        FKey: String;
+    protected
+        function MakeKey: String; virtual; abstract;
+    public
+        procedure AfterConstruction; override;
+        function Equals(const Item: ICollectable): Boolean; virtual;
+        function GetKey: String; virtual;
+    end;
+
+    TAssociationWrapper = class(TAbstractItem, IEquatable, IMappable, IAssociationWrapper)
+    private
+        FAutoDestroy: Boolean;
+        FKey: ICollectable;
+        FValue: TObject;
+    public
+        constructor Create(const Key: ICollectable; Value: TObject); overload;
+        constructor Create(Key: Integer; Value: TObject); overload;
+        constructor Create(Key: String; Value: TObject); overload;
+        constructor Create(Key, Value: TObject; AutoDestroyKey: Boolean = true); overload;
+        destructor Destroy; override;
+        function GetAutoDestroy: Boolean;
+        procedure SetAutoDestroy(Value: Boolean);
+        function GetKey: ICollectable;
+        function GetValue: TObject;
+        function Equals(const Item: ICollectable): Boolean;
+        property AutoDestroy: Boolean read GetAutoDestroy write SetAutoDestroy;
+        property Key: ICollectable read GetKey;
+        property Value: TObject read GetValue;
+    end;
+
+    TBooleanWrapper = class(TAbstractItem, IEquatable, IHashable, IComparable, IBoolean)
+    private
+        FValue: Boolean;
+    public
+        constructor Create(Value: Boolean);
+        function GetValue: Boolean;
+        function CompareTo(const Item: ICollectable): Integer;
+        function Equals(const Item: ICollectable): Boolean;
+        function HashCode: Integer;
+        property Value: Boolean read GetValue;
+    end;
+
+    TCardinalWrapper = class(TAbstractItem, IEquatable, IHashable, IComparable, ICardinal)
+    private
+        FValue: Cardinal;
+    public
+        constructor Create(Value: Cardinal);
+        function GetValue: Cardinal;
+        function Equals(const Item: ICollectable): Boolean;
+        function HashCode: Integer;
+        function CompareTo(const Item: ICollectable): Integer;
+        property Value: Cardinal read GetValue;
+    end;
+
+    TCharWrapper = class(TAbstractItem, IEquatable, IHashable, IComparable, IChar)
+    private
+        FValue: Char;
+    public
+        constructor Create(Value: Char);
+        function GetValue: Char;
+        function Equals(const Item: ICollectable): Boolean;
+        function HashCode: Integer;
+        function CompareTo(const Item: ICollectable): Integer;
+        property Value: Char read GetValue;
+    end;
+
+    TClassWrapper = class(TAbstractItem, IEquatable, IHashable, IClass)
+    private
+        FValue: TClass;
+    public
+        constructor Create(Value: TClass);
+        function GetValue: TClass;
+        function Equals(const Item: ICollectable): Boolean;
+        function HashCode: Integer;
+        property Value: TClass read GetValue;
+    end;
+
+    TDoubleWrapper = class(TAbstractItem, IEquatable, IHashable, IComparable, IDouble)
+    private
+        FValue: Double;
+    public
+        constructor Create(Value: Double);
+        function GetValue: Double;
+        function Equals(const Item: ICollectable): Boolean;
+        function HashCode: Integer;
+        function CompareTo(const Item: ICollectable): Integer;
+        property Value: Double read GetValue;
+    end;
+
+    TIntegerWrapper = class(TAbstractItem, IEquatable, IHashable, IComparable, IInteger)
+    private
+        FValue: Integer;
+    public
+        constructor Create(Value: Integer);
+        function GetValue: Integer;
+        function Equals(const Item: ICollectable): Boolean;
+        function HashCode: Integer;
+        function CompareTo(const Item: ICollectable): Integer;
+        property Value: Integer read GetValue;
+    end;
+
+    TIntegerAssociationWrapper = class(TAbstractItem, IEquatable, IIntegerMappable, IIntegerAssociationWrapper)
+    private
+        FAutoDestroy: Boolean;
+        FKey: Integer;
+        FValue: TObject;
+    public
+        constructor Create(const Key: Integer; Value: TObject); overload;
+        destructor Destroy; override;
+        function Equals(const Item: ICollectable): Boolean;
+        function GetAutoDestroy: Boolean;
+        procedure SetAutoDestroy(Value: Boolean);
+        function GetKey: Integer;
+        function GetValue: TObject;
+        property AutoDestroy: Boolean read GetAutoDestroy write SetAutoDestroy;
+        property Key: Integer read GetKey;
+        property Value: TObject read GetValue;
+    end;
+
+    TInterfaceWrapper = class(TAbstractItem, IHashable, IEquatable, IInterfaceWrapper)
+    private
+        FValue: IUnknown;
+    public
+        constructor Create(const Value: IUnknown);
+        destructor Destroy; override;
+        function GetValue: IUnknown;
+        function Equals(const Item: ICollectable): Boolean;
+        function HashCode: Integer;
+        property Value: IUnknown read GetValue;
+    end;
+
+    TObjectWrapper = class(TAbstractItem, IEquatable, IComparable, IHashable, IObject)
+    private
+        FAutoDestroy: Boolean;
+        FValue: TObject;
+    public
+        constructor Create(Value: TObject); overload;
+        destructor Destroy; override;
+        function GetAutoDestroy: Boolean;
+        procedure SetAutoDestroy(Value: Boolean);
+        function GetValue: TObject;
+        function CompareTo(const Item: ICollectable): Integer;
+        function Equals(const Item: ICollectable): Boolean;
+        function HashCode: Integer;
+        property AutoDestroy: Boolean read FAutoDestroy write FAutoDestroy;
+        property Value: TObject read GetValue;
+    end;
+
+    TStringWrapper = class(TAbstractItem, IEquatable, IHashable, IComparable, IString)
+    private
+        FValue: String;
+    public
+        constructor Create(Value: String);
+        function GetValue: String;
+        function Equals(const Item: ICollectable): Boolean;
+        function HashCode: Integer;
+        function CompareTo(const Item: ICollectable): Integer;
+        property Value: String read FValue;
+    end;
+
+    TStringAssociationWrapper = class(TAbstractItem, IEquatable, IStringMappable, IStringAssociationWrapper)
+    private
+        FAutoDestroy: Boolean;
+        FKey: String;
+        FValue: TObject;
+    public
+        constructor Create(const Key: String; Value: TObject); overload;
+        destructor Destroy; override;
+        function GetAutoDestroy: Boolean;
+        procedure SetAutoDestroy(Value: Boolean);
+        function GetKey: String;
+        function GetValue: TObject;
+        function Equals(const Item: ICollectable): Boolean;
+        property AutoDestroy: Boolean read GetAutoDestroy write SetAutoDestroy;
+        property Key: String read GetKey;
+        property Value: TObject read GetValue;
+    end;
+
+implementation
+
+{ TAbstractItem }
+function TAbstractItem.GetInstance: TObject;
+begin
+    Result := Self;
+end;
+
+
+{ TAbstractIntegerMappable }
+procedure TAbstractIntegerMappable.AfterConstruction;
+begin
+    inherited AfterConstruction;
+    FKey := MakeKey;
+end;
+
+function TAbstractIntegerMappable.Equals(const Item: ICollectable): Boolean;
+begin
+    Result := (Self = Item.GetInstance);
+end;
+
+function TAbstractIntegerMappable.GetKey: Integer;
+begin
+    Result := FKey;
+end;
+
+{ TAbstractMappable }
+destructor TAbstractMappable.Destroy;
+begin
+    FKey := nil;
+    inherited Destroy;
+end;
+
+procedure TAbstractMappable.AfterConstruction;
+begin
+    inherited AfterConstruction;
+    FKey := MakeKey;
+end;
+
+function TAbstractMappable.Equals(const Item: ICollectable): Boolean;
+begin
+    Result := (Self = Item.GetInstance);
+end;
+
+function TAbstractMappable.GetKey: ICollectable;
+begin
+    Result := FKey;
+end;
+
+{ TAbstractStringMappable }
+procedure TAbstractStringMappable.AfterConstruction;
+begin
+    inherited AfterConstruction;
+    FKey := MakeKey;
+end;
+
+function TAbstractStringMappable.Equals(const Item: ICollectable): Boolean;
+begin
+    Result := (Self = Item.GetInstance);
+end;
+
+function TAbstractStringMappable.GetKey: String;
+begin
+    Result := FKey;
+end;
+
+{ TAssociationWrapper }
+constructor TAssociationWrapper.Create(const Key: ICollectable; Value: TObject);
+begin
+    inherited Create;
+    FAutoDestroy := true;
+    FKey := Key;
+    FValue := Value;
+end;
+
+constructor TAssociationWrapper.Create(Key: Integer; Value: TObject);
+begin
+    Create(TIntegerWrapper.Create(Key) as ICollectable, Value);
+end;
+
+constructor TAssociationWrapper.Create(Key: String; Value: TObject);
+begin
+    Create(TStringWrapper.Create(Key) as ICollectable, Value);
+end;
+
+constructor TAssociationWrapper.Create(Key, Value: TObject; AutoDestroyKey: Boolean);
+var
+    KeyWrapper: TObjectWrapper;
+begin
+    KeyWrapper := TObjectWrapper.Create(Key);
+    KeyWrapper.AutoDestroy := AutoDestroyKey;
+    Create(KeyWrapper as ICollectable, Value);
+end;
+
+destructor TAssociationWrapper.Destroy;
+begin
+    if FAutoDestroy then
+        FValue.Free;
+    FKey := nil;
+    inherited Destroy;
+end;
+
+function TAssociationWrapper.GetAutoDestroy: Boolean;
+begin
+    Result := FAutoDestroy;
+end;
+
+procedure TAssociationWrapper.SetAutoDestroy(Value: Boolean);
+begin
+    FAutoDestroy := Value;
+end;
+
+function TAssociationWrapper.GetKey: ICollectable;
+begin
+    Result := FKey;
+end;
+
+function TAssociationWrapper.GetValue: TObject;
+begin
+    Result := FValue;
+end;
+
+function TAssociationWrapper.Equals(const Item: ICollectable): Boolean;
+begin
+    Result := (Self.Value = (Item.GetInstance as TAssociationWrapper).Value)
+end;
+
+{ TCardinalWrapper }
+constructor TCardinalWrapper.Create(Value: Cardinal);
+begin
+    inherited Create;
+    FValue := Value;
+end;
+
+function TCardinalWrapper.GetValue: Cardinal;
+begin
+    Result := FValue;
+end;
+
+function TCardinalWrapper.Equals(const Item: ICollectable): Boolean;
+begin
+    Result := (Self.Value = (Item.GetInstance as TCardinalWrapper).Value)
+end;
+
+function TCardinalWrapper.HashCode: Integer;
+begin
+    Result := FValue;
+end;
+
+function TCardinalWrapper.CompareTo(const Item: ICollectable): Integer;
+var
+    Value2: Cardinal;
+begin
+    Value2 := (Item.GetInstance as TCardinalWrapper).Value;
+    if Value < Value2 then
+        Result := -1
+    else if Value > Value2 then
+        Result := 1
+    else
+        Result := 0;
+end;
+
+{ TBooleanWrapper }
+constructor TBooleanWrapper.Create(Value: Boolean);
+begin
+    inherited Create;
+    FValue := Value;
+end;
+
+function TBooleanWrapper.GetValue: Boolean;
+begin
+    Result := FValue;
+end;
+
+function TBooleanWrapper.Equals(const Item: ICollectable): Boolean;
+begin
+    Result := (Self.Value = (Item.GetInstance as TBooleanWrapper).Value)
+end;
+
+function TBooleanWrapper.HashCode: Integer;
+begin
+    Result := Ord(FValue);
+end;
+
+function TBooleanWrapper.CompareTo(const Item: ICollectable): Integer;
+var
+    Value2: Boolean;
+begin
+    Value2 := (Item.GetInstance as TBooleanWrapper).Value;
+    if not Value and Value2 then
+        Result := -1
+    else if Value and not Value2 then
+        Result := 1
+    else
+        Result := 0;
+end;
+
+{ TCharWrapper }
+constructor TCharWrapper.Create(Value: Char);
+begin
+    inherited Create;
+    FValue := Value;
+end;
+
+function TCharWrapper.GetValue: Char;
+begin
+    Result := FValue;
+end;
+
+function TCharWrapper.Equals(const Item: ICollectable): Boolean;
+begin
+    Result := (Self.Value = (Item.GetInstance as TCharWrapper).Value)
+end;
+
+function TCharWrapper.HashCode: Integer;
+begin
+    Result := Integer(FValue);
+end;
+
+function TCharWrapper.CompareTo(const Item: ICollectable): Integer;
+var
+    Value2: Char;
+begin
+    Value2 := (Item.GetInstance as TCharWrapper).Value;
+    if Value < Value2 then
+        Result := -1
+    else if Value > Value2 then
+        Result := 1
+    else
+        Result := 0;
+end;
+
+{ TClassWrapper }
+constructor TClassWrapper.Create(Value: TClass);
+begin
+    inherited Create;
+    FValue := Value;
+end;
+
+function TClassWrapper.GetValue: TClass;
+begin
+    Result := FValue;
+end;
+
+function TClassWrapper.Equals(const Item: ICollectable): Boolean;
+begin
+    Result := (Self.Value = (Item.GetInstance as TClassWrapper).Value)
+end;
+
+function TClassWrapper.HashCode: Integer;
+begin
+    Result := Integer(FValue.ClassInfo);
+end;
+
+{ TDoubleWrapper }
+constructor TDoubleWrapper.Create(Value: Double);
+begin
+    inherited Create;
+    FValue := Value;
+end;
+
+function TDoubleWrapper.GetValue: Double;
+begin
+    Result := FValue;
+end;
+
+function TDoubleWrapper.Equals(const Item: ICollectable): Boolean;
+begin
+    Result := (Self.Value = (Item.GetInstance as TDoubleWrapper).Value)
+end;
+
+function TDoubleWrapper.HashCode: Integer;
+var
+    DblAsInt: array[0..1] of Integer;
+begin
+    Double(DblAsInt) := Value;
+    Result := DblAsInt[0] xor DblAsInt[1];
+end;
+
+function TDoubleWrapper.CompareTo(const Item: ICollectable): Integer;
+var
+    Value2: Double;
+begin
+    Value2 := (Item.GetInstance as TDoubleWrapper).Value;
+    if Value < Value2 then
+        Result := -1
+    else if Value > Value2 then
+        Result := 1
+    else
+        Result := 0;
+end;
+
+{ TIntegerWrapper }
+constructor TIntegerWrapper.Create(Value: Integer);
+begin
+    inherited Create;
+    FValue := Value;
+end;
+
+function TIntegerWrapper.GetValue: Integer;
+begin
+    Result := FValue;
+end;
+
+function TIntegerWrapper.Equals(const Item: ICollectable): Boolean;
+begin
+    Result := (Self.Value = (Item.GetInstance as TIntegerWrapper).Value)
+end;
+
+function TIntegerWrapper.HashCode: Integer;
+begin
+    Result := FValue;
+end;
+
+function TIntegerWrapper.CompareTo(const Item: ICollectable): Integer;
+var
+    Value2: Integer;
+begin
+    Value2 := (Item.GetInstance as TIntegerWrapper).Value;
+    if Value < Value2 then
+        Result := -1
+    else if Value > Value2 then
+        Result := 1
+    else
+        Result := 0;
+end;
+
+{ TIntegerAssociationWrapper }
+constructor TIntegerAssociationWrapper.Create(const Key: Integer; Value: TObject);
+begin
+    inherited Create;
+    FAutoDestroy := true;
+    FKey := Key;
+    FValue := Value;
+end;
+
+destructor TIntegerAssociationWrapper.Destroy;
+begin
+    if FAutoDestroy then
+        FValue.Free;
+    inherited Destroy;
+end;
+
+function TIntegerAssociationWrapper.GetAutoDestroy: Boolean;
+begin
+    Result := FAutoDestroy;
+end;
+
+procedure TIntegerAssociationWrapper.SetAutoDestroy(Value: Boolean);
+begin
+    FAutoDestroy := Value;
+end;
+
+function TIntegerAssociationWrapper.GetValue: TObject;
+begin
+    Result := FValue;
+end;
+
+function TIntegerAssociationWrapper.Equals(const Item: ICollectable): Boolean;
+begin
+    Result := (Self.Value = (Item.GetInstance as TIntegerAssociationWrapper).Value)
+end;
+
+function TIntegerAssociationWrapper.GetKey: Integer;
+begin
+    Result := FKey;
+end;
+
+{ TStringAssociationWrapper }
+constructor TStringAssociationWrapper.Create(const Key: String; Value: TObject);
+begin
+    inherited Create;
+    FAutoDestroy := true;
+    FKey := Key;
+    FValue := Value;
+end;
+
+destructor TStringAssociationWrapper.Destroy;
+begin
+    if FAutoDestroy then
+        FValue.Free;
+    inherited Destroy;
+end;
+
+function TStringAssociationWrapper.GetAutoDestroy: Boolean;
+begin
+    Result := FAutoDestroy;
+end;
+
+procedure TStringAssociationWrapper.SetAutoDestroy(Value: Boolean);
+begin
+    FAutoDestroy := Value;
+end;
+
+function TStringAssociationWrapper.GetValue: TObject;
+begin
+    Result := FValue;
+end;
+
+function TStringAssociationWrapper.Equals(const Item: ICollectable): Boolean;
+begin
+    Result := (Self.Value = (Item.GetInstance as TStringAssociationWrapper).Value)
+end;
+
+function TStringAssociationWrapper.GetKey: String;
+begin
+    Result := FKey;
+end;
+
+{ TInterfaceWrapper }
+constructor TInterfaceWrapper.Create(const Value: IUnknown);
+begin
+    inherited Create;
+    FValue := Value;
+end;
+
+destructor TInterfaceWrapper.Destroy;
+begin
+    FValue := nil;
+    inherited Destroy;
+end;
+
+function TInterfaceWrapper.GetValue: IUnknown;
+begin
+    Result := FValue;
+end;
+
+function TInterfaceWrapper.Equals(const Item: ICollectable): Boolean;
+begin
+    Result := (Self.Value = (Item.GetInstance as TInterfaceWrapper).Value)
+end;
+
+function TInterfaceWrapper.HashCode: Integer;
+begin
+    Result := Integer(Pointer(FValue));
+end;
+
+{ TObjectWrapper }
+constructor TObjectWrapper.Create(Value: TObject);
+begin
+    inherited Create;
+    FAutoDestroy := true;
+    FValue := Value;
+end;
+
+destructor TObjectWrapper.Destroy;
+begin
+    if FAutoDestroy then
+        FValue.Free;
+    inherited Destroy;
+end;
+
+function TObjectWrapper.GetAutoDestroy: Boolean;
+begin
+    Result := FAutoDestroy;
+end;
+
+procedure TObjectWrapper.SetAutoDestroy(Value: Boolean);
+begin
+    FAutoDestroy := Value;
+end;
+
+function TObjectWrapper.GetValue: TObject;
+begin
+    Result := FValue;
+end;
+
+function TObjectWrapper.CompareTo(const Item: ICollectable): Integer;
+var
+    Value1, Value2: Integer;
+begin
+    Value1 := Integer(Pointer(Self));
+    if Item <> nil then
+        Value2 := Integer(Pointer(Item))
+    else
+        Value2 := Low(Integer);
+    if (Value1 < Value2) then
+        Result := -1
+    else if (Value1 > Value2) then
+        Result := 1
+    else
+        Result := 0;
+end;
+
+function TObjectWrapper.Equals(const Item: ICollectable): Boolean;
+begin
+    Result := (Self.Value = (Item.GetInstance as TObjectWrapper).Value)
+end;
+
+function TObjectWrapper.HashCode: Integer;
+begin
+    Result := Integer(Pointer(FValue));
+end;
+
+{ TStringWrapper }
+constructor TStringWrapper.Create(Value: String);
+begin
+    inherited Create;
+    FValue := Value;
+end;
+
+function TStringWrapper.GetValue: String;
+begin
+    Result := FValue;
+end;
+
+function TStringWrapper.Equals(const Item: ICollectable): Boolean;
+begin
+    Result := (Self.Value = (Item.GetInstance as TStringWrapper).Value)
+end;
+
+function TStringWrapper.HashCode: Integer;
+var
+    I: Integer;
+begin
+    Result := 0;
+    for I := 1 to Length(FValue) do
+        Result := (Result shl 1) xor Ord(FValue[I]);
+end;
+
+function TStringWrapper.CompareTo(const Item: ICollectable): Integer;
+begin
+    Result := CompareStr(Self.Value, (Item.GetInstance as TStringWrapper).Value)
+end;
+
+
+end.
diff --git a/Lua/src/lib/collections/Collections.pas b/Lua/src/lib/collections/Collections.pas
new file mode 100644
index 00000000..0c94173d
--- /dev/null
+++ b/Lua/src/lib/collections/Collections.pas
@@ -0,0 +1,5318 @@
+unit Collections;
+(*****************************************************************************
+ * Copyright 2003 by Matthew Greet
+ * This library is free software; you can redistribute it and/or modify it
+ * under the terms of the GNU Lesser General Public License as published by the
+ * Free Software Foundation; either version 2.1 of the License, or (at your
+ * option) any later version.
+ *
+ * This library is distributed in the hope that it will be useful, but WITHOUT
+ * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS
+ * FOR A PARTICULAR PURPOSE. See the GNU Lesser General Public License for more
+ * details. (http://opensource.org/licenses/lgpl-license.php)
+ * 
+ * See http://www.warmachine.u-net.com/delphi_collections for updates and downloads.
+ *
+ * $Version: v1.0 $
+ * $Revision: 1.1.1.4 $
+ * $Log: D:\QVCS Repositories\Delphi Collections\Collections.qbt $
+ * 
+ *   Main unit containing all interface and abstract class definitions.
+ * 
+ * Revision 1.1.1.4  by: Matthew Greet  Rev date: 14/03/05 23:26:32
+ *   Fixed RemoveAll for TAbstractList for sorted lists.
+ * 
+ * Revision 1.1.1.3  by: Matthew Greet  Rev date: 14/10/04 16:31:18
+ *   Fixed memory lean in ContainsKey of TAbstractStringMap and
+ *   TAbstractIntegerMap.
+ * 
+ * Revision 1.1.1.2  by: Matthew Greet  Rev date: 12/06/04 20:03:26
+ *   Capacity property. 
+ *   Memory leak fixed.
+ * 
+ * Revision 1.1.1.1  by: Matthew Greet  Rev date: 13/02/04 16:12:10
+ *   v1.0 branch.
+ * 
+ * Revision 1.1  by: Matthew Greet  Rev date: 06/04/03 10:36:30
+ *   Added integer map and string map collection types with supporting
+ *   classes. 
+ *   Add clone and filter functions with supporting classes. 
+ *   Added nil not allowed collection error. 
+ *   Properties appear in collection interfaces as well as abstract
+ *   classes.
+ * 
+ * Revision 1.0  by: Matthew Greet  Rev date: 01/03/03 10:50:02
+ *   Initial revision.
+ * 
+ * FPC compatibility fixes by: UltraStar Deluxe Team
+ *
+ * $Endlog$
+ *****************************************************************************)
+
+{$IFDEF FPC}
+  {$MODE Delphi}{$H+}
+{$ENDIF}
+ 
+interface
+
+uses
+    Classes, SysUtils;
+
+const
+    EquatableIID: TGUID = '{EAC823A7-0B90-11D7-8120-0002E3165EF8}';
+    HashableIID: TGUID = '{98998440-4C3E-11D7-8120-0002E3165EF8}';
+    ComparableIID: TGUID = '{9F4C96C0-0CF0-11D7-8120-0002E3165EF8}';
+    MappableIID: TGUID = '{DAEC8CA0-0DBB-11D7-8120-0002E3165EF8}';
+    StringMappableIID: TGUID = '{3CC61F40-5F92-11D7-8120-0002E3165EF8}';
+    IntegerMappableIID: TGUID = '{774FC760-5F92-11D7-8120-0002E3165EF8}';
+
+type
+    TDefaultComparator = class;
+    TNaturalComparator = class;
+    ICollectable = interface;
+
+    TCollectableArray = array of ICollectable;
+    TIntegerArray = array of Integer;
+    TStringArray = array of String;
+    TListArray = array of TList;
+
+    TCollectionError = (ceOK, ceDuplicate, ceDuplicateKey, ceFixedSize, ceNilNotAllowed, ceNotNaturalItem, ceOutOfRange);
+    TCollectionErrors = set of TCollectionError;
+
+    TSearchResultType = (srNotFound, srFoundAtIndex, srBeforeIndex, srAfterEnd);
+
+    TCollectionType = (ctBag, ctSet, ctList, ctMap, ctIntegerMap, ctStringMap);
+
+    TCollectionFilterFunc = function (const Item: ICollectable): Boolean of object;
+    TCollectionCompareFunc = function (const Item1, Item2: ICollectable): Integer of object;
+
+    TSearchResult = record
+        ResultType: TSearchResultType;
+        Index: Integer;
+    end;
+
+    ICollectable = interface
+        ['{98998441-4C3E-11D7-8120-0002E3165EF8}']
+        function GetInstance: TObject;
+    end;
+
+    IEquatable = interface
+        ['{EAC823A7-0B90-11D7-8120-0002E3165EF8}']
+        function GetInstance: TObject;
+        function Equals(const Item: ICollectable): Boolean;
+    end;
+
+    IHashable = interface(IEquatable)
+        ['{98998440-4C3E-11D7-8120-0002E3165EF8}']
+        function HashCode: Integer;
+    end;
+
+    IComparable = interface(IEquatable)
+        ['{9F4C96C0-0CF0-11D7-8120-0002E3165EF8}']
+        function CompareTo(const Item: ICollectable): Integer;
+    end;
+
+    IMappable = interface(IEquatable)
+        ['{DAEC8CA0-0DBB-11D7-8120-0002E3165EF8}']
+        function GetKey: ICollectable;
+    end;
+
+    IStringMappable = interface(IEquatable)
+        ['{3CC61F40-5F92-11D7-8120-0002E3165EF8}']
+        function GetKey: String;
+    end;
+
+    IIntegerMappable = interface(IEquatable)
+        ['{774FC760-5F92-11D7-8120-0002E3165EF8}']
+        function GetKey: Integer;
+    end;
+
+    IComparator = interface
+        ['{1F20CD60-10FE-11D7-8120-0002E3165EF8}']
+        function GetInstance: TObject;
+        function Compare(const Item1, Item2: ICollectable): Integer;
+        function Equals(const Item1, Item2: ICollectable): Boolean; overload;
+        function Equals(const Comparator: IComparator): Boolean; overload;
+    end;
+
+    IFilter = interface
+        ['{27FE44C0-638E-11D7-8120-0002E3165EF8}']
+        function Accept(const Item: ICollectable): Boolean;
+    end;
+
+    IIterator = interface
+        ['{F6930500-1113-11D7-8120-0002E3165EF8}']
+        function GetAllowRemoval: Boolean;
+        function CurrentItem: ICollectable;
+        function EOF: Boolean;
+        function First: ICollectable;
+        function Next: ICollectable;
+        function Remove: Boolean;
+    end;
+
+    IMapIterator = interface(IIterator)
+        ['{848CC0E0-2A31-11D7-8120-0002E3165EF8}']
+        function CurrentKey: ICollectable;
+    end;
+
+    IIntegerMapIterator = interface(IIterator)
+        ['{C7169780-606C-11D7-8120-0002E3165EF8}']
+        function CurrentKey: Integer;
+    end;
+
+    IStringMapIterator = interface(IIterator)
+        ['{1345ED20-5F93-11D7-8120-0002E3165EF8}']
+        function CurrentKey: String;
+    end;
+
+    IAssociation = interface(ICollectable)
+        ['{556CD700-4DB3-11D7-8120-0002E3165EF8}']
+        function GetKey: ICollectable;
+        function GetValue: ICollectable;
+    end;
+
+    IIntegerAssociation = interface(ICollectable)
+        ['{ED954420-5F94-11D7-8120-0002E3165EF8}']
+        function GetKey: Integer;
+        function GetValue: ICollectable;
+    end;
+
+    IStringAssociation = interface(ICollectable)
+        ['{FB87D2A0-5F94-11D7-8120-0002E3165EF8}']
+        function GetKey: String;
+        function GetValue: ICollectable;
+    end;
+
+    IAssociationComparator = interface(IComparator)
+        ['{EA9BE6E0-A852-11D8-B93A-0002E3165EF8}']
+        function GetKeyComparator: IComparator;
+        procedure SetKeyComparator(Value: IComparator);
+        property KeyComparator: IComparator read GetKeyComparator write SetKeyComparator;
+    end;
+
+    IIntegerAssociationComparator = interface(IComparator)
+        ['{EA9BE6E1-A852-11D8-B93A-0002E3165EF8}']
+    end;
+
+    IStringAssociationComparator = interface(IComparator)
+        ['{EA9BE6E2-A852-11D8-B93A-0002E3165EF8}']
+    end;
+
+    ICollection = interface
+        ['{EAC823AC-0B90-11D7-8120-0002E3165EF8}']
+        function GetAsArray: TCollectableArray;
+        function GetCapacity: Integer;
+        procedure SetCapacity(Value: Integer);
+        function GetComparator: IComparator;
+        procedure SetComparator(const Value: IComparator);
+        function GetDuplicates: Boolean;
+        function GetFixedSize: Boolean;
+        function GetIgnoreErrors: TCollectionErrors;
+        procedure SetIgnoreErrors(Value: TCollectionErrors);
+        function GetInstance: TObject;
+        function GetIterator: IIterator; overload;
+        function GetIterator(const Filter: IFilter): IIterator; overload;
+        function GetIterator(FilterFunc: TCollectionFilterFunc): IIterator; overload;
+        function GetNaturalItemIID: TGUID;
+        function GetNaturalItemsOnly: Boolean;
+        function GetSize: Integer;
+        function GetType: TCollectionType;
+        function Add(const Item: ICollectable): Boolean; overload;
+        function Add(const ItemArray: array of ICollectable): Integer; overload;
+        function Add(const Collection: ICollection): Integer; overload;
+        function Clear: Integer;
+        function Clone: ICollection;
+        function Contains(const Item: ICollectable): Boolean; overload;
+        function Contains(const ItemArray: array of ICollectable): Boolean; overload;
+        function Contains(const Collection: ICollection): Boolean; overload;
+        function Equals(const Collection: ICollection): Boolean;
+        function Find(const Filter: IFilter): ICollectable; overload;
+        function Find(FilterFunc: TCollectionFilterFunc): ICollectable; overload;
+        function FindAll(const Filter: IFilter = nil): ICollection; overload;
+        function FindAll(FilterFunc: TCollectionFilterFunc): ICollection; overload;
+        function IsEmpty: Boolean;
+        function IsNaturalItem(const Item: ICollectable): Boolean;
+        function IsNilAllowed: Boolean;
+        function ItemAllowed(const Item: ICollectable): TCollectionError;
+        function ItemCount(const Item: ICollectable): Integer; overload;
+        function ItemCount(const ItemArray: array of ICollectable): Integer; overload;
+        function ItemCount(const Collection: ICollection): Integer; overload;
+        function Matching(const ItemArray: array of ICollectable): ICollection; overload;
+        function Matching(const Collection: ICollection): ICollection; overload;
+        function Remove(const Item: ICollectable): ICollectable; overload;
+        function Remove(const ItemArray: array of ICollectable): ICollection; overload;
+        function Remove(const Collection: ICollection): ICollection; overload;
+        function RemoveAll(const Item: ICollectable): ICollection; overload;
+        function RemoveAll(const ItemArray: array of ICollectable): ICollection; overload;
+        function RemoveAll(const Collection: ICollection): ICollection; overload;
+        function Retain(const ItemArray: array of ICollectable): ICollection; overload;
+        function Retain(const Collection: ICollection): ICollection; overload;
+        property AsArray: TCollectableArray read GetAsArray;
+        property Capacity: Integer read GetCapacity write SetCapacity;
+        property Comparator: IComparator read GetComparator write SetComparator;
+        property FixedSize: Boolean read GetFixedSize;
+        property IgnoreErrors: TCollectionErrors read GetIgnoreErrors write SetIgnoreErrors;
+        property NaturalItemIID: TGUID read GetNaturalItemIID;
+        property NaturalItemsOnly: Boolean read GetNaturalItemsOnly;
+        property Size: Integer read GetSize;
+    end;
+
+    IBag = interface(ICollection)
+        ['{C29C9560-2D59-11D7-8120-0002E3165EF8}']
+        function CloneAsBag: IBag;
+    end;
+
+    ISet = interface(ICollection)
+        ['{DD7888E2-0BB1-11D7-8120-0002E3165EF8}']
+        function CloneAsSet: ISet;
+        function Complement(const Universe: ISet): ISet;
+        function Intersect(const Set2: ISet): ISet;
+        function Union(const Set2: ISet): ISet;
+    end;
+
+    IList = interface(ICollection)
+        ['{EE81AB60-0B9F-11D7-8120-0002E3165EF8}']
+        function GetDuplicates: Boolean;
+        procedure SetDuplicates(Value: Boolean);
+        function GetItem(Index: Integer): ICollectable;
+        procedure SetItem(Index: Integer; const Item: ICollectable);
+        function GetSorted: Boolean;
+        procedure SetSorted(Value: Boolean);
+        function CloneAsList: IList;
+        function Delete(Index: Integer): ICollectable;
+        procedure Exchange(Index1, Index2: Integer);
+        function First: ICollectable;
+        function IndexOf(const Item: ICollectable): Integer;
+        function Insert(Index: Integer; const Item: ICollectable): Boolean; overload;
+        function Insert(Index: Integer; const ItemArray: array of ICollectable): Integer; overload;
+        function Insert(Index: Integer; const Collection: ICollection): Integer; overload;
+        function Last: ICollectable;
+        procedure Sort(const Comparator: IComparator); overload;
+        procedure Sort(CompareFunc: TCollectionCompareFunc); overload;
+        property Duplicates: Boolean read GetDuplicates write SetDuplicates;
+        property Items[Index: Integer]: ICollectable read GetItem write SetItem; default;
+        property Sorted: Boolean read GetSorted write SetSorted;
+    end;
+
+    IMap = interface(ICollection)
+        ['{AD458280-2A6B-11D7-8120-0002E3165EF8}']
+        function GetItem(const Key: ICollectable): ICollectable;
+        procedure SetItem(const Key, Item: ICollectable);
+        function GetKeyComparator: IComparator;
+        procedure SetKeyComparator(const Value: IComparator);
+        function GetKeyIterator: IIterator;
+        function GetKeys: ISet;
+        function GetMapIterator: IMapIterator;
+        function GetMapIteratorByKey(const Filter: IFilter): IMapIterator; overload;
+        function GetMapIteratorByKey(FilterFunc: TCollectionFilterFunc): IMapIterator; overload;
+        function GetNaturalKeyIID: TGUID;
+        function GetNaturalKeysOnly: Boolean;
+        function GetValues: ICollection;
+        function CloneAsMap: IMap;
+        function ContainsKey(const Key: ICollectable): Boolean; overload;
+        function ContainsKey(const KeyArray: array of ICollectable): Boolean; overload;
+        function ContainsKey(const Collection: ICollection): Boolean; overload;
+        function Get(const Key: ICollectable): ICollectable;
+        function IsNaturalKey(const Key: ICollectable): Boolean;
+        function KeyAllowed(const Key: ICollectable): TCollectionError;
+        function MatchingKey(const KeyArray: array of ICollectable): ICollection; overload;
+        function MatchingKey(const Collection: ICollection): ICollection; overload;
+        function Put(const Item: ICollectable): ICollectable; overload;
+        function Put(const Key, Item: ICollectable): ICollectable; overload;
+        function Put(const ItemArray: array of ICollectable): ICollection; overload;
+        function Put(const Collection: ICollection): ICollection; overload;
+        function Put(const Map: IMap): ICollection; overload;
+        function RemoveKey(const Key: ICollectable): ICollectable; overload;
+        function RemoveKey(const KeyArray: array of ICollectable): ICollection; overload;
+        function RemoveKey(const Collection: ICollection): ICollection; overload;
+        function RetainKey(const KeyArray: array of ICollectable): ICollection; overload;
+        function RetainKey(const Collection: ICollection): ICollection; overload;
+        property KeyComparator: IComparator read GetKeyComparator write SetKeyComparator;
+        property Items[const Key: ICollectable]: ICollectable read GetItem write SetItem; default;
+        property NaturalKeyIID: TGUID read GetNaturalKeyIID;
+        property NaturalKeysOnly: Boolean read GetNaturalKeysOnly;
+    end;
+
+    IIntegerMap = interface(ICollection)
+        ['{93DBA9A0-606C-11D7-8120-0002E3165EF8}']
+        function GetItem(const Key: Integer): ICollectable;
+        procedure SetItem(const Key: Integer; const Item: ICollectable);
+        function GetKeys: ISet;
+        function GetMapIterator: IIntegerMapIterator;
+        function GetValues: ICollection;
+        function CloneAsIntegerMap: IIntegerMap;
+        function ContainsKey(const Key: Integer): Boolean; overload;
+        function ContainsKey(const KeyArray: array of Integer): Boolean; overload;
+        function Get(const Key: Integer): ICollectable;
+        function Put(const Item: ICollectable): ICollectable; overload;
+        function Put(const Key: Integer; const Item: ICollectable): ICollectable; overload;
+        function Put(const ItemArray: array of ICollectable): ICollection; overload;
+        function Put(const Collection: ICollection): ICollection; overload;
+        function Put(const Map: IIntegerMap): ICollection; overload;
+        function RemoveKey(const Key: Integer): ICollectable; overload;
+        function RemoveKey(const KeyArray: array of Integer): ICollection; overload;
+        function RetainKey(const KeyArray: array of Integer): ICollection; overload;
+        property Items[const Key: Integer]: ICollectable read GetItem write SetItem; default;
+    end;
+
+    IStringMap = interface(ICollection)
+        ['{20531A20-5F92-11D7-8120-0002E3165EF8}']
+        function GetItem(const Key: String): ICollectable;
+        procedure SetItem(const Key: String; const Item: ICollectable);
+        function GetKeys: ISet;
+        function GetMapIterator: IStringMapIterator;
+        function GetValues: ICollection;
+        function CloneAsStringMap: IStringMap;
+        function ContainsKey(const Key: String): Boolean; overload;
+        function ContainsKey(const KeyArray: array of String): Boolean; overload;
+        function Get(const Key: String): ICollectable;
+        function Put(const Item: ICollectable): ICollectable; overload;
+        function Put(const Key: String; const Item: ICollectable): ICollectable; overload;
+        function Put(const ItemArray: array of ICollectable): ICollection; overload;
+        function Put(const Collection: ICollection): ICollection; overload;
+        function Put(const Map: IStringMap): ICollection; overload;
+        function RemoveKey(const Key: String): ICollectable; overload;
+        function RemoveKey(const KeyArray: array of String): ICollection; overload;
+        function RetainKey(const KeyArray: array of String): ICollection; overload;
+        property Items[const Key: String]: ICollectable read GetItem write SetItem; default;
+    end;
+
+    TCollectionPosition = class
+    private
+        FFound: Boolean;
+    public
+        constructor Create(Found: Boolean);
+        property Found: Boolean read FFound;
+    end;
+
+    TAbstractComparator = class(TInterfacedObject, IComparator)
+    public
+        class function GetDefaultComparator: IComparator;
+        class function GetNaturalComparator: IComparator;
+        class function GetReverseNaturalComparator: IComparator;
+        function GetInstance: TObject;
+        function Compare(const Item1, Item2: ICollectable): Integer; virtual; abstract;
+        function Equals(const Item1, Item2: ICollectable): Boolean; overload; virtual; abstract;
+        function Equals(const Comparator: IComparator): Boolean; overload; virtual;
+    end;
+
+    TDefaultComparator = class(TAbstractComparator)
+    protected
+        constructor Create;
+    public
+        function Compare(const Item1, Item2: ICollectable): Integer; override;
+        function Equals(const Item1, Item2: ICollectable): Boolean; override;
+    end;
+
+    TNaturalComparator = class(TAbstractComparator)
+    protected
+        constructor Create;
+    public
+        function Compare(const Item1, Item2: ICollectable): Integer; override;
+        function Equals(const Item1, Item2: ICollectable): Boolean; override;
+    end;
+
+    TReverseNaturalComparator = class(TAbstractComparator)
+    protected
+        constructor Create;
+    public
+        function Compare(const Item1, Item2: ICollectable): Integer; override;
+        function Equals(const Item1, Item2: ICollectable): Boolean; override;
+    end;
+
+    TAssociation = class(TInterfacedObject, ICollectable, IAssociation)
+    private
+        FKey: ICollectable;
+        FValue: ICollectable;
+    public
+        constructor Create(const Key, Value: ICollectable); virtual;
+        destructor Destroy; override;
+        function GetInstance: TObject; virtual;
+        function GetKey: ICollectable;
+        function GetValue: ICollectable;
+    end;
+
+    TIntegerAssociation = class(TInterfacedObject, ICollectable, IIntegerAssociation)
+    private
+        FKey: Integer;
+        FValue: ICollectable;
+    public
+        constructor Create(const Key: Integer; const Value: ICollectable); virtual;
+        destructor Destroy; override;
+        function GetInstance: TObject; virtual;
+        function GetKey: Integer;
+        function GetValue: ICollectable;
+    end;
+
+    TStringAssociation = class(TInterfacedObject, ICollectable, IStringAssociation)
+    private
+        FKey: String;
+        FValue: ICollectable;
+    public
+        constructor Create(const Key: String; const Value: ICollectable); virtual;
+        destructor Destroy; override;
+        function GetInstance: TObject; virtual;
+        function GetKey: String;
+        function GetValue: ICollectable;
+    end;
+
+    TAssociationComparator = class(TAbstractComparator, IAssociationComparator)
+    private
+        FKeyComparator: IComparator;
+    public
+        constructor Create(NaturalKeys: Boolean = false);
+        destructor Destroy; override;
+        function GetKeyComparator: IComparator;
+        procedure SetKeyComparator(Value: IComparator);
+        function Compare(const Item1, Item2: ICollectable): Integer; override;
+        function Equals(const Item1, Item2: ICollectable): Boolean; override;
+        property KeyComparator: IComparator read GetKeyComparator write SetKeyComparator;
+    end;
+
+    TIntegerAssociationComparator = class(TAbstractComparator, IIntegerAssociationComparator)
+    public
+        constructor Create;
+        destructor Destroy; override;
+        function Compare(const Item1, Item2: ICollectable): Integer; override;
+        function Equals(const Item1, Item2: ICollectable): Boolean; override;
+    end;
+
+    TStringAssociationComparator = class(TAbstractComparator, IStringAssociationComparator)
+    public
+        constructor Create;
+        destructor Destroy; override;
+        function Compare(const Item1, Item2: ICollectable): Integer; override;
+        function Equals(const Item1, Item2: ICollectable): Boolean; override;
+    end;
+
+
+
+    TAbstractCollection = class(TInterfacedObject, ICollection)
+    private
+        FCreated: Boolean;          // Required to avoid passing destroyed object reference to exception
+        FComparator: IComparator;
+        FIgnoreErrors: TCollectionErrors;
+        FNaturalItemsOnly: Boolean;
+    protected
+        procedure CollectionError(ErrorType: TCollectionError);
+        procedure InitFrom(const Collection: ICollection); overload; virtual;
+        function TrueAdd(const Item: ICollectable): Boolean; virtual; abstract;
+        procedure TrueClear; virtual; abstract;
+        function TrueContains(const Item: ICollectable): Boolean; virtual; abstract;
+        function TrueItemCount(const Item: ICollectable): Integer; virtual;
+        function TrueRemove(const Item: ICollectable): ICollectable; virtual; abstract;
+        function TrueRemoveAll(const Item: ICollectable): ICollection; virtual; abstract;
+    public
+        constructor Create; overload; virtual;
+        constructor Create(NaturalItemsOnly: Boolean); overload; virtual;
+        constructor Create(const ItemArray: array of ICollectable); overload; virtual;
+        constructor Create(const ItemArray: array of ICollectable; NaturalItemsOnly: Boolean); overload; virtual;
+        constructor Create(const Collection: ICollection); overload; virtual;
+        destructor Destroy; override;
+        class function GetAlwaysNaturalItems: Boolean; virtual;
+        function GetAsArray: TCollectableArray; virtual;
+        function GetCapacity: Integer; virtual; abstract;
+        procedure SetCapacity(Value: Integer); virtual; abstract;
+        function GetComparator: IComparator; virtual;
+        procedure SetComparator(const Value: IComparator); virtual;
+        function GetDuplicates: Boolean; virtual;
+        function GetFixedSize: Boolean; virtual;
+        function GetIgnoreErrors: TCollectionErrors;
+        procedure SetIgnoreErrors(Value: TCollectionErrors);
+        function GetInstance: TObject;
+        function GetIterator: IIterator; overload; virtual; abstract;
+        function GetIterator(const Filter: IFilter): IIterator; overload; virtual;
+        function GetIterator(FilterFunc: TCollectionFilterFunc): IIterator; overload; virtual;
+        function GetNaturalItemIID: TGUID; virtual; abstract;
+        function GetNaturalItemsOnly: Boolean; virtual;
+        function GetSize: Integer; virtual; abstract;
+        function GetType: TCollectionType; virtual; abstract;
+        function Add(const Item: ICollectable): Boolean; overload; virtual;
+        function Add(const ItemArray: array of ICollectable): Integer; overload; virtual;
+        function Add(const Collection: ICollection): Integer; overload; virtual;
+        procedure AfterConstruction; override;
+        procedure BeforeDestruction; override;
+        function Clear: Integer; virtual;
+        function Clone: ICollection; virtual;
+        function Contains(const Item: ICollectable): Boolean; overload; virtual;
+        function Contains(const ItemArray: array of ICollectable): Boolean; overload; virtual;
+        function Contains(const Collection: ICollection): Boolean; overload; virtual;
+        function Equals(const Collection: ICollection): Boolean; virtual;
+        function Find(const Filter: IFilter): ICollectable; overload; virtual;
+        function Find(FilterFunc: TCollectionFilterFunc): ICollectable; overload; virtual;
+        function FindAll(const Filter: IFilter): ICollection; overload; virtual;
+        function FindAll(FilterFunc: TCollectionFilterFunc): ICollection; overload; virtual;
+        function IsEmpty: Boolean; virtual;
+        function IsNaturalItem(const Item: ICollectable): Boolean; virtual;
+        function IsNilAllowed: Boolean; virtual; abstract;
+        function ItemAllowed(const Item: ICollectable): TCollectionError; virtual;
+        function ItemCount(const Item: ICollectable): Integer; overload; virtual;
+        function ItemCount(const ItemArray: array of ICollectable): Integer; overload; virtual;
+        function ItemCount(const Collection: ICollection): Integer; overload; virtual;
+        function Matching(const ItemArray: array of ICollectable): ICollection; overload; virtual;
+        function Matching(const Collection: ICollection): ICollection; overload; virtual;
+        function Remove(const Item: ICollectable): ICollectable; overload; virtual;
+        function Remove(const ItemArray: array of ICollectable): ICollection; overload; virtual;
+        function Remove(const Collection: ICollection): ICollection; overload; virtual;
+        function RemoveAll(const Item: ICollectable): ICollection; overload; virtual;
+        function RemoveAll(const ItemArray: array of ICollectable): ICollection; overload; virtual;
+        function RemoveAll(const Collection: ICollection): ICollection; overload; virtual;
+        function Retain(const ItemArray: array of ICollectable): ICollection; overload; virtual;
+        function Retain(const Collection: ICollection): ICollection; overload; virtual;
+        property AsArray: TCollectableArray read GetAsArray;
+        property Capacity: Integer read GetCapacity write SetCapacity;
+        property Comparator: IComparator read GetComparator write SetComparator;
+        property FixedSize: Boolean read GetFixedSize;
+        property IgnoreErrors: TCollectionErrors read GetIgnoreErrors write SetIgnoreErrors;
+        property NaturalItemIID: TGUID read GetNaturalItemIID;
+        property NaturalItemsOnly: Boolean read GetNaturalItemsOnly;
+        property Size: Integer read GetSize;
+    end;
+
+    TAbstractBag = class(TAbstractCollection, IBag)
+    public
+        function CloneAsBag: IBag; virtual;
+        function GetNaturalItemIID: TGUID; override;
+        function GetType: TCollectionType; override;
+        function IsNilAllowed: Boolean; override;
+    end;
+
+    TAbstractSet = class (TAbstractCollection, ISet)
+    protected
+        function GetPosition(const Item: ICollectable): TCollectionPosition; virtual; abstract;
+        function TrueAdd(const Item: ICollectable): Boolean; override;
+        procedure TrueAdd2(Position: TCollectionPosition; const Item: ICollectable); virtual; abstract;
+        function TrueContains(const Item: ICollectable): Boolean; override;
+        function TrueGet(Position: TCollectionPosition): ICollectable; virtual; abstract;
+        function TrueRemove(const Item: ICollectable): ICollectable; override;
+        procedure TrueRemove2(Position: TCollectionPosition); virtual; abstract;
+        function TrueRemoveAll(const Item: ICollectable): ICollection; override;
+    public
+        function GetDuplicates: Boolean; override;
+        function GetNaturalItemIID: TGUID; override;
+        function GetType: TCollectionType; override;
+        function CloneAsSet: ISet; virtual;
+        function Complement(const Universe: ISet): ISet; overload; virtual;
+        function Intersect(const Set2: ISet): ISet; overload; virtual;
+        function IsNilAllowed: Boolean; override;
+        function Union(const Set2: ISet): ISet; overload; virtual;
+    end;
+
+    TAbstractList = class(TAbstractCollection, IList)
+    private
+        FDuplicates: Boolean;
+        FSorted: Boolean;
+    protected
+        function BinarySearch(const Item: ICollectable): TSearchResult; virtual;
+        procedure InitFrom(const Collection: ICollection); override;
+        procedure QuickSort(Lo, Hi: Integer; const Comparator: IComparator); overload; virtual;
+        procedure QuickSort(Lo, Hi: Integer; CompareFunc: TCollectionCompareFunc); overload; virtual;
+        function SequentialSearch(const Item: ICollectable; const SearchComparator: IComparator = nil): TSearchResult; virtual;
+        function TrueContains(const Item: ICollectable): Boolean; override;
+        function TrueGetItem(Index: Integer): ICollectable; virtual; abstract;
+        procedure TrueSetItem(Index: Integer; const Item: ICollectable); virtual; abstract;
+        function TrueAdd(const Item: ICollectable): Boolean; override;
+        procedure TrueAppend(const Item: ICollectable); virtual; abstract;
+        function TrueDelete(Index: Integer): ICollectable; virtual; abstract;
+        procedure TrueInsert(Index: Integer; const Item: ICollectable); virtual; abstract;
+        function TrueItemCount(const Item: ICollectable): Integer; override;
+        function TrueRemove(const Item: ICollectable): ICollectable; override;
+        function TrueRemoveAll(const Item: ICollectable): ICollection; override;
+    public
+        constructor Create(NaturalItemsOnly: Boolean); override;
+        function GetDuplicates: Boolean; override;
+        procedure SetDuplicates(Value: Boolean); virtual;
+        function GetItem(Index: Integer): ICollectable; virtual;
+        procedure SetItem(Index: Integer; const Item: ICollectable); virtual;
+        function GetIterator: IIterator; override;
+        function GetNaturalItemIID: TGUID; override;
+        function GetSorted: Boolean; virtual;
+        procedure SetSorted(Value: Boolean); virtual;
+        function GetType: TCollectionType; override;
+        function CloneAsList: IList; virtual;
+        function Delete(Index: Integer): ICollectable; virtual;
+        procedure Exchange(Index1, Index2: Integer); virtual;
+        function First: ICollectable; virtual;
+        function IndexOf(const Item: ICollectable): Integer; virtual;
+        function Insert(Index: Integer; const Item: ICollectable): Boolean; overload; virtual;
+        function Insert(Index: Integer; const ItemArray: array of ICollectable): Integer; overload; virtual;
+        function Insert(Index: Integer; const Collection: ICollection): Integer; overload; virtual;
+        function IsNilAllowed: Boolean; override;
+        function Last: ICollectable; virtual;
+        function Search(const Item: ICollectable; const SearchComparator: IComparator = nil): TSearchResult; virtual;
+        procedure Sort(const SortComparator: IComparator = nil); overload; virtual;
+        procedure Sort(CompareFunc: TCollectionCompareFunc); overload; virtual;
+        property Duplicates: Boolean read GetDuplicates write SetDuplicates;
+        property Items[Index: Integer]: ICollectable read GetItem write SetItem; default;
+        property Sorted: Boolean read GetSorted write SetSorted;
+    end;
+
+    TAbstractMap = class(TAbstractCollection, IMap)
+    private
+        FAssociationComparator: IAssociationComparator;
+        FKeyComparator: IComparator;
+        FNaturalKeysOnly: Boolean;
+    protected
+        function GetAssociationIterator: IMapIterator; virtual; abstract;
+        function GetKeyPosition(const Key: ICollectable): TCollectionPosition; virtual; abstract;
+        procedure InitFrom(const Collection: ICollection); override;
+        function TrueAdd(const Item: ICollectable): Boolean; override;
+        function TrueContains(const Item: ICollectable): Boolean; override;
+        function TrueGet(Position: TCollectionPosition): IAssociation; virtual; abstract;
+        function TruePut(Position: TCollectionPosition; const Association: IAssociation): IAssociation; virtual; abstract;
+        function TrueRemove(const Item: ICollectable): ICollectable; override;
+        function TrueRemove2(Position: TCollectionPosition): IAssociation; virtual; abstract;
+        function TrueRemoveAll(const Item: ICollectable): ICollection; override;
+        property AssociationComparator: IAssociationComparator read FAssociationComparator;
+    public
+        constructor Create; override;
+        constructor Create(NaturalItemsOnly: Boolean); override;
+        constructor Create(NaturalItemsOnly: Boolean; NaturalKeysOnly: Boolean); overload; virtual;
+        constructor Create(const ItemArray: array of ICollectable); overload; override;
+        constructor Create(const ItemArray: array of ICollectable; NaturalItemsOnly: Boolean); overload; override;
+        constructor Create(const ItemArray: array of ICollectable; NaturalItemsOnly: Boolean; NaturalKeysOnly: Boolean); overload; virtual;
+        constructor Create(const KeyArray, ItemArray: array of ICollectable); overload; virtual;
+        constructor Create(const KeyArray, ItemArray: array of ICollectable; NaturalItemsOnly: Boolean); overload; virtual;
+        constructor Create(const KeyArray, ItemArray: array of ICollectable; NaturalItemsOnly: Boolean; NaturalKeysOnly: Boolean); overload; virtual;
+//      Don't use this parameter signature as it hits a compiler bug in D5.
+//        constructor Create(const KeyArray, ItemArray: TCollectableArray; NaturalItemsOnly: Boolean = false; NaturalKeysOnly: Boolean = true); overload; virtual;
+        constructor Create(const Map: IMap); overload; virtual;
+        destructor Destroy; override;
+        class function GetAlwaysNaturalKeys: Boolean; virtual;
+        function GetItem(const Key: ICollectable): ICollectable; virtual;
+        procedure SetItem(const Key, Item: ICollectable); virtual;
+        function GetIterator: IIterator; override;
+        function GetKeyComparator: IComparator; virtual;
+        procedure SetKeyComparator(const Value: IComparator); virtual;
+        function GetKeyIterator: IIterator; virtual;
+        function GetKeys: ISet; virtual;
+        function GetMapIterator: IMapIterator; virtual;
+        function GetMapIteratorByKey(const Filter: IFilter): IMapIterator; overload; virtual;
+        function GetMapIteratorByKey(FilterFunc: TCollectionFilterFunc): IMapIterator; overload; virtual;
+        function GetNaturalItemIID: TGUID; override;
+        function GetNaturalKeyIID: TGUID; virtual;
+        function GetNaturalKeysOnly: Boolean; virtual;
+        function GetType: TCollectionType; override;
+        function GetValues: ICollection; virtual;
+        function Clone: ICollection; override;
+        function CloneAsMap: IMap; virtual;
+        function ContainsKey(const Key: ICollectable): Boolean; overload; virtual;
+        function ContainsKey(const KeyArray: array of ICollectable): Boolean; overload; virtual;
+        function ContainsKey(const Collection: ICollection): Boolean; overload; virtual;
+        function Get(const Key: ICollectable): ICollectable; virtual;
+        function KeyAllowed(const Key: ICollectable): TCollectionError; virtual;
+        function IsNaturalKey(const Key: ICollectable): Boolean; virtual;
+        function IsNilAllowed: Boolean; override;
+        function MatchingKey(const KeyArray: array of ICollectable): ICollection; overload; virtual;
+        function MatchingKey(const Collection: ICollection): ICollection; overload; virtual;
+        function Put(const Item: ICollectable): ICollectable; overload; virtual;
+        function Put(const Key, Item: ICollectable): ICollectable; overload; virtual;
+        function Put(const ItemArray: array of ICollectable): ICollection; overload; virtual;
+        function Put(const Collection: ICollection): ICollection; overload; virtual;
+        function Put(const Map: IMap): ICollection; overload; virtual;
+        function RemoveKey(const Key: ICollectable): ICollectable; overload; virtual;
+        function RemoveKey(const KeyArray: array of ICollectable): ICollection; overload; virtual;
+        function RemoveKey(const Collection: ICollection): ICollection; overload; virtual;
+        function RetainKey(const KeyArray: array of ICollectable): ICollection; overload; virtual;
+        function RetainKey(const Collection: ICollection): ICollection; overload; virtual;
+        property KeyComparator: IComparator read GetKeyComparator write SetKeyComparator;
+        property Items[const Key: ICollectable]: ICollectable read GetItem write SetItem; default;
+        property NaturalKeyIID: TGUID read GetNaturalKeyIID;
+        property NaturalKeysOnly: Boolean read GetNaturalKeysOnly;
+    end;
+
+    TAbstractIntegerMap = class(TAbstractCollection, IIntegerMap)
+    private
+        FAssociationComparator: IIntegerAssociationComparator;
+    protected
+        function GetAssociationIterator: IIntegerMapIterator; virtual; abstract;
+        function GetKeyPosition(const Key: Integer): TCollectionPosition; virtual; abstract;
+        function TrueAdd(const Item: ICollectable): Boolean; override;
+        function TrueContains(const Item: ICollectable): Boolean; override;
+        function TrueGet(Position: TCollectionPosition): IIntegerAssociation; virtual; abstract;
+        function TruePut(Position: TCollectionPosition; const Association: IIntegerAssociation): IIntegerAssociation; virtual; abstract;
+        function TrueRemove(const Item: ICollectable): ICollectable; override;
+        function TrueRemove2(Position: TCollectionPosition): IIntegerAssociation; virtual; abstract;
+        function TrueRemoveAll(const Item: ICollectable): ICollection; override;
+        property AssociationComparator: IIntegerAssociationComparator read FAssociationComparator;
+    public
+        constructor Create(NaturalItemsOnly: Boolean); override;
+        constructor Create(const ItemArray: array of ICollectable); overload; override;
+        constructor Create(const ItemArray: array of ICollectable; NaturalItemsOnly: Boolean); overload; override;
+        constructor Create(const KeyArray: array of Integer; const ItemArray: array of ICollectable); overload; virtual;
+        constructor Create(const KeyArray: array of Integer; const ItemArray: array of ICollectable; NaturalItemsOnly: Boolean); overload; virtual;
+        constructor Create(const Map: IIntegerMap); overload; virtual;
+        destructor Destroy; override;
+        function GetItem(const Key: Integer): ICollectable; virtual;
+        procedure SetItem(const Key: Integer; const Item: ICollectable); virtual;
+        function GetIterator: IIterator; override;
+        function GetKeys: ISet; virtual;
+        function GetMapIterator: IIntegerMapIterator; virtual;
+        function GetNaturalItemIID: TGUID; override;
+        function GetType: TCollectionType; override;
+        function GetValues: ICollection; virtual;
+        function Clone: ICollection; override;
+        function CloneAsIntegerMap: IIntegerMap; virtual;
+        function ContainsKey(const Key: Integer): Boolean; overload; virtual;
+        function ContainsKey(const KeyArray: array of Integer): Boolean; overload; virtual;
+        function Get(const Key: Integer): ICollectable; virtual;
+        function IsNilAllowed: Boolean; override;
+        function Put(const Item: ICollectable): ICollectable; overload; virtual;
+        function Put(const Key: Integer; const Item: ICollectable): ICollectable; overload; virtual;
+        function Put(const ItemArray: array of ICollectable): ICollection; overload; virtual;
+        function Put(const Collection: ICollection): ICollection; overload; virtual;
+        function Put(const Map: IIntegerMap): ICollection; overload; virtual;
+        function RemoveKey(const Key: Integer): ICollectable; overload; virtual;
+        function RemoveKey(const KeyArray: array of Integer): ICollection; overload; virtual;
+        function RetainKey(const KeyArray: array of Integer): ICollection; overload; virtual;
+        property Items[const Key: Integer]: ICollectable read GetItem write SetItem; default;
+    end;
+
+    TAbstractStringMap = class(TAbstractCollection, IStringMap)
+    private
+        FAssociationComparator: IStringAssociationComparator;
+    protected
+        function GetAssociationIterator: IStringMapIterator; virtual; abstract;
+        function GetKeyPosition(const Key: String): TCollectionPosition; virtual; abstract;
+        function TrueAdd(const Item: ICollectable): Boolean; override;
+        function TrueContains(const Item: ICollectable): Boolean; override;
+        function TrueGet(Position: TCollectionPosition): IStringAssociation; virtual; abstract;
+        function TruePut(Position: TCollectionPosition; const Association: IStringAssociation): IStringAssociation; virtual; abstract;
+        function TrueRemove(const Item: ICollectable): ICollectable; override;
+        function TrueRemove2(Position: TCollectionPosition): IStringAssociation; virtual; abstract;
+        function TrueRemoveAll(const Item: ICollectable): ICollection; override;
+        property AssociationComparator: IStringAssociationComparator read FAssociationComparator;
+    public
+        constructor Create(NaturalItemsOnly: Boolean); override;
+        constructor Create(const ItemArray: array of ICollectable); overload; override;
+        constructor Create(const ItemArray: array of ICollectable; NaturalItemsOnly: Boolean); overload; override;
+        constructor Create(const KeyArray: array of String; const ItemArray: array of ICollectable); overload; virtual;
+        constructor Create(const KeyArray: array of String; const ItemArray: array of ICollectable; NaturalItemsOnly: Boolean); overload; virtual;
+        constructor Create(const Map: IStringMap); overload; virtual;
+        destructor Destroy; override;
+        function GetItem(const Key: String): ICollectable; virtual;
+        procedure SetItem(const Key: String; const Item: ICollectable); virtual;
+        function GetIterator: IIterator; override;
+        function GetKeys: ISet; virtual;
+        function GetMapIterator: IStringMapIterator; virtual;
+        function GetNaturalItemIID: TGUID; override;
+        function GetType: TCollectionType; override;
+        function GetValues: ICollection; virtual;
+        function Clone: ICollection; override;
+        function CloneAsStringMap: IStringMap; virtual;
+        function ContainsKey(const Key: String): Boolean; overload; virtual;
+        function ContainsKey(const KeyArray: array of String): Boolean; overload; virtual;
+        function Get(const Key: String): ICollectable; virtual;
+        function IsNilAllowed: Boolean; override;
+        function Put(const Item: ICollectable): ICollectable; overload; virtual;
+        function Put(const Key: String; const Item: ICollectable): ICollectable; overload; virtual;
+        function Put(const ItemArray: array of ICollectable): ICollection; overload; virtual;
+        function Put(const Collection: ICollection): ICollection; overload; virtual;
+        function Put(const Map: IStringMap): ICollection; overload; virtual;
+        function RemoveKey(const Key: String): ICollectable; overload; virtual;
+        function RemoveKey(const KeyArray: array of String): ICollection; overload; virtual;
+        function RetainKey(const KeyArray: array of String): ICollection; overload; virtual;
+        property Items[const Key: String]: ICollectable read GetItem write SetItem; default;
+    end;
+
+    TAbstractCollectionClass = class of TAbstractCollection;
+    TAbstractBagClass = class of TAbstractBag;
+    TAbstractSetClass = class of TAbstractSet;
+    TAbstractListClass = class of TAbstractList;
+    TAbstractMapClass = class of TAbstractMap;
+    TAbstractIntegerMapClass = class of TAbstractIntegerMap;
+    TAbstractStringMapClass = class of TAbstractStringMap;
+
+    TAbstractIterator = class(TInterfacedObject, IIterator)
+    private
+        FAllowRemoval: Boolean;
+        FEOF: Boolean;
+        FItem: ICollectable;
+    protected
+        constructor Create(AllowRemoval: Boolean = true);
+        function TrueFirst: ICollectable; virtual; abstract;
+        function TrueNext: ICollectable; virtual; abstract;
+        procedure TrueRemove; virtual; abstract;
+    public
+        procedure AfterConstruction; override;
+        function GetAllowRemoval: Boolean; virtual;
+        function CurrentItem: ICollectable; virtual;
+        function EOF: Boolean; virtual;
+        function First: ICollectable; virtual;
+        function Next: ICollectable; virtual;
+        function Remove: Boolean; virtual;
+        property AllowRemoval: Boolean read GetAllowRemoval;
+    end;
+
+    TAbstractListIterator = class(TAbstractIterator)
+    private
+        FCollection: TAbstractList;
+        FIndex: Integer;
+    protected
+        constructor Create(Collection: TAbstractList);
+        function TrueFirst: ICollectable; override;
+        function TrueNext: ICollectable; override;
+        procedure TrueRemove; override;
+    end;
+
+    TAbstractMapIterator = class(TAbstractIterator, IMapIterator)
+    public
+        function CurrentKey: ICollectable; virtual; abstract;
+    end;
+
+    TAbstractAssociationIterator = class(TInterfacedObject, IIterator, IMapIterator)
+    private
+        FAllowRemoval: Boolean;
+        FEOF: Boolean;
+        FAssociation: IAssociation;
+    protected
+        constructor Create(AllowRemoval: Boolean = true);
+        function TrueFirst: IAssociation; virtual; abstract;
+        function TrueNext: IAssociation; virtual; abstract;
+        procedure TrueRemove; virtual; abstract;
+    public
+        procedure AfterConstruction; override;
+        function GetAllowRemoval: Boolean; virtual;
+        function CurrentKey: ICollectable; virtual;
+        function CurrentItem: ICollectable; virtual;
+        function EOF: Boolean; virtual;
+        function First: ICollectable; virtual;
+        function Next: ICollectable; virtual;
+        function Remove: Boolean; virtual;
+        property AllowRemoval: Boolean read GetAllowRemoval;
+    end;
+
+    TAbstractIntegerAssociationIterator = class(TInterfacedObject, IIterator, IIntegerMapIterator)
+    private
+        FAllowRemoval: Boolean;
+        FEOF: Boolean;
+        FAssociation: IIntegerAssociation;
+    protected
+        constructor Create(AllowRemoval: Boolean = true);
+        function TrueFirst: IIntegerAssociation; virtual; abstract;
+        function TrueNext: IIntegerAssociation; virtual; abstract;
+        procedure TrueRemove; virtual; abstract;
+    public
+        procedure AfterConstruction; override;
+        function GetAllowRemoval: Boolean; virtual;
+        function CurrentKey: Integer; virtual;
+        function CurrentItem: ICollectable; virtual;
+        function EOF: Boolean; virtual;
+        function First: ICollectable; virtual;
+        function Next: ICollectable; virtual;
+        function Remove: Boolean; virtual;
+        property AllowRemoval: Boolean read GetAllowRemoval;
+    end;
+
+    TAbstractStringAssociationIterator = class(TInterfacedObject, IIterator, IStringMapIterator)
+    private
+        FAllowRemoval: Boolean;
+        FEOF: Boolean;
+        FAssociation: IStringAssociation;
+    protected
+        constructor Create(AllowRemoval: Boolean = true);
+        function TrueFirst: IStringAssociation; virtual; abstract;
+        function TrueNext: IStringAssociation; virtual; abstract;
+        procedure TrueRemove; virtual; abstract;
+    public
+        procedure AfterConstruction; override;
+        function GetAllowRemoval: Boolean; virtual;
+        function CurrentKey: String; virtual;
+        function CurrentItem: ICollectable; virtual;
+        function EOF: Boolean; virtual;
+        function First: ICollectable; virtual;
+        function Next: ICollectable; virtual;
+        function Remove: Boolean; virtual;
+        property AllowRemoval: Boolean read GetAllowRemoval;
+    end;
+
+    TAssociationIterator = class(TAbstractIterator, IMapIterator)
+    private
+        FIterator: IIterator;
+    protected
+        function TrueFirst: ICollectable; override;
+        function TrueNext: ICollectable; override;
+        procedure TrueRemove; override;
+    public
+        constructor Create(const Iterator: IIterator);
+        destructor Destroy; override;
+        function CurrentItem: ICollectable; override;
+        function CurrentKey: ICollectable; virtual;
+    end;
+
+    TAssociationKeyIterator = class(TAbstractIterator)
+    private
+        FIterator: IMapIterator;
+    protected
+        function TrueFirst: ICollectable; override;
+        function TrueNext: ICollectable; override;
+        procedure TrueRemove; override;
+    public
+        constructor Create(const Iterator: IMapIterator);
+        destructor Destroy; override;
+    end;
+
+    TAbstractFilter = class(TInterfacedObject, IFilter)
+    public
+        function Accept(const Item: ICollectable): Boolean; virtual; abstract;
+    end;
+
+    TFilterIterator = class(TAbstractIterator)
+    private
+        FIterator: IIterator;
+        FFilter: IFilter;
+    protected
+        function TrueFirst: ICollectable; override;
+        function TrueNext: ICollectable; override;
+        procedure TrueRemove; override;
+    public
+        constructor Create(const Iterator: IIterator; const Filter: IFilter; AllowRemoval: Boolean = true); virtual;
+        destructor Destroy; override;
+    end;
+
+    TFilterFuncIterator = class(TAbstractIterator)
+    private
+        FIterator: IIterator;
+        FFilterFunc: TCollectionFilterFunc;
+    protected
+        function TrueFirst: ICollectable; override;
+        function TrueNext: ICollectable; override;
+        procedure TrueRemove; override;
+    public
+        constructor Create(const Iterator: IIterator; FilterFunc: TCollectionFilterFunc; AllowRemoval: Boolean = true); virtual;
+        destructor Destroy; override;
+    end;
+
+    TKeyFilterMapIterator = class(TAbstractMapIterator)
+    private
+        FIterator: IMapIterator;
+        FFilter: IFilter;
+    protected
+        function TrueFirst: ICollectable; override;
+        function TrueNext: ICollectable; override;
+        procedure TrueRemove; override;
+    public
+        constructor Create(const Iterator: IMapIterator; const Filter: IFilter; AllowRemoval: Boolean = true); virtual;
+        destructor Destroy; override;
+        function CurrentKey: ICollectable; override;
+    end;
+
+    TKeyFilterFuncMapIterator = class(TAbstractMapIterator)
+    private
+        FIterator: IMapIterator;
+        FFilterFunc: TCollectionFilterFunc;
+    protected
+        function TrueFirst: ICollectable; override;
+        function TrueNext: ICollectable; override;
+        procedure TrueRemove; override;
+    public
+        constructor Create(const Iterator: IMapIterator; FilterFunc: TCollectionFilterFunc; AllowRemoval: Boolean = true); virtual;
+        destructor Destroy; override;
+        function CurrentKey: ICollectable; override;
+    end;
+
+
+    ECollectionError = class(Exception)
+    private
+        FCollection: ICollection;
+        FErrorType: TCollectionError;
+    public
+        constructor Create(const Msg: String; const Collection: ICollection; ErrorType: TCollectionError);
+        property Collection: ICollection read FCollection;
+        property ErrorType: TCollectionError read FErrorType;
+    end;
+
+implementation
+
+uses
+    Math,
+    CollArray, CollHash, CollList, CollPArray, CollWrappers;
+
+var
+    FDefaultComparator: IComparator;
+    FNaturalComparator: IComparator;
+    FReverseNaturalComparator: IComparator;
+
+{ TCollectionPosition }
+constructor TCollectionPosition.Create(Found: Boolean);
+begin
+    FFound := Found;
+end;
+
+{ TAbstractComparator }
+class function TAbstractComparator.GetDefaultComparator: IComparator;
+begin
+    if FDefaultComparator = nil then
+        FDefaultComparator := TDefaultComparator.Create;
+    Result := FDefaultComparator;
+end;
+
+class function TAbstractComparator.GetNaturalComparator: IComparator;
+begin
+    if FNaturalComparator = nil then
+        FNaturalComparator := TNaturalComparator.Create;
+    Result := FNaturalComparator;
+end;
+
+class function TAbstractComparator.GetReverseNaturalComparator: IComparator;
+begin
+    if FReverseNaturalComparator = nil then
+        FReverseNaturalComparator := TReverseNaturalComparator.Create;
+    Result := FReverseNaturalComparator;
+end;
+
+function TAbstractComparator.GetInstance: TObject;
+begin
+    Result := Self;
+end;
+
+function TAbstractComparator.Equals(const Comparator: IComparator): Boolean;
+begin
+    Result := (Self = Comparator.GetInstance); 
+end;
+
+{ TDefaultComparator }
+constructor TDefaultComparator.Create;
+begin
+    // Empty
+end;
+
+function TDefaultComparator.Compare(const Item1, Item2: ICollectable): Integer;
+var
+    Value1, Value2: Integer;
+begin
+    if Item1 <> nil then
+        Value1 := Integer(Pointer(Item1))
+    else
+        Value1 := Low(Integer);
+    if Item2 <> nil then
+        Value2 := Integer(Pointer(Item2))
+    else
+        Value2 := Low(Integer);
+    if (Value1 < Value2) then
+        Result := -1
+    else if (Value1 > Value2) then
+        Result := 1
+    else
+        Result := 0;
+end;
+
+function TDefaultComparator.Equals(const Item1, Item2: ICollectable): Boolean;
+begin
+    Result := (Item1 = Item2);
+end;
+
+{ TNaturalComparator }
+constructor TNaturalComparator.Create;
+begin
+    // Empty
+end;
+
+function TNaturalComparator.Compare(const Item1, Item2: ICollectable): Integer;
+begin
+    if (Item1 = nil) and (Item2 <> nil) then
+        Result := -1
+    else if (Item1 <> nil) and (Item2 = nil) then
+        Result := 1
+    else if (Item1 = nil) and (Item2 = nil) then
+        Result := 0
+    else
+        Result := (Item1 as IComparable).CompareTo(Item2);
+end;
+
+function TNaturalComparator.Equals(const Item1, Item2: ICollectable): Boolean;
+begin
+    if (Item1 = nil) or (Item2 = nil) then
+        Result := (Item1 = Item2)
+    else
+    begin
+        Result := (Item1 as IEquatable).Equals(Item2);
+    end;
+end;
+
+{ TReverseNaturalComparator }
+constructor TReverseNaturalComparator.Create;
+begin
+    // Empty
+end;
+
+function TReverseNaturalComparator.Compare(const Item1, Item2: ICollectable): Integer;
+begin
+    if (Item1 = nil) and (Item2 <> nil) then
+        Result := 1
+    else if (Item1 <> nil) and (Item2 = nil) then
+        Result := -1
+    else if (Item1 = nil) and (Item2 = nil) then
+        Result := 0
+    else
+        Result := -(Item1 as IComparable).CompareTo(Item2);
+end;
+
+function TReverseNaturalComparator.Equals(const Item1, Item2: ICollectable): Boolean;
+begin
+    if (Item1 = nil) or (Item2 = nil) then
+        Result := (Item1 = Item2)
+    else
+        Result := (Item1 as IEquatable).Equals(Item2);
+end;
+
+{ TAssociation }
+constructor TAssociation.Create(const Key, Value: ICollectable);
+begin
+    FKey := Key;
+    FValue := Value;
+end;
+
+destructor TAssociation.Destroy;
+begin
+    FKey := nil;
+    FValue := nil;
+    inherited Destroy;
+end;
+
+function TAssociation.GetInstance: TObject;
+begin
+    Result := Self;
+end;
+
+function TAssociation.GetKey: ICollectable;
+begin
+    Result := FKey;
+end;
+
+function TAssociation.GetValue: ICollectable;
+begin
+    Result := FValue;
+end;
+
+
+{ TIntegerAssociation }
+constructor TIntegerAssociation.Create(const Key: Integer; const Value: ICollectable);
+begin
+    FKey := Key;
+    FValue := Value;
+end;
+
+destructor TIntegerAssociation.Destroy;
+begin
+    FValue := nil;
+    inherited Destroy;
+end;
+
+function TIntegerAssociation.GetInstance: TObject;
+begin
+    Result := Self;
+end;
+
+function TIntegerAssociation.GetKey: Integer;
+begin
+    Result := FKey;
+end;
+
+function TIntegerAssociation.GetValue: ICollectable;
+begin
+    Result := FValue;
+end;
+
+
+{ TStringAssociation }
+constructor TStringAssociation.Create(const Key: String; const Value: ICollectable);
+begin
+    FKey := Key;
+    FValue := Value;
+end;
+
+destructor TStringAssociation.Destroy;
+begin
+    FValue := nil;
+    inherited Destroy;
+end;
+
+function TStringAssociation.GetInstance: TObject;
+begin
+    Result := Self;
+end;
+
+function TStringAssociation.GetKey: String;
+begin
+    Result := FKey;
+end;
+
+function TStringAssociation.GetValue: ICollectable;
+begin
+    Result := FValue;
+end;
+
+
+{ TAbstractIterator }
+constructor TAbstractIterator.Create(AllowRemoval: Boolean);
+begin
+    inherited Create;
+    FAllowRemoval := AllowRemoval;
+    FEOF := true;
+    FItem := nil;
+end;
+
+procedure TAbstractIterator.AfterConstruction;
+begin
+    inherited AfterConstruction;
+    First;
+end;
+
+function TAbstractIterator.GetAllowRemoval: Boolean;
+begin
+    Result := FAllowRemoval;
+end;
+
+function TAbstractIterator.CurrentItem: ICollectable;
+begin
+    Result := FItem;
+end;
+
+function TAbstractIterator.EOF: Boolean;
+begin
+    Result := FEOF;
+end;
+
+function TAbstractIterator.First: ICollectable;
+begin
+    FEOF := false;
+    FItem := TrueFirst;
+    if FItem = nil then
+        FEOF := true;
+    Result := FItem;
+end;
+
+function TAbstractIterator.Next: ICollectable;
+begin
+    if not FEOF then
+    begin
+        FItem := TrueNext;
+        if FItem = nil then
+            FEOF := true;
+    end;
+    Result := FItem;
+end;
+
+function TAbstractIterator.Remove: Boolean;
+begin
+    if (FItem <> nil) and FAllowRemoval then
+    begin
+        TrueRemove;
+        FItem := nil;
+        Result := true;
+    end
+    else
+        Result := false;
+end;
+
+{ TAbstractAssociationIterator }
+constructor TAbstractAssociationIterator.Create(AllowRemoval: Boolean);
+begin
+    inherited Create;
+    FAllowRemoval := AllowRemoval;
+    FEOF := true;
+    FAssociation := nil;
+end;
+
+procedure TAbstractAssociationIterator.AfterConstruction;
+begin
+    inherited AfterConstruction;
+    First;
+end;
+
+function TAbstractAssociationIterator.GetAllowRemoval: Boolean;
+begin
+    Result := FAllowRemoval;
+end;
+
+function TAbstractAssociationIterator.CurrentKey: ICollectable;
+begin
+    if FAssociation <> nil then
+        Result := FAssociation.GetKey
+    else
+        Result := nil;
+end;
+
+function TAbstractAssociationIterator.CurrentItem: ICollectable;
+begin
+    if FAssociation <> nil then
+        Result := FAssociation.GetValue
+    else
+        Result := nil;
+end;
+
+function TAbstractAssociationIterator.EOF: Boolean;
+begin
+    Result := FEOF;
+end;
+
+function TAbstractAssociationIterator.First: ICollectable;
+begin
+    FAssociation := TrueFirst;
+    if FAssociation <> nil then
+    begin
+        Result := FAssociation.GetValue;
+        FEOF := false;
+    end
+    else
+    begin
+        Result := nil;
+        FEOF := true;
+    end;
+end;
+
+function TAbstractAssociationIterator.Next: ICollectable;
+begin
+    if not FEOF then
+    begin
+        FAssociation := TrueNext;
+        if FAssociation <> nil then
+            Result := FAssociation.GetValue
+        else
+        begin
+            Result := nil;
+            FEOF := true;
+        end;
+    end;
+end;
+
+function TAbstractAssociationIterator.Remove: Boolean;
+begin
+    if (FAssociation <> nil) and FAllowRemoval then
+    begin
+        TrueRemove;
+        FAssociation := nil;
+        Result := true;
+    end
+    else
+        Result := false;
+end;
+
+{ TAbstractIntegerAssociationIterator }
+constructor TAbstractIntegerAssociationIterator.Create(AllowRemoval: Boolean);
+begin
+    inherited Create;
+    FAllowRemoval := AllowRemoval;
+    FEOF := true;
+    FAssociation := nil;
+end;
+
+procedure TAbstractIntegerAssociationIterator.AfterConstruction;
+begin
+    inherited AfterConstruction;
+    First;
+end;
+
+function TAbstractIntegerAssociationIterator.GetAllowRemoval: Boolean;
+begin
+    Result := FAllowRemoval;
+end;
+
+function TAbstractIntegerAssociationIterator.CurrentKey: Integer;
+begin
+    if FAssociation <> nil then
+        Result := FAssociation.GetKey
+    else
+        Result := 0;
+end;
+
+function TAbstractIntegerAssociationIterator.CurrentItem: ICollectable;
+begin
+    if FAssociation <> nil then
+        Result := FAssociation.GetValue
+    else
+        Result := nil;
+end;
+
+function TAbstractIntegerAssociationIterator.EOF: Boolean;
+begin
+    Result := FEOF;
+end;
+
+function TAbstractIntegerAssociationIterator.First: ICollectable;
+begin
+    FAssociation := TrueFirst;
+    if FAssociation <> nil then
+    begin
+        Result := FAssociation.GetValue;
+        FEOF := false;
+    end
+    else
+    begin
+        Result := nil;
+        FEOF := true;
+    end;
+end;
+
+function TAbstractIntegerAssociationIterator.Next: ICollectable;
+begin
+    if not FEOF then
+    begin
+        FAssociation := TrueNext;
+        if FAssociation <> nil then
+            Result := FAssociation.GetValue
+        else
+        begin
+            Result := nil;
+            FEOF := true;
+        end;
+    end;
+end;
+
+function TAbstractIntegerAssociationIterator.Remove: Boolean;
+begin
+    if (FAssociation <> nil) and FAllowRemoval then
+    begin
+        TrueRemove;
+        FAssociation := nil;
+        Result := true;
+    end
+    else
+        Result := false;
+end;
+
+{ TAbstractStringAssociationIterator }
+constructor TAbstractStringAssociationIterator.Create(AllowRemoval: Boolean);
+begin
+    inherited Create;
+    FAllowRemoval := AllowRemoval;
+    FEOF := true;
+    FAssociation := nil;
+end;
+
+procedure TAbstractStringAssociationIterator.AfterConstruction;
+begin
+    inherited AfterConstruction;
+    First;
+end;
+
+function TAbstractStringAssociationIterator.GetAllowRemoval: Boolean;
+begin
+    Result := FAllowRemoval;
+end;
+
+function TAbstractStringAssociationIterator.CurrentKey: String;
+begin
+    if FAssociation <> nil then
+        Result := FAssociation.GetKey
+    else
+        Result := '';
+end;
+
+function TAbstractStringAssociationIterator.CurrentItem: ICollectable;
+begin
+    if FAssociation <> nil then
+        Result := FAssociation.GetValue
+    else
+        Result := nil;
+end;
+
+function TAbstractStringAssociationIterator.EOF: Boolean;
+begin
+    Result := FEOF;
+end;
+
+function TAbstractStringAssociationIterator.First: ICollectable;
+begin
+    FAssociation := TrueFirst;
+    if FAssociation <> nil then
+    begin
+        Result := FAssociation.GetValue;
+        FEOF := false;
+    end
+    else
+    begin
+        Result := nil;
+        FEOF := true;
+    end;
+end;
+
+function TAbstractStringAssociationIterator.Next: ICollectable;
+begin
+    if not FEOF then
+    begin
+        FAssociation := TrueNext;
+        if FAssociation <> nil then
+            Result := FAssociation.GetValue
+        else
+        begin
+            Result := nil;
+            FEOF := true;
+        end;
+    end;
+end;
+
+function TAbstractStringAssociationIterator.Remove: Boolean;
+begin
+    if (FAssociation <> nil) and FAllowRemoval then
+    begin
+        TrueRemove;
+        FAssociation := nil;
+        Result := true;
+    end
+    else
+        Result := false;
+end;
+
+{ TAssociationIterator }
+constructor TAssociationIterator.Create(const Iterator: IIterator);
+begin
+    inherited Create(Iterator.GetAllowRemoval);
+    FIterator := Iterator;
+end;
+
+destructor TAssociationIterator.Destroy;
+begin
+    FIterator := nil;
+    inherited Destroy;
+end;
+
+function TAssociationIterator.TrueFirst: ICollectable;
+var
+    Association: IAssociation;
+begin
+    Association := FIterator.First as IAssociation;
+    if Association <> nil then
+        Result := Association.GetValue
+    else
+        Result := nil;
+end;
+
+function TAssociationIterator.TrueNext: ICollectable;
+var
+    Association: IAssociation;
+begin
+    Association := (FIterator.Next as IAssociation);
+    if Association <> nil then
+        Result := Association.GetValue
+    else
+        Result := nil;
+end;
+
+procedure TAssociationIterator.TrueRemove;
+begin
+    FIterator.Remove;
+end;
+
+function TAssociationIterator.CurrentItem: ICollectable;
+var
+    Association: IAssociation;
+begin
+    Association := FIterator.CurrentItem as IAssociation;
+    if Association <> nil then
+        Result := Association.GetValue
+    else
+        Result := nil;
+end;
+
+function TAssociationIterator.CurrentKey: ICollectable;
+var
+    Association: IAssociation;
+begin
+    Association := FIterator.CurrentItem  as IAssociation;
+    if Association <> nil then
+        Result := Association.GetKey
+    else
+        Result := nil;
+end;
+
+{ TAssociationComparator }
+constructor TAssociationComparator.Create(NaturalKeys: Boolean);
+begin
+    inherited Create;
+    if NaturalKeys then
+        FKeyComparator := TAbstractComparator.GetNaturalComparator
+    else
+        FKeyComparator := TAbstractComparator.GetDefaultComparator;
+end;
+
+destructor TAssociationComparator.Destroy;
+begin
+    FKeyComparator := nil;
+    inherited Destroy;
+end;
+
+function TAssociationComparator.GetKeyComparator: IComparator;
+begin
+    Result := FKeyComparator;
+end;
+
+procedure TAssociationComparator.SetKeyComparator(Value: IComparator);
+begin
+    FKeyComparator := Value;
+end;
+
+function TAssociationComparator.Compare(const Item1, Item2: ICollectable): Integer;
+begin
+    Result := KeyComparator.Compare((Item1 as IAssociation).GetKey, (Item2 as IAssociation).GetKey);
+end;
+
+function TAssociationComparator.Equals(const Item1, Item2: ICollectable): Boolean;
+begin
+    Result := KeyComparator.Equals((Item1 as IAssociation).GetKey, (Item2 as IAssociation).GetKey);
+end;
+
+{ TIntegerAssociationComparator }
+constructor TIntegerAssociationComparator.Create;
+begin
+    inherited Create;
+end;
+
+destructor TIntegerAssociationComparator.Destroy;
+begin
+    inherited Destroy;
+end;
+
+function TIntegerAssociationComparator.Compare(const Item1, Item2: ICollectable): Integer;
+var
+    Key1, Key2: Integer;
+begin
+    Key1 := (Item1 as IIntegerAssociation).GetKey;
+    Key2 := (Item2 as IIntegerAssociation).GetKey;
+    if Key1 < Key2 then
+        Result := -1
+    else if Key1 > Key2 then
+        Result := 1
+    else
+        Result := 0;
+end;
+
+function TIntegerAssociationComparator.Equals(const Item1, Item2: ICollectable): Boolean;
+begin
+    Result := ((Item1 as IIntegerAssociation).GetKey = (Item2 as IIntegerAssociation).GetKey);
+end;
+
+{ TStringAssociationComparator }
+constructor TStringAssociationComparator.Create;
+begin
+    inherited Create;
+end;
+
+destructor TStringAssociationComparator.Destroy;
+begin
+    inherited Destroy;
+end;
+
+function TStringAssociationComparator.Compare(const Item1, Item2: ICollectable): Integer;
+var
+    Key1, Key2: String;
+begin
+    Key1 := (Item1 as IStringAssociation).GetKey;
+    Key2 := (Item2 as IStringAssociation).GetKey;
+    if Key1 < Key2 then
+        Result := -1
+    else if Key1 > Key2 then
+        Result := 1
+    else
+        Result := 0;
+end;
+
+function TStringAssociationComparator.Equals(const Item1, Item2: ICollectable): Boolean;
+begin
+    Result := ((Item1 as IStringAssociation).GetKey = (Item2 as IStringAssociation).GetKey);
+end;
+
+{ TAssociationKeyIterator }
+constructor TAssociationKeyIterator.Create(const Iterator: IMapIterator);
+begin
+    inherited Create(Iterator.GetAllowRemoval);
+    FIterator := Iterator;
+end;
+
+destructor TAssociationKeyIterator.Destroy;
+begin
+    FIterator := nil;
+    inherited Destroy;
+end;
+
+function TAssociationKeyIterator.TrueFirst: ICollectable;
+begin
+    FIterator.First;
+    Result := FIterator.CurrentKey;
+end;
+
+function TAssociationKeyIterator.TrueNext: ICollectable;
+begin
+    FIterator.Next;
+    Result := FIterator.CurrentKey;
+end;
+
+procedure TAssociationKeyIterator.TrueRemove;
+begin
+    FIterator.Remove;
+end;
+
+{ TFilterIterator }
+constructor TFilterIterator.Create(const Iterator: IIterator; const Filter: IFilter; AllowRemoval: Boolean = true);
+begin
+    FIterator := Iterator;
+    FFilter := Filter;
+end;
+
+destructor TFilterIterator.Destroy;
+begin
+    FIterator := nil;
+    FFilter := nil;
+end;
+
+function TFilterIterator.TrueFirst: ICollectable;
+var
+    Item: ICollectable;
+begin
+    Item := FIterator.First;
+    while not FIterator.EOF do
+    begin
+        if FFilter.Accept(Item) then
+            break
+        else
+            Item := FIterator.Next;
+    end;
+    Result := Item;
+end;
+
+function TFilterIterator.TrueNext: ICollectable;
+var
+    Item: ICollectable;
+begin
+    Item := FIterator.Next;
+    while not FIterator.EOF do
+    begin
+        if FFilter.Accept(Item) then
+            break
+        else
+            Item := FIterator.Next;
+    end;
+    Result := Item;
+end;
+
+procedure TFilterIterator.TrueRemove;
+begin
+    FIterator.Remove;
+end;
+
+{ TFilterFuncIterator }
+constructor TFilterFuncIterator.Create(const Iterator: IIterator; FilterFunc: TCollectionFilterFunc; AllowRemoval: Boolean = true);
+begin
+    FIterator := Iterator;
+    FFilterFunc := FilterFunc;
+end;
+
+destructor TFilterFuncIterator.Destroy;
+begin
+    FIterator := nil;
+    FFilterFunc := nil;
+end;
+
+function TFilterFuncIterator.TrueFirst: ICollectable;
+var
+    Item: ICollectable;
+begin
+    Item := FIterator.First;
+    while not FIterator.EOF do
+    begin
+        if FFilterFunc(Item) then
+            break
+        else
+            Item := FIterator.Next;
+    end;
+    Result := Item;
+end;
+
+function TFilterFuncIterator.TrueNext: ICollectable;
+var
+    Item: ICollectable;
+begin
+    Item := FIterator.Next;
+    while not FIterator.EOF do
+    begin
+        if FFilterFunc(Item) then
+            break
+        else
+            Item := FIterator.Next;
+    end;
+    Result := Item;
+end;
+
+procedure TFilterFuncIterator.TrueRemove;
+begin
+    FIterator.Remove;
+end;
+
+{ TKeyFilterMapIterator }
+constructor TKeyFilterMapIterator.Create(const Iterator: IMapIterator; const Filter: IFilter; AllowRemoval: Boolean = true);
+begin
+    FIterator := Iterator;
+    FFilter := Filter;
+end;
+
+destructor TKeyFilterMapIterator.Destroy;
+begin
+    FIterator := nil;
+    FFilter := nil;
+end;
+
+function TKeyFilterMapIterator.TrueFirst: ICollectable;
+var
+    Key, Item: ICollectable;
+begin
+    Item := FIterator.First;
+    while not FIterator.EOF do
+    begin
+        Key := FIterator.CurrentKey;
+        if FFilter.Accept(Key) then
+            break
+        else
+            Item := FIterator.Next;
+    end;
+    Result := Item;
+end;
+
+function TKeyFilterMapIterator.TrueNext: ICollectable;
+var
+    Key, Item: ICollectable;
+begin
+    Item := FIterator.Next;
+    while not FIterator.EOF do
+    begin
+        Key := FIterator.CurrentKey;
+        if FFilter.Accept(Key) then
+            break
+        else
+            Item := FIterator.Next;
+    end;
+    Result := Item;
+end;
+
+procedure TKeyFilterMapIterator.TrueRemove;
+begin
+    FIterator.Remove;
+end;
+
+function TKeyFilterMapIterator.CurrentKey: ICollectable;
+begin
+    Result := FIterator.CurrentKey;
+end;
+
+{ TKeyFilterFuncMapIterator }
+constructor TKeyFilterFuncMapIterator.Create(const Iterator: IMapIterator; FilterFunc: TCollectionFilterFunc; AllowRemoval: Boolean = true);
+begin
+    FIterator := Iterator;
+    FFilterFunc := FilterFunc;
+end;
+
+destructor TKeyFilterFuncMapIterator.Destroy;
+begin
+    FIterator := nil;
+    FFilterFunc := nil;
+end;
+
+function TKeyFilterFuncMapIterator.TrueFirst: ICollectable;
+var
+    Key, Item: ICollectable;
+begin
+    Item := FIterator.First;
+    while not FIterator.EOF do
+    begin
+        Key := FIterator.CurrentKey;
+        if FFilterFunc(Key) then
+            break
+        else
+            Item := FIterator.Next;
+    end;
+    Result := Item;
+end;
+
+function TKeyFilterFuncMapIterator.TrueNext: ICollectable;
+var
+    Key, Item: ICollectable;
+begin
+    Item := FIterator.Next;
+    while not FIterator.EOF do
+    begin
+        Key := FIterator.CurrentKey;
+        if FFilterFunc(Key) then
+            break
+        else
+            Item := FIterator.Next;
+    end;
+    Result := Item;
+end;
+
+procedure TKeyFilterFuncMapIterator.TrueRemove;
+begin
+    FIterator.Remove;
+end;
+
+function TKeyFilterFuncMapIterator.CurrentKey: ICollectable;
+begin
+    Result := FIterator.CurrentKey;
+end;
+
+
+{ TAbstractCollection }
+constructor TAbstractCollection.Create;
+begin
+    Create(false);
+end;
+
+constructor TAbstractCollection.Create(NaturalItemsOnly: Boolean);
+begin
+    FCreated := false;
+    inherited Create;
+    FNaturalItemsOnly := NaturalItemsOnly or GetAlwaysNaturalItems;
+    if FNaturalItemsOnly then
+        FComparator := TAbstractComparator.GetNaturalComparator
+    else
+        FComparator := TAbstractComparator.GetDefaultComparator;
+    FIgnoreErrors := [ceDuplicate];
+end;
+
+constructor TAbstractCollection.Create(const ItemArray: array of ICollectable);
+begin
+    Create(ItemArray, false);
+end;
+
+// Fixed size collections must override this.
+constructor TAbstractCollection.Create(const ItemArray: array of ICollectable; NaturalItemsOnly: Boolean);
+var
+    I: Integer;
+begin
+    Create(NaturalItemsOnly);
+    if not FixedSize then
+    begin
+        Capacity := Length(ItemArray);
+        for I := Low(ItemArray) to High(ItemArray) do
+        begin
+            Add(ItemArray[I]);
+        end;
+    end;
+end;
+
+// Fixed size collections must override this.
+constructor TAbstractCollection.Create(const Collection: ICollection);
+var
+    Iterator: IIterator;
+begin
+    Create(Collection.GetNaturalItemsOnly);
+    InitFrom(Collection);
+    if not FixedSize then
+    begin
+        Capacity := Collection.GetSize;
+        Iterator := Collection.GetIterator;
+        while not Iterator.EOF do
+        begin
+            Add(Iterator.CurrentItem);
+            Iterator.Next;
+        end;
+    end;
+end;
+
+destructor TAbstractCollection.Destroy;
+begin
+    FCreated := false;
+    FComparator := nil;
+    inherited Destroy;
+end;
+
+procedure TAbstractCollection.CollectionError(ErrorType: TCollectionError);
+var
+    Msg: String;
+begin
+    if not (ErrorType in FIgnoreErrors) then
+    begin
+        case ErrorType of
+        ceDuplicate: Msg := 'Collection does not allow duplicates.';
+        ceDuplicateKey: Msg := 'Collection does not allow duplicate keys.';
+        ceFixedSize: Msg := 'Collection has fixed size.';
+        ceNilNotAllowed: Msg := 'Collection does not allow nil.';
+        ceNotNaturalItem: Msg := 'Collection only accepts natural items.';
+        ceOutOfRange: Msg := 'Index out of collection range.';
+        end;
+        // If exception is thrown during construction, collection cannot be
+        // passed to it as destructor is automatically called and this leaves an
+        // interface reference to a destroyed object and crashes.
+        if FCreated then
+            raise ECollectionError.Create(Msg, Self, ErrorType)
+        else
+            raise ECollectionError.Create(Msg, nil, ErrorType);
+    end;
+end;
+
+procedure TAbstractCollection.InitFrom(const Collection: ICollection);
+begin
+    Comparator := Collection.GetComparator;
+    IgnoreErrors := Collection.GetIgnoreErrors;
+end;
+
+// Implementations should override this if possible
+function TAbstractCollection.TrueItemCount(const Item: ICollectable): Integer;
+var
+    Iterator: IIterator;
+    Total: Integer;
+begin
+    Total := 0;
+    Iterator := GetIterator;
+    while not Iterator.EOF do
+    begin
+        if FComparator.Equals(Item, Iterator.CurrentItem) then
+            Inc(Total);
+        Iterator.Next;
+    end;
+    Result := Total;
+end;
+
+class function TAbstractCollection.GetAlwaysNaturalItems: Boolean;
+begin
+    Result := false;
+end;
+
+function TAbstractCollection.GetAsArray: TCollectableArray;
+var
+    Iterator: IIterator;
+    Working: TCollectableArray;
+    I: Integer;
+begin
+    SetLength(Working, Size);
+    I := 0;
+    Iterator := GetIterator;
+    while not Iterator.EOF do
+    begin
+        Working[I] := Iterator.CurrentItem;
+        Inc(I);
+        Iterator.Next;
+    end;
+    Result := Working;
+end;
+
+function TAbstractCollection.GetComparator: IComparator;
+begin
+    Result := FComparator;
+end;
+
+function TAbstractCollection.GetDuplicates: Boolean;
+begin
+    Result := true; // Sets and lists override this.
+end;
+
+procedure TAbstractCollection.SetComparator(const Value: IComparator);
+begin
+    if Value = nil then
+    begin
+        if NaturalItemsOnly then
+            FComparator := TAbstractComparator.GetNaturalComparator
+        else
+            FComparator := TAbstractComparator.GetDefaultComparator;
+    end
+    else
+        FComparator := Value;
+end;
+
+function TAbstractCollection.GetFixedSize: Boolean;
+begin
+    Result := false;
+end;
+
+function TAbstractCollection.GetIgnoreErrors: TCollectionErrors;
+begin
+    Result := FIgnoreErrors;
+end;
+
+procedure TAbstractCollection.SetIgnoreErrors(Value: TCollectionErrors);
+begin
+    FIgnoreErrors := Value;
+end;
+
+function TAbstractCollection.GetInstance: TObject;
+begin
+    Result := Self;
+end;
+
+function TAbstractCollection.GetIterator(const Filter: IFilter): IIterator;
+var
+    Iterator: IIterator;
+begin
+    Iterator := GetIterator;
+    Result := TFilterIterator.Create(Iterator, Filter, Iterator.GetAllowRemoval);
+end;
+
+function TAbstractCollection.GetIterator(FilterFunc: TCollectionFilterFunc): IIterator;
+var
+    Iterator: IIterator;
+begin
+    Iterator := GetIterator;
+    Result := TFilterFuncIterator.Create(Iterator, FilterFunc, Iterator.GetAllowRemoval);
+end;
+
+function TAbstractCollection.GetNaturalItemsOnly: Boolean;
+begin
+    Result := FNaturalItemsOnly;
+end;
+
+function TAbstractCollection.Add(const Item: ICollectable): Boolean;
+var
+    ItemError: TCollectionError;
+    Success: Boolean;
+begin
+    ItemError := ItemAllowed(Item); // Can be natural items only error or nil not allowed error
+    if ItemError <> ceOK then
+    begin
+        CollectionError(ItemError);
+        Success := false;
+    end
+    else if FixedSize then
+    begin
+        CollectionError(ceFixedSize);
+        Success := false;
+    end
+    else
+    begin
+        Success := TrueAdd(Item);
+    end;
+    Result := Success;
+end;
+
+function TAbstractCollection.Add(const ItemArray: array of ICollectable): Integer;
+var
+    Item: ICollectable;
+    ItemError: TCollectionError;
+    I, Count: Integer;
+    Success: Boolean;
+begin
+    Count := 0;
+    if FixedSize then
+    begin
+        CollectionError(ceFixedSize);
+    end
+    else
+    begin
+        for I := Low(ItemArray) to High(ItemArray) do
+        begin
+            Item := ItemArray[I];
+            ItemError := ItemAllowed(Item);
+            if ItemError <> ceOK then
+            begin
+                CollectionError(ItemError);
+                Success := false;
+            end
+            else
+            begin
+                Success := TrueAdd(Item);
+            end;
+            if Success then
+                Inc(Count);
+        end;
+    end;
+    Result := Count;
+end;
+
+function TAbstractCollection.Add(const Collection: ICollection): Integer;
+var
+    Iterator: IIterator;
+    Item: ICollectable;
+    ItemError: TCollectionError;
+    Count: Integer;
+    Success: Boolean;
+begin
+    Count := 0;
+    Iterator := Collection.GetIterator;
+    while not Iterator.EOF do
+    begin
+        Item := Iterator.CurrentItem;
+        ItemError := ItemAllowed(Item);
+        if ItemError <> ceOK then
+        begin
+            CollectionError(ItemError);
+            Success := false;
+        end
+        else if FixedSize then
+        begin
+            CollectionError(ceFixedSize);
+            Success := false;
+        end
+        else
+        begin
+            Success := TrueAdd(Item);
+        end;
+        if Success then
+            Inc(Count);
+        Iterator.Next;
+    end;
+    Result := Count;
+end;
+
+procedure TAbstractCollection.AfterConstruction;
+begin
+    inherited AfterConstruction;
+    FCreated := true;
+end;
+
+procedure TAbstractCollection.BeforeDestruction;
+begin
+    if not FixedSize then
+        TrueClear;
+    inherited BeforeDestruction;
+end;
+
+function TAbstractCollection.Clear: Integer;
+begin
+    if not FixedSize then
+    begin
+        Result := Size;
+        TrueClear;
+    end
+    else
+    begin
+        CollectionError(ceFixedSize);
+        Result := 0;
+    end;
+end;
+
+function TAbstractCollection.Clone: ICollection;
+begin
+    Result := (TAbstractCollectionClass(ClassType)).Create(Self);
+end;
+
+function TAbstractCollection.Contains(const Item: ICollectable): Boolean;
+var
+    ItemError: TCollectionError;
+    Success: Boolean;
+begin
+    ItemError := ItemAllowed(Item);
+    if ItemError <> ceOK then
+    begin
+        CollectionError(ItemError);
+        Success := false;
+    end
+    else
+    begin
+        Success := TrueContains(Item);
+    end;
+    Result := Success;
+end;
+
+function TAbstractCollection.Contains(const ItemArray: array of ICollectable): Boolean;
+var
+    I: Integer;
+    Success: Boolean;
+begin
+    Success := true;
+    for I := Low(ItemArray) to High(ItemArray) do
+    begin
+        Success := Success and Contains(ItemArray[I]);
+        if not Success then
+            break;
+    end;
+    Result := Success;
+end;
+
+function TAbstractCollection.Contains(const Collection: ICollection): Boolean;
+var
+    Iterator: IIterator;
+    Success: Boolean;
+begin
+    Success := true;
+    Iterator := Collection.GetIterator;
+    while not Iterator.EOF do
+    begin
+        Success := Success and Contains(Iterator.CurrentItem);
+        if not Success then
+            break;
+        Iterator.Next;
+    end;
+    Result := Success;
+end;
+
+function TAbstractCollection.Equals(const Collection: ICollection): Boolean;
+var
+    Iterator: IIterator;
+    Success: Boolean;
+begin
+    if Collection.GetType <> GetType then
+        Result := false
+    else if Collection.Size <> Size then
+        Result := false
+    else if not Collection.Comparator.Equals(Comparator) then
+        Result := false
+    else if not Collection.GetDuplicates and not GetDuplicates then
+    begin
+        // Not equal if any item not found in parameter collection
+        Success := true;
+        Iterator := GetIterator;
+        while not Iterator.EOF and Success do
+        begin
+            Success := Collection.Contains(Iterator.CurrentItem);
+            Iterator.Next;
+        end;
+        Result := Success;
+    end
+    else
+    begin
+        // Not equal if any item count not equal to item count in parameter collection
+        Success := true;
+        Iterator := GetIterator;
+        while not Iterator.EOF and Success do
+        begin
+            Success := (ItemCount(Iterator.CurrentItem) = Collection.ItemCount(Iterator.CurrentItem));
+            Iterator.Next;
+        end;
+        Result := Success;
+    end;
+end;
+
+function TAbstractCollection.Find(const Filter: IFilter): ICollectable;
+begin
+    Result := GetIterator(Filter).First;
+end;
+
+function TAbstractCollection.Find(FilterFunc: TCollectionFilterFunc): ICollectable;
+begin
+    Result := GetIterator(FilterFunc).First;
+end;
+
+function TAbstractCollection.FindAll(const Filter: IFilter): ICollection;
+var
+    ResultCollection: ICollection;
+    Iterator: IIterator;
+begin
+    ResultCollection := TPArrayBag.Create(NaturalItemsOnly);
+    Iterator := Self.GetIterator(Filter);
+    while not Iterator.EOF do
+    begin
+        ResultCollection.Add(Iterator.CurrentItem);
+        Iterator.Next;
+    end;
+    Result := ResultCollection;
+end;
+
+function TAbstractCollection.FindAll(FilterFunc: TCollectionFilterFunc): ICollection;
+var
+    ResultCollection: ICollection;
+    Iterator: IIterator;
+begin
+    ResultCollection := TPArrayBag.Create(NaturalItemsOnly);
+    Iterator := Self.GetIterator(FilterFunc);
+    while not Iterator.EOF do
+    begin
+        ResultCollection.Add(Iterator.CurrentItem);
+        Iterator.Next;
+    end;
+    Result := ResultCollection;
+end;
+
+function TAbstractCollection.IsEmpty: Boolean;
+begin
+    Result := (Size = 0);
+end;
+
+function TAbstractCollection.IsNaturalItem(const Item: ICollectable): Boolean;
+var
+    Temp: IUnknown;
+begin
+    if Item <> nil then
+        Result := (Item.QueryInterface(NaturalItemIID, Temp) <> E_NOINTERFACE)
+    else
+        Result := false;
+end;
+
+function TAbstractCollection.ItemAllowed(const Item: ICollectable): TCollectionError;
+begin
+    if NaturalItemsOnly and not IsNaturalItem(Item) then
+        Result := ceNotNaturalItem
+    else if not IsNilAllowed and (Item = nil) then
+        Result := ceNilNotAllowed
+    else
+        Result := ceOK;
+end;
+
+function TAbstractCollection.ItemCount(const Item: ICollectable): Integer;
+var
+    ItemError: TCollectionError;
+begin
+    ItemError := ItemAllowed(Item);
+    if ItemError <> ceOK then
+    begin
+        CollectionError(ItemError);
+        Result := 0;
+    end
+    else if GetDuplicates then
+    begin
+        Result := TrueItemCount(Item);
+    end
+    else
+    begin
+        // Where duplicates are not allowed, TrueContains will be faster than TrueItemCount.
+        if TrueContains(Item) then
+            Result := 1
+        else
+            Result := 0;
+    end;
+end;
+
+function TAbstractCollection.ItemCount(const ItemArray: array of ICollectable): Integer;
+var
+    I: Integer;
+    Total: Integer;
+begin
+    Total := 0;
+    for I := Low(ItemArray) to High(ItemArray) do
+    begin
+        Total := Total + ItemCount(ItemArray[I]);
+    end;
+    Result := Total;
+end;
+
+function TAbstractCollection.ItemCount(const Collection: ICollection): Integer;
+var
+    Iterator: IIterator;
+    Total: Integer;
+begin
+    Total := 0;
+    Iterator := Collection.GetIterator;
+    while not Iterator.EOF do
+    begin
+        Total := Total + ItemCount(Iterator.CurrentItem);
+        Iterator.Next;
+    end;
+    Result := Total;
+end;
+
+function TAbstractCollection.Matching(const ItemArray: array of ICollectable): ICollection;
+var
+    ResultCollection: ICollection;
+    I: Integer;
+begin
+    ResultCollection := TPArrayBag.Create(NaturalItemsOnly);
+    for I := Low(ItemArray) to High(ItemArray) do
+    begin
+        if Contains(ItemArray[I]) then
+            ResultCollection.Add(ItemArray[I]);
+    end;
+    Result := ResultCollection;
+end;
+
+function TAbstractCollection.Matching(const Collection: ICollection): ICollection;
+var
+    ResultCollection: ICollection;
+    Iterator: IIterator;
+begin
+    ResultCollection := TPArrayBag.Create(NaturalItemsOnly);
+    Iterator := Collection.GetIterator;
+    while not Iterator.EOF do
+    begin
+        if Contains(Iterator.CurrentItem) then
+            ResultCollection.Add(Iterator.CurrentItem);
+        Iterator.Next;
+    end;
+    Result := ResultCollection;
+end;
+
+function TAbstractCollection.Remove(const Item: ICollectable): ICollectable;
+var
+    ItemError: TCollectionError;
+begin
+    ItemError := ItemAllowed(Item);
+    if ItemError <> ceOK then
+    begin
+        CollectionError(ItemError);
+        Result := nil;
+    end
+    else if FixedSize then
+    begin
+        CollectionError(ceFixedSize);
+        Result := nil;
+    end
+    else
+    begin
+        Result := TrueRemove(Item);
+    end;
+end;
+
+function TAbstractCollection.Remove(const ItemArray: array of ICollectable): ICollection;
+var
+    ResultCollection: ICollection;
+    I: Integer;
+begin
+    ResultCollection := TPArrayBag.Create(NaturalItemsOnly);
+    for I := Low(ItemArray) to High(ItemArray) do
+    begin
+        ResultCollection.Add(Remove(ItemArray[I]));
+    end;
+    Result := ResultCollection;
+end;
+
+function TAbstractCollection.Remove(const Collection: ICollection): ICollection;
+var
+    ResultCollection: ICollection;
+    Iterator: IIterator;
+begin
+    ResultCollection := TPArrayBag.Create(NaturalItemsOnly);
+    Iterator := Collection.GetIterator;
+    while not Iterator.EOF do
+    begin
+        ResultCollection.Add(Remove(Iterator.CurrentItem));
+        Iterator.Next;
+    end;
+    Result := ResultCollection;
+end;
+
+function TAbstractCollection.RemoveAll(const Item: ICollectable): ICollection;
+var
+    ItemError: TCollectionError;
+begin
+    ItemError := ItemAllowed(Item);
+    if ItemError <> ceOK then
+    begin
+        CollectionError(ItemError);
+        Result := nil;
+    end
+    else if FixedSize then
+    begin
+        CollectionError(ceFixedSize);
+        Result := nil;
+    end
+    else
+    begin
+        Result := TrueRemoveAll(Item);
+    end;
+end;
+
+function TAbstractCollection.RemoveAll(const ItemArray: array of ICollectable): ICollection;
+var
+    ResultCollection: ICollection;
+    I: Integer;
+begin
+    ResultCollection := TPArrayBag.Create(NaturalItemsOnly);
+    for I := Low(ItemArray) to High(ItemArray) do
+    begin
+        ResultCollection.Add(RemoveAll(ItemArray[I]));
+    end;
+    Result := ResultCollection;
+end;
+
+function TAbstractCollection.RemoveAll(const Collection: ICollection): ICollection;
+var
+    ResultCollection: ICollection;
+    Iterator: IIterator;
+begin
+    ResultCollection := TPArrayBag.Create(NaturalItemsOnly);
+    Iterator := Collection.GetIterator;
+    while not Iterator.EOF do
+    begin
+        ResultCollection.Add(RemoveAll(Iterator.CurrentItem));
+        Iterator.Next;
+    end;
+    Result := ResultCollection;
+end;
+
+function TAbstractCollection.Retain(const ItemArray: array of ICollectable): ICollection;
+var
+    ResultCollection: ICollection;
+    Iterator: IIterator;
+    Item: ICollectable;
+    I: Integer;
+    Found, Success: Boolean;
+begin
+    ResultCollection := TPArrayBag.Create(NaturalItemsOnly);
+    Iterator := GetIterator;
+    while not Iterator.EOF do
+    begin
+        // Converting the array to a map would be faster but I don't want to
+        // couple base class code to a complex collection.
+        Found := false;
+        for I := Low(ItemArray) to High(ItemArray) do
+        begin
+            Item := Iterator.CurrentItem;
+            Found := Comparator.Equals(Item, ItemArray[I]);
+            if Found then
+                break;
+        end;
+        if not Found then
+        begin
+            Success := Iterator.Remove;
+            if Success then
+                ResultCollection.Add(Item);
+        end;
+        Iterator.Next;
+    end;
+    Result := ResultCollection;
+end;
+
+function TAbstractCollection.Retain(const Collection: ICollection): ICollection;
+var
+    ResultCollection: ICollection;
+    Iterator: IIterator;
+    Item: ICollectable;
+    Success: Boolean;
+begin
+    ResultCollection := TPArrayBag.Create(NaturalItemsOnly);
+    Iterator := GetIterator;
+    while not Iterator.EOF do
+    begin
+        Item := Iterator.CurrentItem;
+        if not Collection.Contains(Item) then
+        begin
+            Success := Iterator.Remove;
+            if Success then
+                ResultCollection.Add(Item);
+        end;
+        Iterator.Next;
+    end;
+    Result := ResultCollection;
+end;
+
+{ TAbstractBag }
+function TAbstractBag.CloneAsBag: IBag;
+begin
+    Result := (TAbstractBagClass(ClassType)).Create(Self);
+end;
+
+function TAbstractBag.GetNaturalItemIID: TGUID;
+begin
+    Result := EquatableIID;
+end;
+
+function TAbstractBag.GetType: TCollectionType;
+begin
+    Result := ctBag;
+end;
+
+function TAbstractBag.IsNilAllowed: Boolean;
+begin
+    Result := true;
+end;
+
+{ TAbstractSet }
+function TAbstractSet.TrueAdd(const Item: ICollectable): Boolean;
+var
+    Position: TCollectionPosition;
+begin
+    // Adds if not already present otherwise fails
+    Position := GetPosition(Item);
+    try
+        if Position.Found then
+        begin
+            CollectionError(ceDuplicate);
+            Result := false;
+        end
+        else
+        begin
+            TrueAdd2(Position, Item);
+            Result := true;
+        end;
+    finally
+        Position.Free;
+    end;
+end;
+
+function TAbstractSet.TrueContains(const Item: ICollectable): Boolean;
+var
+    Position: TCollectionPosition;
+begin
+    Position := GetPosition(Item);
+    try
+        Result := Position.Found;
+    finally
+        Position.Free;
+    end;
+end;
+
+function TAbstractSet.TrueRemove(const Item: ICollectable): ICollectable;
+var
+    Position: TCollectionPosition;
+begin
+    Position := GetPosition(Item);
+    try
+        if Position.Found then
+        begin
+            Result := TrueGet(Position);
+            TrueRemove2(Position);
+        end
+        else
+            Result := nil;
+    finally
+        Position.Free;
+    end;
+end;
+
+function TAbstractSet.TrueRemoveAll(const Item: ICollectable): ICollection;
+var
+    ResultCollection: ICollection;
+    RemovedItem: ICollectable;
+begin
+    ResultCollection := TPArrayBag.Create;
+    RemovedItem := TrueRemove(Item);
+    if RemovedItem <> nil then
+        ResultCollection.Add(RemovedItem);
+    Result := ResultCollection;
+end;
+
+function TAbstractSet.GetDuplicates: Boolean;
+begin
+    Result := false;
+end;
+
+function TAbstractSet.GetNaturalItemIID: TGUID;
+begin
+    Result := EquatableIID;
+end;
+
+function TAbstractSet.GetType: TCollectionType;
+begin
+    Result := ctSet;
+end;
+
+function TAbstractSet.CloneAsSet: ISet;
+begin
+    Result := (TAbstractSetClass(ClassType)).Create(Self);
+end;
+
+function TAbstractSet.Complement(const Universe: ISet): ISet;
+var
+    ResultSet: ISet;
+    Iterator: IIterator;
+    Item: ICollectable;
+begin
+    // Return items in universe not found in self.
+    ResultSet := TAbstractSetClass(ClassType).Create(NaturalItemsOnly);
+    Iterator := Universe.GetIterator;
+    while not Iterator.EOF do
+    begin
+        Item := Iterator.CurrentItem;
+        if not Contains(Item) then
+            ResultSet.Add(Item);
+        Iterator.Next;
+    end;
+    Result := ResultSet;
+end;
+
+function TAbstractSet.Intersect(const Set2: ISet): ISet;
+var
+    ResultSet: ISet;
+    Iterator: IIterator;
+    Item: ICollectable;
+begin
+    // Return items found in self and parameter.
+    ResultSet := TAbstractSetClass(ClassType).Create(NaturalItemsOnly);
+    Iterator := GetIterator;
+    while not Iterator.EOF do
+    begin
+        Item := Iterator.CurrentItem;
+        if Contains(Item) and Set2.Contains(Item) then
+            ResultSet.Add(Iterator.CurrentItem);
+        Iterator.Next;
+    end;
+    Result := ResultSet;
+end;
+
+function TAbstractSet.IsNilAllowed: Boolean;
+begin
+    Result := false;
+end;
+
+function TAbstractSet.Union(const Set2: ISet): ISet;
+var
+    ResultSet: ISet;
+    Iterator: IIterator;
+    Item: ICollectable;
+begin
+    // Return items found in self or parameter.
+    ResultSet := CloneAsSet;
+    Iterator := Set2.GetIterator;
+    while not Iterator.EOF do
+    begin
+        Item := Iterator.CurrentItem;
+        if not Contains(Item) and Set2.Contains(Item) then
+            ResultSet.Add(Iterator.CurrentItem);
+        Iterator.Next;
+    end;
+    Result := ResultSet;
+end;
+
+{ TAbstractList }
+constructor TAbstractList.Create(NaturalItemsOnly: Boolean);
+begin
+    inherited Create(NaturalItemsOnly);
+    FDuplicates := true;
+    FSorted := false;
+end;
+
+procedure TAbstractList.InitFrom(const Collection: ICollection);
+var
+    List: IList;
+begin
+    inherited InitFrom(Collection);
+    if Collection.QueryInterface(IList, List) = S_OK then
+    begin
+        FDuplicates := List.GetDuplicates;
+        FSorted := List.GetSorted;
+    end;
+end;
+
+function TAbstractList.TrueAdd(const Item: ICollectable): Boolean;
+var
+    SearchResult: TSearchResult;
+begin
+    Result := True;
+    if Sorted then
+    begin
+        // Insert in appropriate place to maintain sort order, unless duplicate
+        // not allowed.
+        SearchResult := BinarySearch(Item);
+        case SearchResult.ResultType of
+        srBeforeIndex: TrueInsert(SearchResult.Index, Item);
+        srFoundAtIndex: begin
+            if Duplicates then
+                TrueInsert(SearchResult.Index, Item)
+            else
+            begin
+                CollectionError(ceDuplicate);
+                Result := false;
+            end;
+        end;
+        srAfterEnd: TrueAppend(Item);
+        end;
+    end
+    else
+    begin
+        // Add to end, unless duplicate not allowed.
+        if not Duplicates and (SequentialSearch(Item, Comparator).ResultType = srFoundAtIndex) then
+        begin
+            CollectionError(ceDuplicate);
+            Result := false;
+        end
+        else
+            TrueAppend(Item);
+    end;
+end;
+
+function TAbstractList.TrueContains(const Item: ICollectable): Boolean;
+begin
+    if Sorted then
+        Result := BinarySearch(Item).ResultType = srFoundAtIndex
+    else
+        Result := SequentialSearch(Item, Comparator).ResultType = srFoundAtIndex
+end;
+
+function TAbstractList.TrueItemCount(const Item: ICollectable): Integer;
+var
+    SearchResult: TSearchResult;
+    Count: Integer;
+begin
+    if Sorted then
+    begin
+        // If sorted, use binary search.
+        Count := 0;
+        SearchResult := BinarySearch(Item);
+        if SearchResult.ResultType = srFoundAtIndex then
+        begin
+            repeat
+                Inc(Count);
+            until not Comparator.Equals(Item, Items[SearchResult.Index]);
+        end;
+        Result := Count;
+    end
+    else
+        // Resort to sequential search for unsorted
+        Result := inherited TrueItemCount(Item);
+end;
+
+function TAbstractList.TrueRemove(const Item: ICollectable): ICollectable;
+var
+    SearchResult: TSearchResult;
+begin
+    Result := nil;
+    if Sorted then
+    begin
+        SearchResult := BinarySearch(Item);
+        if SearchResult.ResultType = srFoundAtIndex then
+        begin
+            Result := TrueDelete(SearchResult.Index);
+        end;
+    end
+    else
+    begin
+        SearchResult := SequentialSearch(Item);
+        if SearchResult.ResultType = srFoundAtIndex then
+            Result := TrueDelete(SearchResult.Index);
+    end;
+end;
+
+function TAbstractList.TrueRemoveAll(const Item: ICollectable): ICollection;
+var
+    ResultCollection: ICollection;
+    SearchResult: TSearchResult;
+    I: Integer;
+begin
+    ResultCollection := TPArrayBag.Create;
+    if Sorted then
+    begin
+        SearchResult := BinarySearch(Item);
+        if SearchResult.ResultType = srFoundAtIndex then
+        begin
+            repeat
+                ResultCollection.Add(TrueDelete(SearchResult.Index));
+            until not Comparator.Equals(Item, Items[SearchResult.Index]);
+        end;
+    end
+    else
+    begin
+        I := 0;
+        while I < Size do
+        begin
+            if Comparator.Equals(Item, Items[I]) then
+            begin
+                ResultCollection.Add(TrueDelete(I));
+            end
+            else
+                Inc(I);
+        end;
+    end;
+    Result := ResultCollection;
+end;
+
+procedure TAbstractList.QuickSort(Lo, Hi: Integer; const Comparator: IComparator);
+var
+    I, J, Mid: Integer;
+begin
+    repeat
+        I := Lo;
+        J := Hi;
+        Mid := (Lo + Hi) div 2;
+        repeat
+            while Comparator.Compare(Items[I], Items[Mid]) < 0 do
+                Inc(I);
+            while Comparator.Compare(Items[J], Items[Mid]) > 0 do
+                Dec(J);
+            if I <= J then
+            begin
+                Exchange(I, J);
+                if Mid = I then
+                    Mid := J
+                else if Mid = J then
+                    Mid := I;
+                Inc(I);
+                Dec(J);
+            end;
+        until I > J;
+        if Lo < J then
+            QuickSort(Lo, J, Comparator);
+        Lo := I;
+    until I >= Hi;
+end;
+
+procedure TAbstractList.QuickSort(Lo, Hi: Integer; CompareFunc: TCollectionCompareFunc);
+var
+    I, J, Mid: Integer;
+begin
+    repeat
+        I := Lo;
+        J := Hi;
+        Mid := (Lo + Hi) div 2;
+        repeat
+            while CompareFunc(Items[I], Items[Mid]) < 0 do
+                Inc(I);
+            while CompareFunc(Items[J], Items[Mid]) > 0 do
+                Dec(J);
+            if I <= J then
+            begin
+                Exchange(I, J);
+                if Mid = I then
+                    Mid := J
+                else if Mid = J then
+                    Mid := I;
+                Inc(I);
+                Dec(J);
+            end;
+        until I > J;
+        if Lo < J then
+            QuickSort(Lo, J, CompareFunc);
+        Lo := I;
+    until I >= Hi;
+end;
+
+function TAbstractList.GetDuplicates: Boolean;
+begin
+    Result := FDuplicates;
+end;
+
+procedure TAbstractList.SetDuplicates(Value: Boolean);
+var
+    Iterator: IIterator;
+    Failed: Boolean;
+begin
+    Failed := false;
+    // If trying to set no duplicates, check there are no existing duplicates.
+    if not Value then
+    begin
+        Iterator := GetIterator;
+        while not Iterator.EOF and not Failed do
+        begin
+            Failed := (ItemCount(Iterator.CurrentItem) > 1);
+            Iterator.Next;
+        end;
+        if Failed then
+            CollectionError(ceDuplicate);
+    end;
+    if not Failed then
+        FDuplicates := Value;
+end;
+
+function TAbstractList.GetItem(Index: Integer): ICollectable;
+begin
+    if (Index < 0) or (Index >= Size) then
+    begin
+        CollectionError(ceOutOfRange);
+        Result := nil;
+    end
+    else
+        Result := TrueGetItem(Index);
+end;
+
+procedure TAbstractList.SetItem(Index: Integer; const Item: ICollectable);
+var
+    SearchResult: TSearchResult;
+begin
+    if (Index < 0) or (Index >= Size) then
+    begin
+        CollectionError(ceOutOfRange)
+    end
+    else if not Duplicates then
+    begin
+        // Find any duplicates
+        if Sorted then
+        begin
+            SearchResult := BinarySearch(Item);
+            case SearchResult.ResultType of
+            srBeforeIndex, srAfterEnd: begin        // If item is not present
+                FSorted := false;
+                TrueSetItem(Index, Item);
+            end;
+            srFoundAtIndex: begin                   // If item is already present
+                CollectionError(ceDuplicate);
+            end;
+            end;
+        end
+        else
+        begin
+            // If item is already present
+            if SequentialSearch(Item, Comparator).ResultType = srFoundAtIndex then
+            begin
+                CollectionError(ceDuplicate);
+            end
+            else
+            begin
+                TrueSetItem(Index, Item);
+            end;
+        end;
+    end
+    else
+    begin
+        FSorted := false;
+        TrueSetItem(Index, Item);
+    end;
+end;
+
+function TAbstractList.GetIterator: IIterator;
+begin
+    Result := TAbstractListIterator.Create(Self);
+end;
+
+function TAbstractList.GetNaturalItemIID: TGUID;
+begin
+    Result := ComparableIID;
+end;
+
+function TAbstractList.GetSorted: Boolean;
+begin
+    Result := FSorted;
+end;
+
+procedure TAbstractList.SetSorted(Value: Boolean);
+begin
+    if Value then
+        Sort;
+end;
+
+function TAbstractList.GetType: TCollectionType;
+begin
+    Result := ctList;
+end;
+
+function TAbstractList.BinarySearch(const Item: ICollectable): TSearchResult;
+var
+    Lo, Hi, Mid: Integer;
+    CompareResult: Integer;
+    Success: Boolean;
+begin
+    if Size = 0 then
+    begin
+        Result.ResultType := srAfterEnd;
+        Exit;
+    end;
+    Lo := 0;
+    Hi := Size - 1;
+    Success := false;
+    repeat
+        Mid := (Lo + Hi) div 2;
+        CompareResult := Comparator.Compare(Item, Items[Mid]);
+        if CompareResult = 0 then
+            Success := true
+        else if CompareResult > 0 then
+            Lo := Mid + 1
+        else
+            Hi := Mid - 1;
+    until (Lo > Hi) or Success;
+    if Success then
+    begin
+        // Move index back if in cluster of duplicates
+        while (Mid > 0) and Comparator.Equals(Item, Items[Mid - 1]) do
+            Dec(Mid);
+        Result.ResultType := srFoundAtIndex;
+        Result.Index := Mid;
+    end
+    else if CompareResult < 0 then
+    begin
+        Result.ResultType := srBeforeIndex;
+        Result.Index := Mid;
+    end
+    else if Hi < Size - 1 then
+    begin
+        Result.ResultType := srBeforeIndex;
+        Result.Index := Mid + 1;
+    end
+    else
+        Result.ResultType := srAfterEnd;
+end;
+
+function TAbstractList.CloneAsList: IList;
+begin
+    Result := (TAbstractListClass(ClassType)).Create(Self);
+end;
+
+function TAbstractList.Delete(Index: Integer): ICollectable;
+begin
+    if FixedSize then
+    begin
+        CollectionError(ceFixedSize);
+        Result := nil;
+    end
+    else if (Index < 0) or (Index >= Size) then
+    begin
+        CollectionError(ceOutOfRange);
+        Result := nil;
+    end
+    else
+    begin
+        Result := TrueDelete(Index);
+    end;
+end;
+
+procedure TAbstractList.Exchange(Index1, Index2: Integer);
+var
+    Item: ICollectable;
+begin
+    if (Index1 < 0) or (Index1 >= Size) then
+        CollectionError(ceOutOfRange);
+    if (Index2 < 0) or (Index2 >= Size) then
+        CollectionError(ceOutOfRange);
+    FSorted := false;
+    Item := ICollectable(Items[Index1]);
+    Items[Index1] := Items[Index2];
+    Items[Index2] := Item;
+end;
+
+function TAbstractList.First: ICollectable;
+begin
+    if Size > 0 then
+        Result := Items[0]
+    else
+        Result := nil;
+end;
+
+function TAbstractList.IndexOf(const Item: ICollectable): Integer;
+var
+    SearchResult: TSearchResult;
+begin
+    if Sorted then
+        SearchResult := BinarySearch(Item)
+    else
+        SearchResult := SequentialSearch(Item, Comparator);
+    if SearchResult.ResultType = srFoundAtIndex then
+        Result := SearchResult.Index
+    else
+        Result := -1;
+end;
+
+function TAbstractList.Insert(Index: Integer; const Item: ICollectable): Boolean;
+var
+    ItemError: TCollectionError;
+begin
+    ItemError := ItemAllowed(Item);
+    if ItemError <> ceOK then
+    begin
+        CollectionError(ItemError);
+        Result := false;
+    end
+    else if FixedSize then
+    begin
+        CollectionError(ceFixedSize);
+        Result := false;
+    end
+    else if (Index < 0) or (Index > Size) then
+    begin
+        CollectionError(ceOutOfRange);
+        Result := false;
+    end
+    else
+    begin
+        FSorted := false;
+        if Index = Size then
+            TrueAdd(Item)
+        else
+            TrueInsert(Index, Item);
+        Result := true;
+    end;
+end;
+
+function TAbstractList.Insert(Index: Integer; const ItemArray: array of ICollectable): Integer;
+var
+    Item: ICollectable;
+    ItemError: TCollectionError;
+    I, NewIndex, Count: Integer;
+    Success: Boolean;
+begin
+    Count := 0;
+    if FixedSize then
+    begin
+        CollectionError(ceFixedSize);
+    end
+    else if (Index < 0) or (Index > Size) then
+    begin
+        CollectionError(ceOutOfRange);
+    end
+    else
+    begin
+        // Insert entire array in place in correct order
+        NewIndex := Index;
+        for I := Low(ItemArray) to High(ItemArray) do
+        begin
+            Item := ItemArray[I];
+            ItemError := ItemAllowed(Item);
+            if ItemError <> ceOK then
+            begin
+                CollectionError(ItemError);
+            end
+            else
+            begin
+                Success := Insert(NewIndex, Item);
+                if Success then
+                begin
+                    Inc(NewIndex);
+                    Inc(Count);
+                end;
+            end;
+        end;
+    end;
+    Result := Count;
+end;
+
+function TAbstractList.Insert(Index: Integer; const Collection: ICollection): Integer;
+var
+    Iterator: IIterator;
+    Item: ICollectable;
+    ItemError: TCollectionError;
+    NewIndex, Count: Integer;
+    Success: Boolean;
+begin
+    Count := 0;
+    if FixedSize then
+    begin
+        CollectionError(ceFixedSize);
+    end
+    else if (Index < 0) or (Index > Size) then
+    begin
+        CollectionError(ceOutOfRange);
+    end
+    else
+    begin
+        // Insert entire collection in place in correct order
+        NewIndex := Index;
+        Iterator := Collection.GetIterator;
+        while not Iterator.EOF do
+        begin
+            Item := Iterator.CurrentItem;
+            ItemError := ItemAllowed(Item);
+            if ItemError <> ceOK then
+            begin
+                CollectionError(ItemError);
+            end
+            else
+            begin
+                Success := Insert(NewIndex, Item);
+                if Success then
+                begin
+                    Inc(NewIndex);
+                    Inc(Count);
+                end;
+            end;
+            Iterator.Next;
+        end;
+    end;
+    Result := Count;
+end;
+
+function TAbstractList.IsNilAllowed: Boolean;
+begin
+    Result := true;
+end;
+
+function TAbstractList.Last: ICollectable;
+begin
+    if Size > 0 then
+        Result := Items[Size - 1]
+    else
+        Result := nil;
+end;
+
+function TAbstractList.Search(const Item: ICollectable; const SearchComparator: IComparator = nil): TSearchResult;
+begin
+    if Sorted and (SearchComparator = nil) then
+        Result := BinarySearch(Item)
+    else
+        Result := SequentialSearch(Item, SearchComparator);
+end;
+
+function TAbstractList.SequentialSearch(const Item: ICollectable; const SearchComparator: IComparator): TSearchResult;
+var
+    WorkingComparator: IComparator;
+    I: Integer;
+    Success: Boolean;
+begin
+    if SearchComparator = nil then
+        WorkingComparator := Comparator
+    else
+        WorkingComparator := SearchComparator;
+    Result.ResultType := srNotFound;
+    I := 0;
+    Success := false;
+    while (I < Size) and not Success do
+    begin
+        if WorkingComparator.Equals(Item, Items[I]) then
+        begin
+            Result.ResultType := srFoundAtIndex;
+            Result.Index := I;
+            Success := true;
+        end
+        else
+            Inc(I);
+    end;
+end;
+
+procedure TAbstractList.Sort(const SortComparator: IComparator);
+begin
+    if SortComparator = nil then
+    begin
+        if Size > 0 then
+            QuickSort(0, Size - 1, Comparator);
+        FSorted := true;
+    end
+    else
+    begin
+        if Size > 0 then
+            QuickSort(0, Size - 1, SortComparator);
+        FSorted := false;
+    end;
+end;
+
+procedure TAbstractList.Sort(CompareFunc: TCollectionCompareFunc);
+begin
+    if Size > 0 then
+        QuickSort(0, Size - 1, CompareFunc);
+    FSorted := false;
+end;
+
+{ TAbstractMap }
+constructor TAbstractMap.Create;
+begin
+    Create(false, true);
+end;
+
+constructor TAbstractMap.Create(NaturalItemsOnly: Boolean);
+begin
+    Create(NaturalItemsOnly, true);
+end;
+
+constructor TAbstractMap.Create(NaturalItemsOnly: Boolean; NaturalKeysOnly: Boolean);
+begin
+    inherited Create(NaturalItemsOnly);
+    FNaturalKeysOnly := NaturalKeysOnly or GetAlwaysNaturalKeys;
+    FAssociationComparator := TAssociationComparator.Create(FNaturalKeysOnly);
+    if FNaturalKeysOnly then
+        FKeyComparator := TAbstractComparator.GetNaturalComparator
+    else
+        FKeyComparator := TAbstractComparator.GetDefaultComparator;
+end;
+
+constructor TAbstractMap.Create(const ItemArray: array of ICollectable);
+begin
+    Create(ItemArray, true, true);
+end;
+
+constructor TAbstractMap.Create(const ItemArray: array of ICollectable; NaturalItemsOnly: Boolean);
+begin
+    Create(ItemArray, true, true);
+end;
+
+constructor TAbstractMap.Create(const ItemArray: array of ICollectable; NaturalItemsOnly: Boolean; NaturalKeysOnly: Boolean);
+var
+    I: Integer;
+begin
+    Create(true, NaturalKeysOnly);
+    if not FixedSize then
+    begin
+        Capacity := Length(ItemArray);
+        for I := Low(ItemArray) to High(ItemArray) do
+        begin
+            Add(ItemArray[I]);
+        end;
+    end;
+end;
+
+constructor TAbstractMap.Create(const KeyArray, ItemArray: array of ICollectable);
+begin
+    Create(KeyArray, ItemArray, false, true);
+end;
+
+constructor TAbstractMap.Create(const KeyArray, ItemArray: array of ICollectable; NaturalItemsOnly: Boolean);
+begin
+    Create(KeyArray, ItemArray, NaturalItemsOnly, true);
+end;
+
+constructor TAbstractMap.Create(const KeyArray, ItemArray: array of ICollectable; NaturalItemsOnly: Boolean; NaturalKeysOnly: Boolean);
+var
+    I, Lo, Hi: Integer;
+begin
+    Create(NaturalItemsOnly, NaturalKeysOnly);
+    if not FixedSize then
+    begin
+        Capacity := Min(Length(KeyArray), Length(ItemArray));
+        Lo := Max(Low(KeyArray), Low(ItemArray));
+        Hi := Min(High(KeyArray), High(ItemArray));
+        for I := Lo to Hi do
+        begin
+            Put(KeyArray[I], ItemArray[I]);
+        end;
+    end;
+end;
+
+constructor TAbstractMap.Create(const Map: IMap);
+var
+    MapIterator: IMapIterator;
+begin
+    Create(Map.GetNaturalItemsOnly, Map.GetNaturalKeysOnly);
+    InitFrom(Map);
+    if not FixedSize then
+    begin
+        Capacity := Map.GetSize;
+        MapIterator := Map.GetMapIterator;
+        while not MapIterator.EOF do
+        begin
+            Put(MapIterator.CurrentKey, MapIterator.CurrentItem);
+            MapIterator.Next;
+        end;
+    end;
+end;
+
+destructor TAbstractMap.Destroy;
+begin
+    FKeyComparator := nil;
+    FAssociationComparator := nil;
+    inherited Destroy;
+end;
+
+procedure TAbstractMap.InitFrom(const Collection: ICollection);
+var
+    Map: IMap;
+begin
+    inherited InitFrom(Collection);
+    if Collection.QueryInterface(IMap, Map) = S_OK then
+    begin
+        FNaturalKeysOnly := Map.GetNaturalKeysOnly or GetAlwaysNaturalKeys;
+        KeyComparator := Map.GetKeyComparator;
+    end;
+end;
+
+function TAbstractMap.TrueAdd(const Item: ICollectable): Boolean;
+var
+    Position: TCollectionPosition;
+    Mappable: IMappable;
+begin
+    if IsNaturalItem(Item) then
+    begin
+        Mappable := Item as IMappable;
+        Position := GetKeyPosition(Mappable.GetKey);
+        try
+            if Position.Found then
+            begin
+                CollectionError(ceDuplicateKey);
+                Result := false;
+            end
+            else
+            begin
+                TruePut(Position, TAssociation.Create(Mappable.GetKey, Item));
+                Result := true;
+            end;
+        finally
+            Position.Free;
+        end;
+    end
+    else
+    begin
+        CollectionError(ceNotNaturalItem);
+        Result := false;
+    end;
+end;
+
+function TAbstractMap.TrueContains(const Item: ICollectable): Boolean;
+var
+    Item2: ICollectable;
+    Success: Boolean;
+    Iterator: IIterator;
+begin
+    Iterator := GetIterator;
+    Success := false;
+    while not Iterator.EOF and not Success do
+    begin
+        Item2 := Iterator.CurrentItem;
+        if Comparator.Equals(Item, Item2) then
+            Success := true;
+        Iterator.Next;
+    end;
+    Result := Success;
+end;
+
+function TAbstractMap.TrueRemove(const Item: ICollectable): ICollectable;
+var
+    Item2: ICollectable;
+    Iterator: IMapIterator;
+    Found: Boolean;
+begin
+    // Sequential search
+    Found := false;
+    Result := nil;
+    Iterator := GetAssociationIterator;
+    while not Iterator.EOF and not Found do
+    begin
+        Item2 := Iterator.CurrentItem;
+        if Comparator.Equals(Item, Item2) then
+        begin
+            Result := Item2;
+            Iterator.Remove;
+            Found := true;
+        end;
+        Iterator.Next;
+    end;
+end;
+
+function TAbstractMap.TrueRemoveAll(const Item: ICollectable): ICollection;
+var
+    ResultCollection: ICollection;
+    Item2: ICollectable;
+    Iterator: IMapIterator;
+begin
+    // Sequential search
+    ResultCollection := TPArrayBag.Create(NaturalItemsOnly);
+    Iterator := GetAssociationIterator;
+    while not Iterator.EOF do
+    begin
+        Item2 := Iterator.CurrentItem;
+        if Comparator.Equals(Item, Item2) then
+        begin
+            ResultCollection.Add(Item2);
+            Iterator.Remove;
+        end;
+        Iterator.Next;
+    end;
+    Result := ResultCollection;
+end;
+
+class function TAbstractMap.GetAlwaysNaturalKeys: Boolean;
+begin
+    Result := false;
+end;
+
+function TAbstractMap.GetItem(const Key: ICollectable): ICollectable;
+begin
+    Result := Get(Key);
+end;
+
+procedure TAbstractMap.SetItem(const Key, Item: ICollectable);
+begin
+    Put(Key, Item);
+end;
+
+function TAbstractMap.GetIterator: IIterator;
+begin
+    Result := GetAssociationIterator;
+end;
+
+function TAbstractMap.GetKeyComparator: IComparator;
+begin
+    Result := FKeyComparator;
+end;
+
+procedure TAbstractMap.SetKeyComparator(const Value: IComparator);
+begin
+    FKeyComparator := Value;
+    FAssociationComparator.KeyComparator := Value;
+end;
+
+function TAbstractMap.GetKeyIterator: IIterator;
+begin
+    Result := TAssociationKeyIterator.Create(GetAssociationIterator);
+end;
+
+function TAbstractMap.GetKeys: ISet;
+var
+    ResultCollection: TPArraySet;
+    KeyIterator: IIterator;
+begin
+    ResultCollection := TPArraySet.Create(NaturalKeysOnly);
+    ResultCollection.SetComparator(GetKeyComparator);
+    KeyIterator := GetKeyIterator;
+    while not KeyIterator.EOF do
+    begin
+        ResultCollection.Add(KeyIterator.CurrentItem);
+        KeyIterator.Next;
+    end;
+    Result := ResultCollection;
+end;
+
+function TAbstractMap.GetMapIterator: IMapIterator;
+begin
+    Result := GetAssociationIterator;
+end;
+
+function TAbstractMap.GetMapIteratorByKey(const Filter: IFilter): IMapIterator;
+var
+    Iterator: IMapIterator;
+begin
+    Iterator := GetMapIterator;
+    Result := TKeyFilterMapIterator.Create(Iterator, Filter, Iterator.GetAllowRemoval);
+end;
+
+function TAbstractMap.GetMapIteratorByKey(FilterFunc: TCollectionFilterFunc): IMapIterator;
+var
+    Iterator: IMapIterator;
+begin
+    Iterator := GetMapIterator;
+    Result := TKeyFilterFuncMapIterator.Create(Iterator, FilterFunc, Iterator.GetAllowRemoval);
+end;
+
+function TAbstractMap.GetNaturalItemIID: TGUID;
+begin
+    Result := MappableIID;
+end;
+
+function TAbstractMap.GetNaturalKeyIID: TGUID;
+begin
+    Result := EquatableIID;
+end;
+
+function TAbstractMap.GetNaturalKeysOnly: Boolean;
+begin
+    Result := FNaturalKeysOnly;
+end;
+
+function TAbstractMap.GetType: TCollectionType;
+begin
+    Result := ctMap;
+end;
+
+function TAbstractMap.GetValues: ICollection;
+var
+    ResultCollection: ICollection;
+    ValueIterator: IIterator;
+begin
+    ResultCollection := TPArrayBag.Create(NaturalItemsOnly);
+    ValueIterator := GetIterator;
+    while not ValueIterator.EOF do
+    begin
+        ResultCollection.Add(ValueIterator.CurrentItem);
+        ValueIterator.Next;
+    end;
+    Result := ResultCollection;
+end;
+
+// Overrides TAbstractCollection function, otherwise Create(ICollection) is
+// called, which cannot access keys.
+function TAbstractMap.Clone: ICollection;
+begin
+    Result := (TAbstractMapClass(ClassType)).Create(Self);
+end;
+
+function TAbstractMap.CloneAsMap: IMap;
+begin
+    Result := (TAbstractMapClass(ClassType)).Create(Self);
+end;
+
+function TAbstractMap.ContainsKey(const Key: ICollectable): Boolean;
+var
+    Position: TCollectionPosition;
+begin
+    Position := GetKeyPosition(Key);
+    try
+        Result := Position.Found;
+    finally
+        Position.Free;
+    end;
+end;
+
+function TAbstractMap.ContainsKey(const KeyArray: array of ICollectable): Boolean;
+var
+    I: Integer;
+    Success: Boolean;
+begin
+    Success := true;
+    for I := Low(KeyArray) to High(KeyArray) do
+    begin
+        Success := Success and ContainsKey(KeyArray[I]);
+        if not Success then
+            break;
+    end;
+    Result := Success;
+end;
+
+function TAbstractMap.ContainsKey(const Collection: ICollection): Boolean;
+var
+    Iterator: IIterator;
+    Success: Boolean;
+begin
+    Success := true;
+    Iterator := Collection.GetIterator;
+    while not Iterator.EOF do
+    begin
+        Success := Success and ContainsKey(Iterator.CurrentItem);
+        if not Success then
+            break;
+        Iterator.Next;
+    end;
+    Result := Success;
+end;
+
+function TAbstractMap.Get(const Key: ICollectable): ICollectable;
+var
+    KeyError: TCollectionError;
+    Position: TCollectionPosition;
+begin
+    KeyError := KeyAllowed(Key);
+    if KeyError <> ceOK then
+    begin
+        CollectionError(KeyError);
+        Result := nil;
+    end
+    else
+    begin
+        Position := GetKeyPosition(Key);
+        try
+            if Position.Found then
+                Result := TrueGet(Position).GetValue
+            else
+                Result := nil;
+        finally
+            Position.Free;
+        end;
+    end;
+end;
+
+function TAbstractMap.KeyAllowed(const Key: ICollectable): TCollectionError;
+begin
+    if NaturalKeysOnly and not IsNaturalKey(Key) then
+        Result := ceNotNaturalItem
+    else if Key = nil then
+        Result := ceNilNotAllowed
+    else
+        Result := ceOK;
+end;
+
+function TAbstractMap.IsNaturalKey(const Key: ICollectable): Boolean;
+var
+    Temp: IUnknown;
+begin
+    if Key.QueryInterface(NaturalKeyIID, Temp) <> E_NOINTERFACE then
+        Result := true
+    else
+        Result := false;
+end;
+
+function TAbstractMap.IsNilAllowed: Boolean;
+begin
+    Result := true;
+end;
+
+function TAbstractMap.MatchingKey(const KeyArray: array of ICollectable): ICollection;
+var
+    ResultCollection: ICollection;
+    I: Integer;
+begin
+    ResultCollection := TPArrayBag.Create(NaturalItemsOnly);
+    for I := Low(KeyArray) to High(KeyArray) do
+    begin
+        if ContainsKey(KeyArray[I]) then
+            ResultCollection.Add(KeyArray[I]);
+    end;
+    Result := ResultCollection;
+end;
+
+function TAbstractMap.MatchingKey(const Collection: ICollection): ICollection;
+var
+    ResultCollection: ICollection;
+    Iterator: IIterator;
+begin
+    ResultCollection := TPArrayBag.Create(NaturalItemsOnly);
+    Iterator := Collection.GetIterator;
+    while not Iterator.EOF do
+    begin
+        if ContainsKey(Iterator.CurrentItem) then
+            ResultCollection.Add(Iterator.CurrentItem);
+        Iterator.Next;
+    end;
+    Result := ResultCollection;
+end;
+
+function TAbstractMap.Put(const Item: ICollectable): ICollectable;
+var
+    Mappable: IMappable;
+    OldAssociation, NewAssociation: IAssociation;
+    Position: TCollectionPosition;
+begin
+    if not IsNaturalItem(Item) then
+    begin
+        CollectionError(ceNotNaturalItem);
+        Result := nil;
+    end
+    else
+    begin
+        Item.QueryInterface(IMappable, Mappable);
+        Position := GetKeyPosition(Mappable.GetKey);
+        try
+            NewAssociation := TAssociation.Create(Mappable.GetKey, Item);
+            OldAssociation := TruePut(Position, NewAssociation);
+            if OldAssociation <> nil then
+                Result := OldAssociation.GetValue
+            else
+                Result := nil;
+        finally
+            Position.Free;
+        end;
+    end;
+end;
+
+function TAbstractMap.Put(const Key, Item: ICollectable): ICollectable;
+var
+    OldAssociation, NewAssociation: IAssociation;
+    ItemError, KeyError: TCollectionError;
+    Position: TCollectionPosition;
+begin
+    ItemError := ItemAllowed(Item);
+    KeyError := KeyAllowed(Key);
+    if ItemError <> ceOK then
+    begin
+        CollectionError(ItemError);
+        Result := nil;
+    end
+    else if KeyError <> ceOK then
+    begin
+        CollectionError(KeyError);
+        Result := nil;
+    end
+    else
+    begin
+        // Find appropriate place, then place key-item association there
+        Position := GetKeyPosition(Key);
+        try
+            NewAssociation := TAssociation.Create(Key, Item);
+            OldAssociation := TruePut(Position, NewAssociation);
+            if OldAssociation <> nil then
+                Result := OldAssociation.GetValue
+            else
+                Result := nil;
+        finally
+            Position.Free;
+        end;
+    end;
+end;
+
+function TAbstractMap.Put(const ItemArray: array of ICollectable): ICollection;
+var
+    ResultCollection: ICollection;
+    Mappable: IMappable;
+    OldAssociation, NewAssociation: IAssociation;
+    Position: TCollectionPosition;
+    Item: ICollectable;
+    I: Integer;
+begin
+    ResultCollection := TPArrayBag.Create(NaturalItemsOnly);
+    for I := Low(ItemArray) to High(ItemArray) do
+    begin
+        Item := ItemArray[I];
+        if not IsNaturalItem(Item) then
+        begin
+            CollectionError(ceNotNaturalItem);
+        end
+        else
+        begin
+            // Find appropriate place, then place key-item association there
+            Item.QueryInterface(IMappable, Mappable);
+            Position := GetKeyPosition(Mappable.GetKey);
+            try
+                NewAssociation := TAssociation.Create(Mappable.GetKey, Item);
+                OldAssociation := TruePut(Position, NewAssociation);
+                if OldAssociation <> nil then
+                    ResultCollection.Add(OldAssociation.GetValue);
+            finally
+                Position.Free;
+            end;
+        end;
+    end;
+    Result := ResultCollection;
+end;
+
+function TAbstractMap.Put(const Collection: ICollection): ICollection;
+var
+    ResultCollection: ICollection;
+    Mappable: IMappable;
+    OldAssociation, NewAssociation: IAssociation;
+    Position: TCollectionPosition;
+    Iterator: IIterator;
+    Item: ICollectable;
+begin
+    ResultCollection := TPArrayBag.Create(NaturalItemsOnly);
+    Iterator := Collection.GetIterator;
+    while not Iterator.EOF do
+    begin
+        Item := Iterator.CurrentItem;;
+        if not IsNaturalItem(Item) then
+        begin
+            CollectionError(ceNotNaturalItem);
+        end
+        else
+        begin
+            // Find appropriate place, then place key-item association there
+            Item.QueryInterface(IMappable, Mappable);
+            Position := GetKeyPosition(Mappable.GetKey);
+            try
+                NewAssociation := TAssociation.Create(Mappable.GetKey, Item);
+                OldAssociation := TruePut(Position, NewAssociation);
+                if OldAssociation <> nil then
+                    ResultCollection.Add(OldAssociation.GetValue);
+            finally
+                Position.Free;
+            end;
+        end;
+        Iterator.Next;
+    end;
+    Result := ResultCollection;
+end;
+
+function TAbstractMap.Put(const Map: IMap): ICollection;
+var
+    ResultCollection: ICollection;
+    OldAssociation, NewAssociation: IAssociation;
+    ItemError, KeyError: TCollectionError;
+    Position: TCollectionPosition;
+    MapIterator: IMapIterator;
+    Key, Item: ICollectable;
+begin
+    ResultCollection := TPArrayBag.Create(NaturalItemsOnly);
+    MapIterator := Map.GetMapIterator;
+    while not MapIterator.EOF do
+    begin
+        Key := MapIterator.CurrentKey;
+        Item := MapIterator.CurrentItem;
+
+        ItemError := ItemAllowed(Item);
+        KeyError := KeyAllowed(Key);
+        if ItemError <> ceOK then
+        begin
+            CollectionError(ItemError);
+        end
+        else if KeyError <> ceOK then
+        begin
+            CollectionError(KeyError);
+        end
+        else
+        begin
+            // Find appropriate place, then place key-item association there
+            Position := GetKeyPosition(Key);
+            try
+                NewAssociation := TAssociation.Create(Key, Item);
+                OldAssociation := TruePut(Position, NewAssociation);
+                if OldAssociation <> nil then
+                    ResultCollection.Add(OldAssociation.GetValue);
+            finally
+                Position.Free;
+            end;
+        end;
+        MapIterator.Next;
+    end;
+    Result := ResultCollection;
+end;
+
+function TAbstractMap.RemoveKey(const Key: ICollectable): ICollectable;
+var
+    KeyError: TCollectionError;
+    Position: TCollectionPosition;
+    OldAssociation: IAssociation;
+begin
+    KeyError := KeyAllowed(Key);
+    if KeyError <> ceOK then
+    begin
+        CollectionError(KeyError);
+        Result := nil;
+    end
+    else
+    begin
+        Position := GetKeyPosition(Key);
+        try
+            if Position.Found then
+            begin
+                OldAssociation := TrueRemove2(Position);
+                Result := OldAssociation.GetValue
+            end
+            else
+                Result := nil;
+        finally
+            Position.Free;
+        end;
+    end;
+end;
+
+function TAbstractMap.RemoveKey(const KeyArray: array of ICollectable): ICollection;
+var
+    ResultCollection: ICollection;
+    OldAssociation: IAssociation;
+    KeyError: TCollectionError;
+    Position: TCollectionPosition;
+    Key: ICollectable;
+    I: Integer;
+begin
+    ResultCollection := TPArrayBag.Create(NaturalItemsOnly);
+    for I := Low(KeyArray) to High(KeyArray) do
+    begin
+        Key := KeyArray[I];
+        KeyError := KeyAllowed(Key);
+        if KeyError <> ceOK then
+        begin
+            CollectionError(KeyError);
+        end
+        else
+        begin
+            Position := GetKeyPosition(Key);
+            try
+                if Position.Found then
+                begin
+                    OldAssociation := TrueRemove2(Position);
+                    ResultCollection.Add(OldAssociation.GetValue);
+                end;
+            finally
+                Position.Free;
+            end;
+        end;
+    end;
+    Result := ResultCollection;
+end;
+
+function TAbstractMap.RemoveKey(const Collection: ICollection): ICollection;
+var
+    ResultCollection: ICollection;
+    OldAssociation: IAssociation;
+    KeyError: TCollectionError;
+    Position: TCollectionPosition;
+    Key: ICollectable;
+    Iterator: IIterator;
+begin
+    ResultCollection := TPArrayBag.Create(NaturalItemsOnly);
+    Iterator := Collection.GetIterator;
+    while not Iterator.EOF do
+    begin
+        Key := Iterator.CurrentItem;
+        KeyError := KeyAllowed(Key);
+        if KeyError <> ceOK then
+        begin
+            CollectionError(KeyError);
+        end
+        else
+        begin
+            Position := GetKeyPosition(Key);
+            try
+                if Position.Found then
+                begin
+                    OldAssociation := TrueRemove2(Position);
+                    ResultCollection.Add(OldAssociation.GetValue);
+                end;
+            finally
+                Position.Free;
+            end;
+        end;
+        Iterator.Next;
+    end;
+    Result := ResultCollection;
+end;
+
+function TAbstractMap.RetainKey(const KeyArray: array of ICollectable): ICollection;
+var
+    ResultCollection: ICollection;
+    MapIterator: IMapIterator;
+    I: Integer;
+    Found: Boolean;
+begin
+    ResultCollection := TPArrayBag.Create(NaturalItemsOnly);
+    if FixedSize then
+    begin
+        CollectionError(ceFixedSize);
+    end
+    else
+    begin
+        MapIterator := GetMapIterator;
+        while not MapIterator.EOF do
+        begin
+            // Converting the array to a map would be faster but I don't want to
+            // couple base class code to a complex collection.
+            Found := false;
+            for I := Low(KeyArray) to High(KeyArray) do
+            begin
+                Found := KeyComparator.Equals(MapIterator.CurrentKey, KeyArray[I]);
+                if Found then
+                    break;
+            end;
+            if not Found then
+            begin
+                ResultCollection.Add(MapIterator.CurrentItem);
+                MapIterator.Remove;
+            end;
+            MapIterator.Next;
+        end;
+        Result := ResultCollection;
+    end;
+end;
+
+function TAbstractMap.RetainKey(const Collection: ICollection): ICollection;
+var
+    ResultCollection: ICollection;
+    MapIterator: IMapIterator;
+    Key: ICollectable;
+begin
+    ResultCollection := TPArrayBag.Create(NaturalItemsOnly);
+    if FixedSize then
+    begin
+        CollectionError(ceFixedSize);
+    end
+    else
+    begin
+        MapIterator := GetMapIterator;
+        while not MapIterator.EOF do
+        begin
+            Key := MapIterator.CurrentKey;
+            if not Collection.Contains(Key) then
+            begin
+                ResultCollection.Add(MapIterator.CurrentItem);
+                MapIterator.Remove;
+            end;
+            MapIterator.Next;
+        end;
+    end;
+    Result := ResultCollection;
+end;
+
+
+{ TAbstractIntegerMap }
+constructor TAbstractIntegerMap.Create(NaturalItemsOnly: Boolean);
+begin
+    inherited Create(NaturalItemsOnly);
+    FAssociationComparator := TIntegerAssociationComparator.Create;
+end;
+
+constructor TAbstractIntegerMap.Create(const ItemArray: array of ICollectable);
+begin
+    Create(ItemArray, true);
+end;
+
+constructor TAbstractIntegerMap.Create(const ItemArray: array of ICollectable; NaturalItemsOnly: Boolean);
+begin
+    inherited Create(ItemArray, true);
+end;
+
+constructor TAbstractIntegerMap.Create(const KeyArray: array of Integer; const ItemArray: array of ICollectable);
+begin
+    Create(KeyArray, ItemArray, false);
+end;
+
+constructor TAbstractIntegerMap.Create(const KeyArray: array of Integer; const ItemArray: array of ICollectable; NaturalItemsOnly: Boolean);
+var
+    I, Lo, Hi: Integer;
+begin
+    Create(NaturalItemsOnly);
+    Capacity := Min(Length(KeyArray), Length(ItemArray));
+    if not FixedSize then
+    begin
+        Lo := Max(Low(KeyArray), Low(ItemArray));
+        Hi := Min(High(KeyArray), High(ItemArray));
+        for I := Lo to Hi do
+        begin
+            Put(KeyArray[I], ItemArray[I]);
+        end;
+    end;
+end;
+
+constructor TAbstractIntegerMap.Create(const Map: IIntegerMap);
+var
+    MapIterator: IIntegerMapIterator;
+begin
+    Create(Map.GetNaturalItemsOnly);
+    InitFrom(Map);
+    Capacity := Map.GetSize;
+    if not FixedSize then
+    begin
+        MapIterator := Map.GetMapIterator;
+        while not MapIterator.EOF do
+        begin
+            Put(MapIterator.CurrentKey, MapIterator.CurrentItem);
+            MapIterator.Next;
+        end;
+    end;
+end;
+
+destructor TAbstractIntegerMap.Destroy;
+begin
+    FAssociationComparator := nil;
+    inherited Destroy;
+end;
+
+function TAbstractIntegerMap.TrueAdd(const Item: ICollectable): Boolean;
+var
+    Position: TCollectionPosition;
+    Mappable: IIntegerMappable;
+begin
+    if IsNaturalItem(Item) then
+    begin
+        Mappable := Item as IIntegerMappable;
+        Position := GetKeyPosition(Mappable.GetKey);
+        try
+            if Position.Found then
+            begin
+                CollectionError(ceDuplicateKey);
+                Result := false;
+            end
+            else
+            begin
+                TruePut(Position, TIntegerAssociation.Create(Mappable.GetKey, Item));
+                Result := true;
+            end;
+        finally
+            Position.Free;
+        end;
+    end
+    else
+    begin
+        CollectionError(ceNotNaturalItem);
+        Result := false;
+    end;
+end;
+
+function TAbstractIntegerMap.TrueContains(const Item: ICollectable): Boolean;
+var
+    Item2: ICollectable;
+    Success: Boolean;
+    Iterator: IIterator;
+begin
+    Iterator := GetIterator;
+    Success := false;
+    while not Iterator.EOF and not Success do
+    begin
+        Item2 := Iterator.CurrentItem;
+        if Comparator.Equals(Item, Item2) then
+            Success := true;
+        Iterator.Next;
+    end;
+    Result := Success;
+end;
+
+function TAbstractIntegerMap.TrueRemove(const Item: ICollectable): ICollectable;
+var
+    Item2: ICollectable;
+    Iterator: IIntegerMapIterator;
+    Found: Boolean;
+begin
+    // Sequential search
+    Found := false;
+    Result := nil;
+    Iterator := GetAssociationIterator;
+    while not Iterator.EOF and not Found do
+    begin
+        Item2 := Iterator.CurrentItem;
+        if Comparator.Equals(Item, Item2) then
+        begin
+            Result := Item2;
+            Iterator.Remove;
+            Found := true;
+        end;
+        Iterator.Next;
+    end;
+end;
+
+function TAbstractIntegerMap.TrueRemoveAll(const Item: ICollectable): ICollection;
+var
+    ResultCollection: ICollection;
+    Item2: ICollectable;
+    Iterator: IIntegerMapIterator;
+begin
+    // Sequential search
+    ResultCollection := TPArrayBag.Create(NaturalItemsOnly);
+    Iterator := GetAssociationIterator;
+    while not Iterator.EOF do
+    begin
+        Item2 := Iterator.CurrentItem;
+        if Comparator.Equals(Item, Item2) then
+        begin
+            ResultCollection.Add(Item2);
+            Iterator.Remove;
+        end;
+        Iterator.Next;
+    end;
+    Result := ResultCollection;
+end;
+
+function TAbstractIntegerMap.GetItem(const Key: Integer): ICollectable;
+begin
+    Result := Get(Key);
+end;
+
+procedure TAbstractIntegerMap.SetItem(const Key: Integer; const Item: ICollectable);
+begin
+    Put(Key, Item);
+end;
+
+function TAbstractIntegerMap.GetIterator: IIterator;
+begin
+    Result := GetAssociationIterator;
+end;
+
+function TAbstractIntegerMap.GetKeys: ISet;
+var
+    ResultCollection: TPArraySet;
+    MapIterator: IIntegerMapIterator;
+begin
+    ResultCollection := TPArraySet.Create(true);
+    MapIterator := GetMapIterator;
+    while not MapIterator.EOF do
+    begin
+        ResultCollection.Add(TIntegerWrapper.Create(MapIterator.CurrentKey) as ICollectable);
+        MapIterator.Next;
+    end;
+    Result := ResultCollection;
+end;
+
+function TAbstractIntegerMap.GetMapIterator: IIntegerMapIterator;
+begin
+    Result := GetAssociationIterator;
+end;
+
+function TAbstractIntegerMap.GetNaturalItemIID: TGUID;
+begin
+    Result := IntegerMappableIID;
+end;
+
+function TAbstractIntegerMap.GetType: TCollectionType;
+begin
+    Result := ctIntegerMap;
+end;
+
+function TAbstractIntegerMap.GetValues: ICollection;
+var
+    ResultCollection: ICollection;
+    ValueIterator: IIterator;
+begin
+    ResultCollection := TPArrayBag.Create(NaturalItemsOnly);
+    ValueIterator := GetIterator;
+    while not ValueIterator.EOF do
+    begin
+        ResultCollection.Add(ValueIterator.CurrentItem);
+        ValueIterator.Next;
+    end;
+    Result := ResultCollection;
+end;
+
+// Overrides TAbstractCollection function, otherwise Create(ICollection) is
+// called, which cannot access keys.
+function TAbstractIntegerMap.Clone: ICollection;
+begin
+    Result := (TAbstractIntegerMapClass(ClassType)).Create(Self);
+end;
+
+function TAbstractIntegerMap.CloneAsIntegerMap: IIntegerMap;
+begin
+    Result := (TAbstractIntegerMapClass(ClassType)).Create(Self);
+end;
+
+function TAbstractIntegerMap.ContainsKey(const Key: Integer): Boolean;
+var
+    Position: TCollectionPosition;
+begin
+    Position := GetKeyPosition(Key);
+    try
+        Result := Position.Found;
+    finally
+        Position.Free;
+    end;
+end;
+
+function TAbstractIntegerMap.ContainsKey(const KeyArray: array of Integer): Boolean;
+var
+    I: Integer;
+    Success: Boolean;
+begin
+    Success := true;
+    for I := Low(KeyArray) to High(KeyArray) do
+    begin
+        Success := Success and ContainsKey(KeyArray[I]);
+        if not Success then
+            break;
+    end;
+    Result := Success;
+end;
+
+function TAbstractIntegerMap.Get(const Key: Integer): ICollectable;
+var
+    Position: TCollectionPosition;
+begin
+    Position := GetKeyPosition(Key);
+    try
+        if Position.Found then
+            Result := TrueGet(Position).GetValue
+        else
+            Result := nil;
+    finally
+        Position.Free;
+    end;
+end;
+
+function TAbstractIntegerMap.IsNilAllowed: Boolean;
+begin
+    Result := true;
+end;
+
+function TAbstractIntegerMap.Put(const Item: ICollectable): ICollectable;
+var
+    Mappable: IIntegerMappable;
+    OldAssociation, NewAssociation: IIntegerAssociation;
+    Position: TCollectionPosition;
+begin
+    if not IsNaturalItem(Item) then
+    begin
+        CollectionError(ceNotNaturalItem);
+        Result := nil;
+    end
+    else
+    begin
+        Item.QueryInterface(IIntegerMappable, Mappable);
+        Position := GetKeyPosition(Mappable.GetKey);
+        try
+            NewAssociation := TIntegerAssociation.Create(Mappable.GetKey, Item);
+            OldAssociation := TruePut(Position, NewAssociation);
+            if OldAssociation <> nil then
+                Result := OldAssociation.GetValue
+            else
+                Result := nil;
+        finally
+            Position.Free;
+        end;
+    end;
+end;
+
+function TAbstractIntegerMap.Put(const Key: Integer; const Item: ICollectable): ICollectable;
+var
+    OldAssociation, NewAssociation: IIntegerAssociation;
+    ItemError: TCollectionError;
+    Position: TCollectionPosition;
+begin
+    ItemError := ItemAllowed(Item);
+    if ItemError <> ceOK then
+    begin
+        CollectionError(ItemError);
+        Result := nil;
+    end
+    else
+    begin
+        Position := GetKeyPosition(Key);
+        try
+            NewAssociation := TIntegerAssociation.Create(Key, Item);
+            OldAssociation := TruePut(Position, NewAssociation);
+            if OldAssociation <> nil then
+                Result := OldAssociation.GetValue
+            else
+                Result := nil;
+        finally
+            Position.Free;
+        end;
+    end;
+end;
+
+function TAbstractIntegerMap.Put(const ItemArray: array of ICollectable): ICollection;
+var
+    ResultCollection: ICollection;
+    Mappable: IIntegerMappable;
+    OldAssociation, NewAssociation: IIntegerAssociation;
+    Position: TCollectionPosition;
+    Item: ICollectable;
+    I: Integer;
+begin
+    ResultCollection := TPArrayBag.Create(NaturalItemsOnly);
+    for I := Low(ItemArray) to High(ItemArray) do
+    begin
+        Item := ItemArray[I];
+        if not IsNaturalItem(Item) then
+        begin
+            CollectionError(ceNotNaturalItem);
+        end
+        else
+        begin
+            Item.QueryInterface(IIntegerMappable, Mappable);
+            Position := GetKeyPosition(Mappable.GetKey);
+            try
+                NewAssociation := TIntegerAssociation.Create(Mappable.GetKey, Item);
+                OldAssociation := TruePut(Position, NewAssociation);
+                if OldAssociation <> nil then
+                    ResultCollection.Add(OldAssociation.GetValue);
+            finally
+                Position.Free;
+            end;
+        end;
+    end;
+    Result := ResultCollection;
+end;
+
+function TAbstractIntegerMap.Put(const Collection: ICollection): ICollection;
+var
+    ResultCollection: ICollection;
+    Mappable: IIntegerMappable;
+    OldAssociation, NewAssociation: IIntegerAssociation;
+    Position: TCollectionPosition;
+    Iterator: IIterator;
+    Item: ICollectable;
+begin
+    ResultCollection := TPArrayBag.Create(NaturalItemsOnly);
+    Iterator := Collection.GetIterator;
+    while not Iterator.EOF do
+    begin
+        Item := Iterator.CurrentItem;;
+        if not IsNaturalItem(Item) then
+        begin
+            CollectionError(ceNotNaturalItem);
+        end
+        else
+        begin
+            Item.QueryInterface(IIntegerMappable, Mappable);
+            Position := GetKeyPosition(Mappable.GetKey);
+            try
+                NewAssociation := TIntegerAssociation.Create(Mappable.GetKey, Item);
+                OldAssociation := TruePut(Position, NewAssociation);
+                if OldAssociation <> nil then
+                    ResultCollection.Add(OldAssociation.GetValue);
+            finally
+                Position.Free;
+            end;
+        end;
+        Iterator.Next;
+    end;
+    Result := ResultCollection;
+end;
+
+function TAbstractIntegerMap.Put(const Map: IIntegerMap): ICollection;
+var
+    ResultCollection: ICollection;
+    OldAssociation, NewAssociation: IIntegerAssociation;
+    ItemError: TCollectionError;
+    Position: TCollectionPosition;
+    MapIterator: IIntegerMapIterator;
+    Item: ICollectable;
+    Key: Integer;
+begin
+    ResultCollection := TPArrayBag.Create(NaturalItemsOnly);
+    MapIterator := Map.GetMapIterator;
+    while not MapIterator.EOF do
+    begin
+        Key := MapIterator.CurrentKey;
+        Item := MapIterator.CurrentItem;
+
+        ItemError := ItemAllowed(Item);
+        if ItemError <> ceOK then
+        begin
+            CollectionError(ItemError);
+        end
+        else
+        begin
+            Position := GetKeyPosition(Key);
+            try
+                NewAssociation := TIntegerAssociation.Create(Key, Item);
+                OldAssociation := TruePut(Position, NewAssociation);
+                if OldAssociation <> nil then
+                    ResultCollection.Add(OldAssociation.GetValue);
+            finally
+                Position.Free;
+            end;
+        end;
+        MapIterator.Next;
+    end;
+    Result := ResultCollection;
+end;
+
+function TAbstractIntegerMap.RemoveKey(const Key: Integer): ICollectable;
+var
+    Position: TCollectionPosition;
+    OldAssociation: IIntegerAssociation;
+begin
+    Position := GetKeyPosition(Key);
+    try
+        if Position.Found then
+        begin
+            OldAssociation := TrueRemove2(Position);
+            Result := OldAssociation.GetValue
+        end
+        else
+            Result := nil;
+    finally
+        Position.Free;
+    end;
+end;
+
+function TAbstractIntegerMap.RemoveKey(const KeyArray: array of Integer): ICollection;
+var
+    ResultCollection: ICollection;
+    OldAssociation: IIntegerAssociation;
+    Position: TCollectionPosition;
+    Key: Integer;
+    I: Integer;
+begin
+    ResultCollection := TPArrayBag.Create(NaturalItemsOnly);
+    for I := Low(KeyArray) to High(KeyArray) do
+    begin
+        Key := KeyArray[I];
+        Position := GetKeyPosition(Key);
+        try
+            if Position.Found then
+            begin
+                OldAssociation := TrueRemove2(Position);
+                ResultCollection.Add(OldAssociation.GetValue);
+            end;
+        finally
+            Position.Free;
+        end;
+    end;
+    Result := ResultCollection;
+end;
+
+function TAbstractIntegerMap.RetainKey(const KeyArray: array of Integer): ICollection;
+var
+    ResultCollection: ICollection;
+    MapIterator: IIntegerMapIterator;
+    I: Integer;
+    Found: Boolean;
+begin
+    ResultCollection := TPArrayBag.Create(NaturalItemsOnly);
+    if FixedSize then
+    begin
+        CollectionError(ceFixedSize);
+    end
+    else
+    begin
+        MapIterator := GetMapIterator;
+        while not MapIterator.EOF do
+        begin
+            // Converting the array to a map would be faster but I don't want to
+            // couple base class code to a complex collection.
+            Found := false;
+            for I := Low(KeyArray) to High(KeyArray) do
+            begin
+                Found := (MapIterator.CurrentKey = KeyArray[I]);
+                if Found then
+                    break;
+            end;
+            if not Found then
+            begin
+                ResultCollection.Add(MapIterator.CurrentItem);
+                MapIterator.Remove;
+            end;
+            MapIterator.Next;
+        end;
+        Result := ResultCollection;
+    end;
+end;
+
+
+{ TAbstractStringMap }
+constructor TAbstractStringMap.Create(NaturalItemsOnly: Boolean);
+begin
+    inherited Create(NaturalItemsOnly);
+    FAssociationComparator := TStringAssociationComparator.Create;
+end;
+
+constructor TAbstractStringMap.Create(const ItemArray: array of ICollectable);
+begin
+    Create(ItemArray, true);
+end;
+
+constructor TAbstractStringMap.Create(const ItemArray: array of ICollectable; NaturalItemsOnly: Boolean);
+begin
+    inherited Create(ItemArray, true);
+end;
+
+constructor TAbstractStringMap.Create(const KeyArray: array of String; const ItemArray: array of ICollectable);
+begin
+    Create(KeyArray, ItemArray, false);
+end;
+
+constructor TAbstractStringMap.Create(const KeyArray: array of String; const ItemArray: array of ICollectable; NaturalItemsOnly: Boolean);
+var
+    I, Lo, Hi: Integer;
+begin
+    Create(NaturalItemsOnly);
+    Capacity := Min(Length(KeyArray), Length(ItemArray));
+    if not FixedSize then
+    begin
+        Lo := Max(Low(KeyArray), Low(ItemArray));
+        Hi := Min(High(KeyArray), High(ItemArray));
+        for I := Lo to Hi do
+        begin
+            Put(KeyArray[I], ItemArray[I]);
+        end;
+    end;
+end;
+
+constructor TAbstractStringMap.Create(const Map: IStringMap);
+var
+    MapIterator: IStringMapIterator;
+begin
+    Create(Map.GetNaturalItemsOnly);
+    InitFrom(Map);
+    Capacity := Map.GetSize;
+    if not FixedSize then
+    begin
+        MapIterator := Map.GetMapIterator;
+        while not MapIterator.EOF do
+        begin
+            Put(MapIterator.CurrentKey, MapIterator.CurrentItem);
+            MapIterator.Next;
+        end;
+    end;
+end;
+
+destructor TAbstractStringMap.Destroy;
+begin
+    FAssociationComparator := nil;
+    inherited Destroy;
+end;
+
+function TAbstractStringMap.TrueAdd(const Item: ICollectable): Boolean;
+var
+    Position: TCollectionPosition;
+    Mappable: IStringMappable;
+begin
+    if IsNaturalItem(Item) then
+    begin
+        Mappable := Item as IStringMappable;
+        Position := GetKeyPosition(Mappable.GetKey);
+        try
+            if Position.Found then
+            begin
+                CollectionError(ceDuplicateKey);
+                Result := false;
+            end
+            else
+            begin
+                TruePut(Position, TStringAssociation.Create(Mappable.GetKey, Item));
+                Result := true;
+            end;
+        finally
+            Position.Free;
+        end;
+    end
+    else
+    begin
+        CollectionError(ceNotNaturalItem);
+        Result := false;
+    end;
+end;
+
+function TAbstractStringMap.TrueContains(const Item: ICollectable): Boolean;
+var
+    Item2: ICollectable;
+    Success: Boolean;
+    Iterator: IIterator;
+begin
+    Iterator := GetIterator;
+    Success := false;
+    while not Iterator.EOF and not Success do
+    begin
+        Item2 := Iterator.CurrentItem;
+        if Comparator.Equals(Item, Item2) then
+            Success := true;
+        Iterator.Next;
+    end;
+    Result := Success;
+end;
+
+function TAbstractStringMap.TrueRemove(const Item: ICollectable): ICollectable;
+var
+    Item2: ICollectable;
+    Iterator: IStringMapIterator;
+    Found: Boolean;
+begin
+    // Sequential search
+    Found := false;
+    Result := nil;
+    Iterator := GetAssociationIterator;
+    while not Iterator.EOF and not Found do
+    begin
+        Item2 := Iterator.CurrentItem;
+        if Comparator.Equals(Item, Item2) then
+        begin
+            Result := Item2;
+            Iterator.Remove;
+            Found := true;
+        end;
+        Iterator.Next;
+    end;
+end;
+
+function TAbstractStringMap.TrueRemoveAll(const Item: ICollectable): ICollection;
+var
+    ResultCollection: ICollection;
+    Item2: ICollectable;
+    Iterator: IIterator;
+begin
+    // Sequential search
+    ResultCollection := TPArrayBag.Create(NaturalItemsOnly);
+    Iterator := GetAssociationIterator;
+    while not Iterator.EOF do
+    begin
+        Item2 := Iterator.CurrentItem;
+        if Comparator.Equals(Item, Item2) then
+        begin
+            ResultCollection.Add(Item2);
+            Iterator.Remove;
+        end;
+        Iterator.Next;
+    end;
+    Result := ResultCollection;
+end;
+
+function TAbstractStringMap.GetItem(const Key: String): ICollectable;
+begin
+    Result := Get(Key);
+end;
+
+procedure TAbstractStringMap.SetItem(const Key: String; const Item: ICollectable);
+begin
+    Put(Key, Item);
+end;
+
+function TAbstractStringMap.GetIterator: IIterator;
+begin
+    Result := GetAssociationIterator;
+end;
+
+function TAbstractStringMap.GetKeys: ISet;
+var
+    ResultCollection: TPArraySet;
+    MapIterator: IStringMapIterator;
+begin
+    ResultCollection := TPArraySet.Create(true);
+    MapIterator := GetMapIterator;
+    while not MapIterator.EOF do
+    begin
+        ResultCollection.Add(TStringWrapper.Create(MapIterator.CurrentKey) as ICollectable);
+        MapIterator.Next;
+    end;
+    Result := ResultCollection;
+end;
+
+function TAbstractStringMap.GetMapIterator: IStringMapIterator;
+begin
+    Result := GetAssociationIterator;
+end;
+
+function TAbstractStringMap.GetNaturalItemIID: TGUID;
+begin
+    Result := StringMappableIID;
+end;
+
+function TAbstractStringMap.GetType: TCollectionType;
+begin
+    Result := ctStringMap;
+end;
+
+function TAbstractStringMap.GetValues: ICollection;
+var
+    ResultCollection: ICollection;
+    ValueIterator: IIterator;
+begin
+    ResultCollection := TPArrayBag.Create(NaturalItemsOnly);
+    ValueIterator := GetIterator;
+    while not ValueIterator.EOF do
+    begin
+        ResultCollection.Add(ValueIterator.CurrentItem);
+        ValueIterator.Next;
+    end;
+    Result := ResultCollection;
+end;
+
+// Overrides TAbstractCollection function, otherwise Create(ICollection) is
+// called, which cannot access keys.
+function TAbstractStringMap.Clone: ICollection;
+begin
+    Result := (TAbstractStringMapClass(ClassType)).Create(Self);
+end;
+
+function TAbstractStringMap.CloneAsStringMap: IStringMap;
+begin
+    Result := (TAbstractStringMapClass(ClassType)).Create(Self);
+end;
+
+function TAbstractStringMap.ContainsKey(const Key: String): Boolean;
+var
+    Position: TCollectionPosition;
+begin
+    Position := GetKeyPosition(Key);
+    try
+        Result := Position.Found;
+    finally
+        Position.Free;
+    end;
+end;
+
+function TAbstractStringMap.ContainsKey(const KeyArray: array of String): Boolean;
+var
+    I: Integer;
+    Success: Boolean;
+begin
+    Success := true;
+    for I := Low(KeyArray) to High(KeyArray) do
+    begin
+        Success := Success and ContainsKey(KeyArray[I]);
+        if not Success then
+            break;
+    end;
+    Result := Success;
+end;
+
+function TAbstractStringMap.Get(const Key: String): ICollectable;
+var
+    Position: TCollectionPosition;
+begin
+    Position := GetKeyPosition(Key);
+    try
+        if Position.Found then
+            Result := TrueGet(Position).GetValue
+        else
+            Result := nil;
+    finally
+        Position.Free;
+    end;
+end;
+
+function TAbstractStringMap.IsNilAllowed: Boolean;
+begin
+    Result := true;
+end;
+
+function TAbstractStringMap.Put(const Item: ICollectable): ICollectable;
+var
+    Mappable: IStringMappable;
+    OldAssociation, NewAssociation: IStringAssociation;
+    Position: TCollectionPosition;
+begin
+    if not IsNaturalItem(Item) then
+    begin
+        CollectionError(ceNotNaturalItem);
+        Result := nil;
+    end
+    else
+    begin
+        Item.QueryInterface(IStringMappable, Mappable);
+        Position := GetKeyPosition(Mappable.GetKey);
+        try
+            NewAssociation := TStringAssociation.Create(Mappable.GetKey, Item);
+            OldAssociation := TruePut(Position, NewAssociation);
+            if OldAssociation <> nil then
+                Result := OldAssociation.GetValue
+            else
+                Result := nil;
+        finally
+            Position.Free;
+        end;
+    end;
+end;
+
+function TAbstractStringMap.Put(const Key: String; const Item: ICollectable): ICollectable;
+var
+    OldAssociation, NewAssociation: IStringAssociation;
+    ItemError: TCollectionError;
+    Position: TCollectionPosition;
+begin
+    ItemError := ItemAllowed(Item);
+    if ItemError <> ceOK then
+    begin
+        CollectionError(ItemError);
+        Result := nil;
+    end
+    else
+    begin
+        Position := GetKeyPosition(Key);
+        try
+            NewAssociation := TStringAssociation.Create(Key, Item);
+            OldAssociation := TruePut(Position, NewAssociation);
+            if OldAssociation <> nil then
+                Result := OldAssociation.GetValue
+            else
+                Result := nil;
+        finally
+            Position.Free;
+        end;
+    end;
+end;
+
+function TAbstractStringMap.Put(const ItemArray: array of ICollectable): ICollection;
+var
+    ResultCollection: ICollection;
+    Mappable: IStringMappable;
+    OldAssociation, NewAssociation: IStringAssociation;
+    Position: TCollectionPosition;
+    Item: ICollectable;
+    I: Integer;
+begin
+    ResultCollection := TPArrayBag.Create(NaturalItemsOnly);
+    for I := Low(ItemArray) to High(ItemArray) do
+    begin
+        Item := ItemArray[I];
+        if not IsNaturalItem(Item) then
+        begin
+            CollectionError(ceNotNaturalItem);
+        end
+        else
+        begin
+            Item.QueryInterface(IStringMappable, Mappable);
+            Position := GetKeyPosition(Mappable.GetKey);
+            try
+                NewAssociation := TStringAssociation.Create(Mappable.GetKey, Item);
+                OldAssociation := TruePut(Position, NewAssociation);
+                if OldAssociation <> nil then
+                    ResultCollection.Add(OldAssociation.GetValue);
+            finally
+                Position.Free;
+            end;
+        end;
+    end;
+    Result := ResultCollection;
+end;
+
+function TAbstractStringMap.Put(const Collection: ICollection): ICollection;
+var
+    ResultCollection: ICollection;
+    Mappable: IStringMappable;
+    OldAssociation, NewAssociation: IStringAssociation;
+    Position: TCollectionPosition;
+    Iterator: IIterator;
+    Item: ICollectable;
+begin
+    ResultCollection := TPArrayBag.Create(NaturalItemsOnly);
+    Iterator := Collection.GetIterator;
+    while not Iterator.EOF do
+    begin
+        Item := Iterator.CurrentItem;;
+        if not IsNaturalItem(Item) then
+        begin
+            CollectionError(ceNotNaturalItem);
+        end
+        else
+        begin
+            Item.QueryInterface(IStringMappable, Mappable);
+            Position := GetKeyPosition(Mappable.GetKey);
+            try
+                NewAssociation := TStringAssociation.Create(Mappable.GetKey, Item);
+                OldAssociation := TruePut(Position, NewAssociation);
+                if OldAssociation <> nil then
+                    ResultCollection.Add(OldAssociation.GetValue);
+            finally
+                Position.Free;
+            end;
+        end;
+        Iterator.Next;
+    end;
+    Result := ResultCollection;
+end;
+
+function TAbstractStringMap.Put(const Map: IStringMap): ICollection;
+var
+    ResultCollection: ICollection;
+    OldAssociation, NewAssociation: IStringAssociation;
+    ItemError: TCollectionError;
+    Position: TCollectionPosition;
+    MapIterator: IStringMapIterator;
+    Item: ICollectable;
+    Key: String;
+begin
+    ResultCollection := TPArrayBag.Create(NaturalItemsOnly);
+    MapIterator := Map.GetMapIterator;
+    while not MapIterator.EOF do
+    begin
+        Key := MapIterator.CurrentKey;
+        Item := MapIterator.CurrentItem;
+
+        ItemError := ItemAllowed(Item);
+        if ItemError <> ceOK then
+        begin
+            CollectionError(ItemError);
+        end
+        else
+        begin
+            Position := GetKeyPosition(Key);
+            try
+                NewAssociation := TStringAssociation.Create(Key, Item);
+                OldAssociation := TruePut(Position, NewAssociation);
+                if OldAssociation <> nil then
+                    ResultCollection.Add(OldAssociation.GetValue);
+            finally
+                Position.Free;
+            end;
+        end;
+        MapIterator.Next;
+    end;
+    Result := ResultCollection;
+end;
+
+function TAbstractStringMap.RemoveKey(const Key: String): ICollectable;
+var
+    Position: TCollectionPosition;
+    OldAssociation: IStringAssociation;
+begin
+    Position := GetKeyPosition(Key);
+    try
+        if Position.Found then
+        begin
+            OldAssociation := TrueRemove2(Position);
+            Result := OldAssociation.GetValue
+        end
+        else
+            Result := nil;
+    finally
+        Position.Free;
+    end;
+end;
+
+function TAbstractStringMap.RemoveKey(const KeyArray: array of String): ICollection;
+var
+    ResultCollection: ICollection;
+    OldAssociation: IStringAssociation;
+    Position: TCollectionPosition;
+    Key: String;
+    I: Integer;
+begin
+    ResultCollection := TPArrayBag.Create(NaturalItemsOnly);
+    for I := Low(KeyArray) to High(KeyArray) do
+    begin
+        Key := KeyArray[I];
+        Position := GetKeyPosition(Key);
+        try
+            if Position.Found then
+            begin
+                OldAssociation := TrueRemove2(Position);
+                ResultCollection.Add(OldAssociation.GetValue);
+            end;
+        finally
+            Position.Free;
+        end;
+    end;
+    Result := ResultCollection;
+end;
+
+function TAbstractStringMap.RetainKey(const KeyArray: array of String): ICollection;
+var
+    ResultCollection: ICollection;
+    MapIterator: IStringMapIterator;
+    I: Integer;
+    Found: Boolean;
+begin
+    ResultCollection := TPArrayBag.Create(NaturalItemsOnly);
+    if FixedSize then
+    begin
+        CollectionError(ceFixedSize);
+    end
+    else
+    begin
+        MapIterator := GetMapIterator;
+        while not MapIterator.EOF do
+        begin
+            // Converting the array to a map would be faster but I don't want to
+            // couple base class code to a complex collection.
+            Found := false;
+            for I := Low(KeyArray) to High(KeyArray) do
+            begin
+                Found := (MapIterator.CurrentKey = KeyArray[I]);
+                if Found then
+                    break;
+            end;
+            if not Found then
+            begin
+                ResultCollection.Add(MapIterator.CurrentItem);
+                MapIterator.Remove;
+            end;
+            MapIterator.Next;
+        end;
+        Result := ResultCollection;
+    end;
+end;
+
+
+{ ECollectionError }
+constructor ECollectionError.Create(const Msg: String; const Collection: ICollection; ErrorType: TCollectionError);
+begin
+    inherited Create(Msg);
+    FCollection := Collection;
+    FErrorType := ErrorType;
+end;
+
+{ TAbstractListIterator }
+constructor TAbstractListIterator.Create(Collection: TAbstractList);
+begin
+    inherited Create(true);
+    FCollection := Collection;
+    First;
+end;
+
+function TAbstractListIterator.TrueFirst: ICollectable;
+begin
+    FIndex := 0;
+    if FIndex < FCollection.GetSize then
+        Result := FCollection.GetItem(FIndex)
+    else
+        Result := nil;
+end;
+
+function TAbstractListIterator.TrueNext: ICollectable;
+begin
+    Inc(FIndex);
+    if FIndex < FCollection.GetSize then
+        Result := FCollection.GetItem(FIndex)
+    else
+        Result := nil;
+end;
+
+procedure TAbstractListIterator.TrueRemove;
+begin
+    FCollection.Delete(FIndex);
+    Dec(FIndex);
+end;
+
+end.
diff --git a/Lua/src/lib/collections/readme.txt b/Lua/src/lib/collections/readme.txt
new file mode 100644
index 00000000..1f6477de
--- /dev/null
+++ b/Lua/src/lib/collections/readme.txt
@@ -0,0 +1,14 @@
+Delphi Collections by Matthew Greet
+http://www.warmachine.u-net.com/delphi_collections/
+
+Help files (MS .hlp format) at 
+http://www.warmachine.u-net.com/downloads/delphi_collections_1_0_help.zip
+
+Changes
+=====================
+2008-11-06  FPC compatibility fixes by UltraStar Deluxe Team
+2005-03-14  Maintenance release v1.0.5 - bug fix for sorted lists and functional tests checks unsorted and sorted lists.
+2004-10-14 	Maintenance release v1.0.4 - memory leak fixed.
+2004-06-12 	Maintenance release v1.0.3 - memory leak fixed, memory leak test, new Capacity property.
+2004-02-13 	Maintenance release v1.0.2 - expanded introduction and quick start sections in help file.
+2003-10-25 	Maintenance release v1.0.1 - packages and test harness no longer list unused packages.
+\ No newline at end of file
diff --git a/Lua/src/lib/ctypes/ctypes.pas b/Lua/src/lib/ctypes/ctypes.pas
index 6cdf77fc..694552dc 100644
--- a/Lua/src/lib/ctypes/ctypes.pas
+++ b/Lua/src/lib/ctypes/ctypes.pas
@@ -1,72 +1,72 @@
-{
-    This file is part of the Free Pascal run time library.
-    Copyright (c) 2004 by Marco van de Voort, member of the
-    Free Pascal development team
-
-    Implements C types for in header conversions
-
-    See the file COPYING.FPC, included in this distribution,
-    for details about the copyright.
-
-    This program is distributed in the hope that it will be useful,
-    but WITHOUT ANY WARRANTY; without even the implied warranty of
-    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.
-
-
- **********************************************************************}
-
-unit ctypes;
-
-interface
-
-type
-  qword = int64;  // Keep h2pas "uses ctypes" headers working with delphi.
-
-  { the following type definitions are compiler dependant }
-  { and system dependant                                  }
-
-  cint8                  = shortint;           pcint8                 = ^cint8;
-  cuint8                 = byte;               pcuint8                = ^cuint8;
-  cchar                  = cint8;              pcchar                 = ^cchar;
-  cschar                 = cint8;              pcschar                = ^cschar;
-  cuchar                 = cuint8;             pcuchar                = ^cuchar;
-
-  cint16                 = smallint;           pcint16                = ^cint16;
-  cuint16                = word;               pcuint16               = ^cuint16;
-  cshort                 = cint16;             pcshort                = ^cshort;
-  csshort                = cint16;             pcsshort               = ^csshort;
-  cushort                = cuint16;            pcushort               = ^cushort;
-
-  cint32                 = longint;            pcint32                = ^cint32;
-  cuint32                = longword;           pcuint32               = ^cuint32;
-  cint                   = cint32;             pcint                  = ^cint;              { minimum range is : 32-bit    }
-  csint                  = cint32;             pcsint                 = ^csint;             { minimum range is : 32-bit    }
-  cuint                  = cuint32;            pcuint                 = ^cuint;             { minimum range is : 32-bit    }
-  csigned                = cint;               pcsigned               = ^csigned;
-  cunsigned              = cuint;              pcunsigned             = ^cunsigned;
-
-  cint64                 = int64;              pcint64                = ^cint64;
-  cuint64                = qword;              pcuint64               = ^cuint64;
-  clonglong              = cint64;             pclonglong             = ^clonglong;
-  cslonglong             = cint64;             pcslonglong            = ^cslonglong;
-  culonglong             = cuint64;            pculonglong            = ^culonglong;
-
-  cbool                  = longbool;           pcbool                 = ^cbool;
-
-{$if defined(cpu64) and not(defined(win64) and defined(cpux86_64))}
-  clong                  = int64;              pclong                 = ^clong;
-  cslong                 = int64;              pcslong                = ^cslong;
-  culong                 = qword;              pculong                = ^culong;
-{$else}
-  clong                  = longint;            pclong                 = ^clong;
-  cslong                 = longint;            pcslong                = ^cslong;
-  culong                 = cardinal;           pculong                = ^culong;
-{$ifend}
-
-  cfloat                 = single;             pcfloat                = ^cfloat;
-  cdouble                = double;             pcdouble               = ^cdouble;
-  clongdouble            = extended;           pclongdouble           = ^clongdouble;
-
-implementation
-
-end.
+{
+    This file is part of the Free Pascal run time library.
+    Copyright (c) 2004 by Marco van de Voort, member of the
+    Free Pascal development team
+
+    Implements C types for in header conversions
+
+    See the file COPYING.FPC, included in this distribution,
+    for details about the copyright.
+
+    This program is distributed in the hope that it will be useful,
+    but WITHOUT ANY WARRANTY; without even the implied warranty of
+    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.
+
+
+ **********************************************************************}
+
+unit ctypes;
+
+interface
+
+type
+  qword = int64;  // Keep h2pas "uses ctypes" headers working with delphi.
+
+  { the following type definitions are compiler dependant }
+  { and system dependant                                  }
+
+  cint8                  = shortint;           pcint8                 = ^cint8;
+  cuint8                 = byte;               pcuint8                = ^cuint8;
+  cchar                  = cint8;              pcchar                 = ^cchar;
+  cschar                 = cint8;              pcschar                = ^cschar;
+  cuchar                 = cuint8;             pcuchar                = ^cuchar;
+
+  cint16                 = smallint;           pcint16                = ^cint16;
+  cuint16                = word;               pcuint16               = ^cuint16;
+  cshort                 = cint16;             pcshort                = ^cshort;
+  csshort                = cint16;             pcsshort               = ^csshort;
+  cushort                = cuint16;            pcushort               = ^cushort;
+
+  cint32                 = longint;            pcint32                = ^cint32;
+  cuint32                = longword;           pcuint32               = ^cuint32;
+  cint                   = cint32;             pcint                  = ^cint;              { minimum range is : 32-bit    }
+  csint                  = cint32;             pcsint                 = ^csint;             { minimum range is : 32-bit    }
+  cuint                  = cuint32;            pcuint                 = ^cuint;             { minimum range is : 32-bit    }
+  csigned                = cint;               pcsigned               = ^csigned;
+  cunsigned              = cuint;              pcunsigned             = ^cunsigned;
+
+  cint64                 = int64;              pcint64                = ^cint64;
+  cuint64                = qword;              pcuint64               = ^cuint64;
+  clonglong              = cint64;             pclonglong             = ^clonglong;
+  cslonglong             = cint64;             pcslonglong            = ^cslonglong;
+  culonglong             = cuint64;            pculonglong            = ^culonglong;
+
+  cbool                  = longbool;           pcbool                 = ^cbool;
+
+{$if defined(cpu64) and not(defined(win64) and defined(cpux86_64))}
+  clong                  = int64;              pclong                 = ^clong;
+  cslong                 = int64;              pcslong                = ^cslong;
+  culong                 = qword;              pculong                = ^culong;
+{$else}
+  clong                  = longint;            pclong                 = ^clong;
+  cslong                 = longint;            pcslong                = ^cslong;
+  culong                 = cardinal;           pculong                = ^culong;
+{$ifend}
+
+  cfloat                 = single;             pcfloat                = ^cfloat;
+  cdouble                = double;             pcdouble               = ^cdouble;
+  clongdouble            = extended;           pclongdouble           = ^clongdouble;
+
+implementation
+
+end.
diff --git a/Lua/src/lib/ffmpeg/avcodec.pas b/Lua/src/lib/ffmpeg/avcodec.pas
index 0954ee06..d0400d9a 100644
--- a/Lua/src/lib/ffmpeg/avcodec.pas
+++ b/Lua/src/lib/ffmpeg/avcodec.pas
@@ -27,8 +27,13 @@
 (*
  * Conversion of libavcodec/avcodec.h
  * Min. version: 51.16.0, revision 6577, Sat Oct 7 15:30:46 2006 UTC 
- * Max. version: 52.0.0, revision 15448, Sun Sep 28 19:11:26 2008 UTC 
+ * Max. version: 52.11.0, revision 16912, Sun Feb 1 02:00:19 2009 UTC 
  *)
+{
+ * update to
+ * Max. version: 52.42.0, Sun Dec 6 19:20:00 2009 CET 
+ * MiSchi
+}
 
 unit avcodec;
 
@@ -51,6 +56,7 @@ uses
   avutil,
   rational,
   opt,
+  SysUtils,
   {$IFDEF UNIX}
   BaseUnix,
   {$ENDIF}
@@ -59,7 +65,7 @@ uses
 const
   (* Max. supported version by this header *)
   LIBAVCODEC_MAX_VERSION_MAJOR   = 52;
-  LIBAVCODEC_MAX_VERSION_MINOR   = 0;
+  LIBAVCODEC_MAX_VERSION_MINOR   = 42;
   LIBAVCODEC_MAX_VERSION_RELEASE = 0;
   LIBAVCODEC_MAX_VERSION = (LIBAVCODEC_MAX_VERSION_MAJOR * VERSION_MAJOR) +
                            (LIBAVCODEC_MAX_VERSION_MINOR * VERSION_MINOR) +
@@ -84,9 +90,9 @@ const
 {$IFEND}
 
 const
-  AV_NOPTS_VALUE: cint64   = $8000000000000000;
+  AV_NOPTS_VALUE: cint64  = $8000000000000000;
   AV_TIME_BASE            = 1000000;
-  AV_TIME_BASE_Q          : TAVRational = (num: 1; den: AV_TIME_BASE);
+  AV_TIME_BASE_Q: TAVRational = (num: 1; den: AV_TIME_BASE);
 
 (**
  * Identifies the syntax and semantics of the bitstream.
@@ -231,6 +237,35 @@ type
     CODEC_ID_CMV,
     CODEC_ID_MOTIONPIXELS,
     CODEC_ID_TGV,
+    CODEC_ID_TGQ,
+{$IF LIBAVCODEC_VERSION >= 52012000}  // >= 52.12.0
+    CODEC_ID_TQI,
+{$IFEND}
+{$IF LIBAVCODEC_VERSION >= 52022002}  // >= 52.22.2
+    CODEC_ID_AURA,
+    CODEC_ID_AURA2,
+{$IFEND}
+{$IF LIBAVCODEC_VERSION >= 52027000}  // >= 52.27.0
+    CODEC_ID_V210X,
+{$IFEND}
+{$IF LIBAVCODEC_VERSION >= 52028000}  // >= 52.28.0
+    CODEC_ID_TMV,
+{$IFEND}
+{$IF LIBAVCODEC_VERSION >= 52029000}  // >= 52.29.0
+    CODEC_ID_V210,
+{$IFEND}
+{$IF LIBAVCODEC_VERSION >= 52030002}  // >= 52.30.2
+    CODEC_ID_DPX,
+{$IFEND}
+{$IF LIBAVCODEC_VERSION >= 52031002}  // >= 52.31.2
+    CODEC_ID_MAD,
+{$IFEND}
+{$IF LIBAVCODEC_VERSION >= 52037000}  // >= 52.37.0
+    CODEC_ID_FRWU,
+{$IFEND}
+{$IF LIBAVCODEC_VERSION >= 52041000}  // >= 52.41.0
+    CODEC_ID_FLASHSV2,
+{$IFEND}
 
     //* various PCM "codecs" */
     CODEC_ID_PCM_S16LE= $10000,
@@ -257,6 +292,9 @@ type
     CODEC_ID_PCM_F32LE,
     CODEC_ID_PCM_F64BE,
     CODEC_ID_PCM_F64LE,
+{$IF LIBAVCODEC_VERSION >= 52034000} // >= 52.34.0
+    CODEC_ID_PCM_BLURAY,
+{$IFEND}
 
     //* various ADPCM codecs */
     CODEC_ID_ADPCM_IMA_QT= $11000,
@@ -286,6 +324,7 @@ type
     CODEC_ID_ADPCM_IMA_EA_EACS,
     CODEC_ID_ADPCM_EA_XAS,
     CODEC_ID_ADPCM_EA_MAXIS_XA,
+    CODEC_ID_ADPCM_IMA_ISS,
 
     //* AMR */
     CODEC_ID_AMR_NB= $12000,
@@ -305,7 +344,7 @@ type
     CODEC_ID_MP2= $15000,
     CODEC_ID_MP3, ///< preferred ID for decoding MPEG audio layer 1, 2 or 3
     CODEC_ID_AAC,
-    {$IF LIBAVCODEC_VERSION < 52000000} // 52.0.0
+    {$IF LIBAVCODEC_VERSION < 52000000} // < 52.0.0
     _CODEC_ID_MPEG4AAC, // will be redefined to CODEC_ID_AAC below
     {$IFEND}
     CODEC_ID_AC3,
@@ -350,6 +389,19 @@ type
     CODEC_ID_ATRAC3P,
     CODEC_ID_EAC3,
     CODEC_ID_SIPR,
+    CODEC_ID_MP1,
+{$IF LIBAVCODEC_VERSION >= 52020000} // >= 52.20.0
+    CODEC_ID_TWINVQ,
+{$IFEND}
+{$IF LIBAVCODEC_VERSION >= 52022000} // >= 52.22.0
+    CODEC_ID_TRUEHD,
+{$IFEND}
+{$IF LIBAVCODEC_VERSION >= 52026000} // >= 52.26.0
+    CODEC_ID_MP4ALS,
+{$IFEND}
+{$IF LIBAVCODEC_VERSION >= 52035000} // >= 52.35.0
+    CODEC_ID_ATRAC1,
+{$IFEND}
 
     //* subtitle codecs */
     CODEC_ID_DVD_SUBTITLE= $17000,
@@ -358,6 +410,12 @@ type
     CODEC_ID_XSUB,
     CODEC_ID_SSA,
     CODEC_ID_MOV_TEXT,
+{$IF LIBAVCODEC_VERSION >= 52033000} // >= 52.33.0
+    CODEC_ID_HDMV_PGS_SUBTITLE,
+{$IFEND}
+{$IF LIBAVCODEC_VERSION >= 52037001} // >= 52.37.1
+    CODEC_ID_DVB_TELETEXT,
+{$IFEND}
 
     (* other specific kind of codecs (generally used for attachments) *)
     CODEC_ID_TTF= $18000,
@@ -365,11 +423,11 @@ type
     CODEC_ID_PROBE= $19000, ///< codec_id is not known (like CODEC_ID_NONE) but lavf should attempt to identify it
 
     CODEC_ID_MPEG2TS= $20000, {*< _FAKE_ codec to indicate a raw MPEG-2 TS
-                              * stream (only used by libavformat) *}
+                               * stream (only used by libavformat) *}
     __CODEC_ID_4BYTE = $FFFFF  // ensure 4-byte enum
   );
 
-{$IF LIBAVCODEC_VERSION < 52000000} // 52.0.0
+{$IF LIBAVCODEC_VERSION < 52000000} // < 52.0.0
 {* CODEC_ID_MP3LAME is obsolete *}
 const
   CODEC_ID_MP3LAME = CODEC_ID_MP3;
@@ -404,6 +462,67 @@ type
   PSampleFormatArray = ^_TSampleFormatArray;
 
 const
+  {* Audio channel masks *}
+  CH_FRONT_LEFT             = $00000001;
+  CH_FRONT_RIGHT            = $00000002;
+  CH_FRONT_CENTER           = $00000004;
+  CH_LOW_FREQUENCY          = $00000008;
+  CH_BACK_LEFT              = $00000010;
+  CH_BACK_RIGHT             = $00000020;
+  CH_FRONT_LEFT_OF_CENTER   = $00000040;
+  CH_FRONT_RIGHT_OF_CENTER  = $00000080;
+  CH_BACK_CENTER            = $00000100;
+  CH_SIDE_LEFT              = $00000200;
+  CH_SIDE_RIGHT             = $00000400;
+  CH_TOP_CENTER             = $00000800;
+  CH_TOP_FRONT_LEFT         = $00001000;
+  CH_TOP_FRONT_CENTER       = $00002000;
+  CH_TOP_FRONT_RIGHT        = $00004000;
+  CH_TOP_BACK_LEFT          = $00008000;
+  CH_TOP_BACK_CENTER        = $00010000;
+  CH_TOP_BACK_RIGHT         = $00020000;
+  CH_STEREO_LEFT            = $20000000;  ///< Stereo downmix.
+  CH_STEREO_RIGHT           = $40000000;  ///< See CH_STEREO_LEFT.
+{** Channel mask value used for AVCodecContext.request_channel_layout
+ *  to indicate that the user requests the channel order of the decoder output
+ *  to be the native codec channel order.
+ *}
+{$IF LIBAVCODEC_VERSION >= 52038001} // >= 52.38.1
+  CH_LAYOUT_NATIVE          = $8000000000000000LL
+{$IFEND}
+  {* Audio channel convenience macros *}
+  CH_LAYOUT_MONO            = (CH_FRONT_CENTER);
+  CH_LAYOUT_STEREO          = (CH_FRONT_LEFT or CH_FRONT_RIGHT);
+  CH_LAYOUT_SURROUND        = (CH_LAYOUT_STEREO or CH_FRONT_CENTER);
+{$IF LIBAVCODEC_VERSION >= 52027000} // >= 52.27.0
+  CH_LAYOUT_2_1             = (CH_LAYOUT_STEREO or CH_BACK_CENTER);
+  CH_LAYOUT_4POINT0         = (CH_LAYOUT_SURROUND or CH_BACK_CENTER);
+  CH_LAYOUT_2_2             = (CH_LAYOUT_STEREO or CH_SIDE_LEFT or CH_SIDE_RIGHT);
+{$IFEND}
+  CH_LAYOUT_QUAD            = (CH_LAYOUT_STEREO or CH_BACK_LEFT or CH_BACK_RIGHT);
+  CH_LAYOUT_5POINT0         = (CH_LAYOUT_SURROUND or CH_SIDE_LEFT or CH_SIDE_RIGHT);
+  CH_LAYOUT_5POINT1         = (CH_LAYOUT_5POINT0 or CH_LOW_FREQUENCY);
+{$IF LIBAVCODEC_VERSION >= 52025000} // >= 52.25.0
+  CH_LAYOUT_5POINT0_BACK    = (CH_LAYOUT_SURROUND or CH_BACK_LEFT or 
+                               CH_BACK_RIGHT);
+  CH_LAYOUT_5POINT1_BACK    = (CH_LAYOUT_5POINT0_BACK or CH_LOW_FREQUENCY);
+{$IFEND}
+{$IF LIBAVCODEC_VERSION >= 52034000} // >= 52.34.0
+  CH_LAYOUT_7POINT0         = (CH_LAYOUT_5POINT0 or CH_BACK_LEFT or CH_BACK_RIGHT);
+{$IFEND}
+  CH_LAYOUT_7POINT1         = (CH_LAYOUT_5POINT1 or CH_BACK_LEFT or CH_BACK_RIGHT);
+{$IF LIBAVCODEC_VERSION < 52025000} // < 52.25.0
+  CH_LAYOUT_7POINT1_WIDE    = (CH_LAYOUT_SURROUND or CH_LOW_FREQUENCY or
+                               CH_BACK_LEFT or CH_BACK_RIGHT or
+{$ELSE}
+  CH_LAYOUT_7POINT1_WIDE    = (CH_LAYOUT_5POINT1_BACK or 
+{$IFEND}
+                               CH_FRONT_LEFT_OF_CENTER or
+                               CH_FRONT_RIGHT_OF_CENTER);
+  CH_LAYOUT_STEREO_DOWNMIX  = (CH_STEREO_LEFT or CH_STEREO_RIGHT);
+
+
+const
   {* in bytes *}
   AVCODEC_MAX_AUDIO_FRAME_SIZE = 192000; // 1 second of 48khz 32bit audio
 
@@ -441,20 +560,76 @@ type
 
   TAVDiscard = (
     {* We leave some space between them for extensions (drop some
-     * keyframes for intra-only or drop just some bidir frames). *}
-    AVDISCARD_NONE   =-16, ///< discard nothing
-    AVDISCARD_DEFAULT=  0, ///< discard useless packets like 0 size packets in avi
-    AVDISCARD_NONREF =  8, ///< discard all non reference
-    AVDISCARD_BIDIR  = 16, ///< discard all bidirectional frames
-    AVDISCARD_NONKEY = 32, ///< discard all frames except keyframes
-    AVDISCARD_ALL    = 48  ///< discard all
+     * keyframes for intra-only or drop just some bidir frames).
+     *}
+    AVDISCARD_NONE    = -16, ///< discard nothing
+    AVDISCARD_DEFAULT =   0, ///< discard useless packets like 0 size packets in avi
+    AVDISCARD_NONREF  =   8, ///< discard all non reference
+    AVDISCARD_BIDIR   =  16, ///< discard all bidirectional frames
+    AVDISCARD_NONKEY  =  32, ///< discard all frames except keyframes
+    AVDISCARD_ALL     =  48  ///< discard all
+  );
+
+{$IF LIBAVCODEC_VERSION >= 52028000} // >= 52.28.0
+  TAVColorPrimaries = (
+    AVCOL_PRI_BT709       = 1, ///< also ITU-R BT1361 / IEC 61966-2-4 / SMPTE RP177 Annex B
+    AVCOL_PRI_UNSPECIFIED = 2,
+    AVCOL_PRI_BT470M      = 4,
+    AVCOL_PRI_BT470BG     = 5, ///< also ITU-R BT601-6 625 / ITU-R BT1358 625 / ITU-R BT1700 625 PAL & SECAM
+    AVCOL_PRI_SMPTE170M   = 6, ///< also ITU-R BT601-6 525 / ITU-R BT1358 525 / ITU-R BT1700 NTSC
+    AVCOL_PRI_SMPTE240M   = 7, ///< functionally identical to above
+    AVCOL_PRI_FILM        = 8,
+    AVCOL_PRI_NB               ///< Not part of ABI
+  );
+
+  TAVColorTransferCharacteristic = (
+    AVCOL_TRC_BT709       = 1, ///< also ITU-R BT1361
+    AVCOL_TRC_UNSPECIFIED = 2,
+    AVCOL_TRC_GAMMA22     = 4, ///< also ITU-R BT470M / ITU-R BT1700 625 PAL & SECAM
+    AVCOL_TRC_GAMMA28     = 5, ///< also ITU-R BT470BG
+    AVCOL_TRC_NB               ///< Not part of ABI
+  );
+
+  TAVColorSpace = (
+    AVCOL_SPC_RGB         = 0,
+    AVCOL_SPC_BT709       = 1, ///< also ITU-R BT1361 / IEC 61966-2-4 xvYCC709 / SMPTE RP177 Annex B
+    AVCOL_SPC_UNSPECIFIED = 2,
+    AVCOL_SPC_FCC         = 4,
+    AVCOL_SPC_BT470BG     = 5, ///< also ITU-R BT601-6 625 / ITU-R BT1358 625 / ITU-R BT1700 625 PAL & SECAM / IEC 61966-2-4 xvYCC601
+    AVCOL_SPC_SMPTE170M   = 6, ///< also ITU-R BT601-6 525 / ITU-R BT1358 525 / ITU-R BT1700 NTSC / functionally identical to above
+    AVCOL_SPC_SMPTE240M   = 7,
+    AVCOL_SPC_NB               ///< Not part of ABI
+  );
+
+  TAVColorRange = (
+    AVCOL_RANGE_UNSPECIFIED = 0,
+    AVCOL_RANGE_MPEG        = 1, ///< the normal 219*2^(n-8) "MPEG" YUV ranges
+    AVCOL_RANGE_JPEG        = 2, ///< the normal     2^n-1   "JPEG" YUV ranges
+    AVCOL_RANGE_NB               ///< Not part of ABI
+  );
+
+(**
+ *  X   X      3 4 X      X are luma samples,
+ *             1 2        1-6 are possible chroma positions
+ *  X   X      5 6 X      0 is undefined/unknown position
+ *)
+  TAVChromaLocation = (
+    AVCHROMA_LOC_UNSPECIFIED = 0,
+    AVCHROMA_LOC_LEFT        = 1, ///< mpeg2/4, h264 default
+    AVCHROMA_LOC_CENTER      = 2, ///< mpeg1, jpeg, h263
+    AVCHROMA_LOC_TOPLEFT     = 3, ///< DV
+    AVCHROMA_LOC_TOP         = 4,
+    AVCHROMA_LOC_BOTTOMLEFT  = 5,
+    AVCHROMA_LOC_BOTTOM      = 6,
+    AVCHROMA_LOC_NB               ///< Not part of ABI
   );
+{$IFEND}
 
   PRcOverride = ^TRcOverride;
   TRcOverride = record {16}
-    start_frame: cint;
-    end_frame: cint;
-    qscale: cint; // if this is 0 then quality_factor will be used instead
+    start_frame:    cint;
+    end_frame:      cint;
+    qscale:         cint; // if this is 0 then quality_factor will be used instead
     quality_factor: cfloat;
   end;
 
@@ -559,6 +734,18 @@ const
    *)
   CODEC_CAP_SMALL_LAST_FRAME = $0040;
 
+  (**
+   * Codec can export data for HW decoding (VDPAU).
+   *)
+  CODEC_CAP_HWACCEL_VDPAU    = $0080;
+
+  {$IF LIBAVCODEC_VERSION >= 52035000} // >= 52.35.0
+  (**
+   * Codec can output multiple frames per AVPacket
+   *)
+  CODEC_CAP_SUBFRAMES        = $0100;
+  {$IFEND}
+
    //the following defines may change, don't expect compatibility if you use them
    MB_TYPE_INTRA4x4   = $001;
    MB_TYPE_INTRA16x16 = $002; //FIXME h264 specific
@@ -609,8 +796,8 @@ type
   end;
 
 const
-  FF_QSCALE_TYPE_MPEG1	= 0;
-  FF_QSCALE_TYPE_MPEG2	= 1;
+  FF_QSCALE_TYPE_MPEG1  = 0;
+  FF_QSCALE_TYPE_MPEG2  = 1;
   FF_QSCALE_TYPE_H264   = 2;
 
   FF_BUFFER_TYPE_INTERNAL = 1;
@@ -632,7 +819,311 @@ const
   FF_BUFFER_HINTS_PRESERVE = $04; // User must not alter buffer content
   FF_BUFFER_HINTS_REUSABLE = $08; // Codec will reuse the buffer (update)
 
+const
+  {$IF LIBAVCODEC_VERSION < 52000000} // < 52.0.0
+  DEFAULT_FRAME_RATE_BASE = 1001000;
+  {$IFEND}
+
+  FF_ASPECT_EXTENDED = 15;
+
+  FF_RC_STRATEGY_XVID = 1;
+
+  FF_BUG_AUTODETECT       = 1;  ///< autodetection
+  FF_BUG_OLD_MSMPEG4      = 2;
+  FF_BUG_XVID_ILACE       = 4;
+  FF_BUG_UMP4             = 8;
+  FF_BUG_NO_PADDING       = 16;
+  FF_BUG_AMV              = 32;
+  FF_BUG_AC_VLC           = 0;  ///< will be removed, libavcodec can now handle these non compliant files by default
+  FF_BUG_QPEL_CHROMA      = 64;
+  FF_BUG_STD_QPEL         = 128;
+  FF_BUG_QPEL_CHROMA2     = 256;
+  FF_BUG_DIRECT_BLOCKSIZE = 512;
+  FF_BUG_EDGE             = 1024;
+  FF_BUG_HPEL_CHROMA      = 2048;
+  FF_BUG_DC_CLIP          = 4096;
+  FF_BUG_MS               = 8192; ///< workaround various bugs in microsofts broken decoders
+  //FF_BUG_FAKE_SCALABILITY = 16 //Autodetection should work 100%.
+
+  FF_COMPLIANCE_VERY_STRICT   =  2; ///< strictly conform to a older more strict version of the spec or reference software
+  FF_COMPLIANCE_STRICT        =  1; ///< strictly conform to all the things in the spec no matter what consequences
+  FF_COMPLIANCE_NORMAL        =  0;
+  FF_COMPLIANCE_INOFFICIAL    = -1; ///< allow inofficial extensions
+  FF_COMPLIANCE_EXPERIMENTAL  = -2; ///< allow non standarized experimental things
+
+  FF_ER_CAREFUL         = 1;
+  FF_ER_COMPLIANT       = 2;
+  FF_ER_AGGRESSIVE      = 3;
+  FF_ER_VERY_AGGRESSIVE = 4;
+
+  FF_DCT_AUTO    = 0;
+  FF_DCT_FASTINT = 1;
+  FF_DCT_INT     = 2;
+  FF_DCT_MMX     = 3;
+  FF_DCT_MLIB    = 4;
+  FF_DCT_ALTIVEC = 5;
+  FF_DCT_FAAN    = 6;
+
+  FF_IDCT_AUTO         = 0;
+  FF_IDCT_INT          = 1;
+  FF_IDCT_SIMPLE       = 2;
+  FF_IDCT_SIMPLEMMX    = 3;
+  FF_IDCT_LIBMPEG2MMX  = 4;
+  FF_IDCT_PS2          = 5;
+  FF_IDCT_MLIB         = 6;
+  FF_IDCT_ARM          = 7;
+  FF_IDCT_ALTIVEC      = 8;
+  FF_IDCT_SH4          = 9;
+  FF_IDCT_SIMPLEARM    = 10;
+  FF_IDCT_H264         = 11;
+  FF_IDCT_VP3          = 12;
+  FF_IDCT_IPP          = 13;
+  FF_IDCT_XVIDMMX      = 14;
+  FF_IDCT_CAVS         = 15;
+  FF_IDCT_SIMPLEARMV5TE= 16;
+  FF_IDCT_SIMPLEARMV6  = 17;
+  FF_IDCT_SIMPLEVIS    = 18;
+  FF_IDCT_WMV2         = 19;
+  FF_IDCT_FAAN         = 20;
+  FF_IDCT_EA           = 21;
+  FF_IDCT_SIMPLENEON   = 22;
+  FF_IDCT_SIMPLEALPHA  = 23;
+
+  FF_EC_GUESS_MVS   = 1;
+  FF_EC_DEBLOCK     = 2;
+
+  FF_MM_FORCE       = $80000000; (* force usage of selected flags (OR) *)
+  (* lower 16 bits - CPU features *)
+  FF_MM_MMX         = $0001; ///< standard MMX
+  FF_MM_3DNOW       = $0004; ///< AMD 3DNOW
+  {$IF LIBAVCODEC_MAX_VERSION_MAJOR < 53}
+  FF_MM_MMXEXT      = $0002; ///< SSE integer functions or AMD MMX ext
+  {$IFEND}
+  {$IF LIBAVCODEC_VERSION >= 52024000} // >= 52.24.0
+  FF_MM_MMX2        = $0002; ///< SSE integer functions or AMD MMX ext
+  {$IFEND}
+  FF_MM_SSE         = $0008; ///< SSE functions
+  FF_MM_SSE2        = $0010; ///< PIV SSE2 functions
+  FF_MM_3DNOWEXT    = $0020; ///< AMD 3DNowExt
+  FF_MM_SSE3        = $0040; ///< Prescott SSE3 functions
+  FF_MM_SSSE3       = $0080; ///< Conroe SSSE3 functions
+  {$IF LIBAVCODEC_VERSION >= 52022003} // >= 52.22.3
+  FF_MM_SSE4        = $0100; ///< Penryn SSE4.1 functions
+  FF_MM_SSE42       = $0200; ///< Nehalem SSE4.2 functions
+  {$IFEND}
+  FF_MM_IWMMXT      = $0100; ///< XScale IWMMXT
+  FF_MM_ALTIVEC     = $0001; ///< standard AltiVec
+
+  FF_PRED_LEFT   = 0;
+  FF_PRED_PLANE  = 1;
+  FF_PRED_MEDIAN = 2;
+
+  FF_DEBUG_PICT_INFO    = 1;
+  FF_DEBUG_RC           = 2;
+  FF_DEBUG_BITSTREAM    = 4;
+  FF_DEBUG_MB_TYPE      = 8;
+  FF_DEBUG_QP           = 16;
+  FF_DEBUG_MV           = 32;
+  FF_DEBUG_DCT_COEFF    = $00000040;
+  FF_DEBUG_SKIP         = $00000080;
+  FF_DEBUG_STARTCODE    = $00000100;
+  FF_DEBUG_PTS          = $00000200;
+  FF_DEBUG_ER           = $00000400;
+  FF_DEBUG_MMCO         = $00000800;
+  FF_DEBUG_BUGS         = $00001000;
+  FF_DEBUG_VIS_QP       = $00002000;
+  FF_DEBUG_VIS_MB_TYPE  = $00004000;
+  FF_DEBUG_BUFFERS      = $00008000;
+
+  FF_DEBUG_VIS_MV_P_FOR  = $00000001; //visualize forward predicted MVs of P frames
+  FF_DEBUG_VIS_MV_B_FOR  = $00000002; //visualize forward predicted MVs of B frames
+  FF_DEBUG_VIS_MV_B_BACK = $00000004; //visualize backward predicted MVs of B frames
+
+  FF_CMP_SAD    = 0;
+  FF_CMP_SSE    = 1;
+  FF_CMP_SATD   = 2;
+  FF_CMP_DCT    = 3;
+  FF_CMP_PSNR   = 4;
+  FF_CMP_BIT    = 5;
+  FF_CMP_RD     = 6;
+  FF_CMP_ZERO   = 7;
+  FF_CMP_VSAD   = 8;
+  FF_CMP_VSSE   = 9;
+  FF_CMP_NSSE   = 10;
+  FF_CMP_W53    = 11;
+  FF_CMP_W97    = 12;
+  FF_CMP_DCTMAX = 13;
+  FF_CMP_DCT264 = 14;
+  FF_CMP_CHROMA = 256;
+
+  FF_DTG_AFD_SAME         = 8;
+  FF_DTG_AFD_4_3          = 9;
+  FF_DTG_AFD_16_9         = 10;
+  FF_DTG_AFD_14_9         = 11;
+  FF_DTG_AFD_4_3_SP_14_9  = 13;
+  FF_DTG_AFD_16_9_SP_14_9 = 14;
+  FF_DTG_AFD_SP_4_3       = 15;
+
+  FF_DEFAULT_QUANT_BIAS   = 999999;
+
+  FF_LAMBDA_SHIFT   = 7;
+  FF_LAMBDA_SCALE   = (1 shl FF_LAMBDA_SHIFT);
+  FF_QP2LAMBDA      = 118; ///< factor to convert from H.263 QP to lambda
+  FF_LAMBDA_MAX     = (256 * 128 - 1);
+
+  FF_QUALITY_SCALE  = FF_LAMBDA_SCALE; //FIXME maybe remove
+
+  FF_CODER_TYPE_VLC     = 0;
+  FF_CODER_TYPE_AC      = 1;
+  FF_CODER_TYPE_RAW     = 2;
+  FF_CODER_TYPE_RLE     = 3;
+  FF_CODER_TYPE_DEFLATE = 4;
+
+  SLICE_FLAG_CODED_ORDER    = $0001; ///< draw_horiz_band() is called in coded order instead of display
+  SLICE_FLAG_ALLOW_FIELD    = $0002; ///< allow draw_horiz_band() with field slices (MPEG2 field pics)
+  SLICE_FLAG_ALLOW_PLANE    = $0004; ///< allow draw_horiz_band() with 1 component at a time (SVQ1)
+
+  FF_MB_DECISION_SIMPLE = 0;        ///< uses mb_cmp
+  FF_MB_DECISION_BITS   = 1;        ///< chooses the one which needs the fewest bits
+  FF_MB_DECISION_RD     = 2;        ///< rate distortion
+
+  FF_AA_AUTO    = 0;
+  FF_AA_FASTINT = 1; //not implemented yet
+  FF_AA_INT     = 2;
+  FF_AA_FLOAT   = 3;
+
+  FF_PROFILE_UNKNOWN  = -99;
+  FF_PROFILE_AAC_MAIN = 0;
+  FF_PROFILE_AAC_LOW  = 1;
+  FF_PROFILE_AAC_SSR  = 2;
+  FF_PROFILE_AAC_LTP  = 3;
+
+  FF_LEVEL_UNKNOWN    = -99;
+
+  X264_PART_I4X4 = $001;  (* Analyse i4x4 *)
+  X264_PART_I8X8 = $002;  (* Analyse i8x8 (requires 8x8 transform) *)
+  X264_PART_P8X8 = $010;  (* Analyse p16x8, p8x16 and p8x8 *)
+  X264_PART_P4X4 = $020;  (* Analyse p8x4, p4x8, p4x4 *)
+  X264_PART_B8X8 = $100;  (* Analyse b16x8, b8x16 and b8x8 *)
+
+  FF_COMPRESSION_DEFAULT = -1;
+
+const
+  AVPALETTE_SIZE = 1024;
+  AVPALETTE_COUNT = 256;
+
+{$IF LIBAVCODEC_MAX_VERSION_MAJOR < 53}
+type
+(**
+ * AVPaletteControl
+ * This structure defines a method for communicating palette changes
+ * between and demuxer and a decoder.
+ *
+ * @deprecated Use AVPacket to send palette changes instead.
+ * This is totally broken.
+ *)
+  PAVPaletteControl = ^TAVPaletteControl;
+  TAVPaletteControl = record
+    (* demuxer sets this to 1 to indicate the palette has changed;
+     * decoder resets to 0 *)
+    palette_changed: cint;
+
+    (* 4-byte ARGB palette entries, stored in native byte order; note that
+     * the individual palette components should be on a 8-bit scale; if
+     * the palette data comes from a IBM VGA native format, the component
+     * data is probably 6 bits in size and needs to be scaled *)
+    palette: array [0..AVPALETTE_COUNT - 1] of cuint;
+  end; {deprecated;}
+{$IFEND}
+
+{$IF LIBAVCODEC_VERSION >= 52023000} // >= 52.23.0
+type
+  PAVPacket = ^TAVPacket;
+  TAVPacket = record
+(*
+ * Presentation timestamp in AVStream->time_base units; the time at which
+ * the decompressed packet will be presented to the user.
+ * Can be AV_NOPTS_VALUE if it is not stored in the file.
+ * pts MUST be larger or equal to dts as presentation cannot happen before
+ * decompression, unless one wants to view hex dumps. Some formats misuse
+ * the terms dts and pts/cts to mean something different. Such timestamps
+ * must be converted to true pts/dts before they are stored in AVPacket.
+ *)
+    pts:          cint64;
+(*
+ * Decompression timestamp in AVStream->time_base units; the time at which
+ * the packet is decompressed.
+ * Can be AV_NOPTS_VALUE if it is not stored in the file.
+ *)
+    dts:          cint64;
+    data:         PByteArray;
+    size:         cint;
+    stream_index: cint;
+    flags:        cint;
+(*
+ * Duration of this packet in AVStream->time_base units, 0 if unknown.
+ * Equals next_pts - this_pts in presentation order.
+ *)
+    duration:     cint;
+    destruct:     procedure (para1: PAVPacket); cdecl;
+    priv:         pointer;
+    pos:          cint64;       // byte position in stream, -1 if unknown
+
+(*
+ * Time difference in AVStream->time_base units from the pts of this
+ * packet to the point at which the output from the decoder has converged
+ * independent from the availability of previous frames. That is, the
+ * frames are virtually identical no matter if decoding started from
+ * the very first frame or from this keyframe.
+ * Is AV_NOPTS_VALUE if unknown.
+ * This field is not the display duration of the current packet.
+ *
+ * The purpose of this field is to allow seeking in streams that have no
+ * keyframes in the conventional sense. It corresponds to the
+ * recovery point SEI in H.264 and match_time_delta in NUT. It is also
+ * essential for some types of subtitle streams to ensure that all
+ * subtitles are correctly displayed after seeking.
+ *)
+    convergence_duration: cint64;
+  end;
+
+const
+  {$IF LIBAVCODEC_VERSION >= 52030002} // >= 52.30.2
+  PKT_FLAG_KEY = $0001;
+  {$ELSE}
+  AV_PKT_FLAG_KEY = $0001;
+    {$IF LIBAVCODEC_VERSION_MAJOR < 53}
+  PKT_FLAG_KEY = AV_PKT_FLAG_KEY;
+    {$IFEND}
+  {$IFEND}
+{$IFEND}
+
 type
+  PAVClass = ^TAVClass; {const}
+  PAVCodecContext = ^TAVCodecContext;
+
+  PAVCodec = ^TAVCodec;
+
+{$IF LIBAVCODEC_VERSION >= 52018000} // >= 52.18.0
+  PAVHWAccel = ^TAVHWAccel;
+{$IFEND}
+
+  // int[4]
+  PQuadIntArray = ^TQuadIntArray;
+  TQuadIntArray = array[0..3] of cint;
+  // int (*func)(struct AVCodecContext *c2, void *arg)
+  TExecuteFunc = function(c2: PAVCodecContext; arg: Pointer): cint; cdecl;
+
+  TAVClass = record
+    class_name: PAnsiChar;
+    (* actually passing a pointer to an AVCodecContext
+       or AVFormatContext, which begin with an AVClass.
+       Needed because av_log is in libavcodec and has no visibility
+       of AVIn/OutputFormat *)
+    item_name: function(): PAnsiChar; cdecl;
+    option: PAVOption;
+  end;
+
   {**
    * Audio Video Frame.
    * New fields can be added to the end of FF_COMMON_FRAME with minor version
@@ -678,7 +1169,7 @@ type
      * - decoding: Set by libavcodec.
      *)
     pts: cint64;
-    (**\
+    (**
      * picture number in bitstream order
      * - encoding: set by
      * - decoding: Set by libavcodec.
@@ -707,6 +1198,7 @@ type
      * is this picture used as reference
      * The values for this are the same as the MpegEncContext.picture_structure
      * variable, that is 1->top field, 2->bottom field, 3->frame/both fields.
+     * Set to 4 for delayed, non-reference frames.
      * - encoding: unused
      * - decoding: Set by libavcodec. (before get_buffer() call)).
      *)
@@ -831,7 +1323,7 @@ type
      *)
     ref_index: array [0..1] of PShortint;
 
-    {$IF LIBAVCODEC_VERSION >= 51068000} // 51.68.0
+    {$IF LIBAVCODEC_VERSION >= 51068000} // >= 51.68.0
     (**
      * reordered opaque 64bit number (generally a PTS) from AVCodecContext.reordered_opaque
      * output in AVFrame.reordered_opaque
@@ -840,8 +1332,20 @@ type
      *)
     reordered_opaque: cint64;
     {$IFEND}
+    
+    {$IF LIBAVCODEC_VERSION = 52021000} // = 52.21.0
+    (**
+     * hardware accelerator private data (FFmpeg allocated)
+     * - encoding: unused
+     * - decoding: Set by libavcodec
+     *)
+    hwaccel_data_private: pointer;
+    {$IFEND}
+    {$IF LIBAVCODEC_VERSION >= 52022000} // >= 52.22.0
+    hwaccel_picture_private: pointer;
+    {$IFEND}
 
-    {$IF LIBAVCODEC_VERSION >= 51070000} // 51.70.0
+    {$IF LIBAVCODEC_VERSION >= 51070000} // >= 51.70.0
     (**
      * Bits per sample/pixel of internal libavcodec pixel/sample format.
      * This field is applicable only when sample_fmt is SAMPLE_FMT_S32.
@@ -850,230 +1354,105 @@ type
      *)
     bits_per_raw_sample: cint;
     {$IFEND}
-  end;
-
-const
-  {$IF LIBAVCODEC_VERSION < 52000000} // < 52.0.0
-  DEFAULT_FRAME_RATE_BASE = 1001000;
-  {$IFEND}
-
-  FF_ASPECT_EXTENDED = 15;
-
-  FF_RC_STRATEGY_XVID = 1;
-
-  FF_BUG_AUTODETECT       = 1;  ///< autodetection
-  FF_BUG_OLD_MSMPEG4      = 2;
-  FF_BUG_XVID_ILACE       = 4;
-  FF_BUG_UMP4             = 8;
-  FF_BUG_NO_PADDING       = 16;
-  FF_BUG_AMV              = 32;
-  FF_BUG_AC_VLC           = 0;  ///< will be removed, libavcodec can now handle these non compliant files by default
-  FF_BUG_QPEL_CHROMA      = 64;
-  FF_BUG_STD_QPEL         = 128;
-  FF_BUG_QPEL_CHROMA2     = 256;
-  FF_BUG_DIRECT_BLOCKSIZE = 512;
-  FF_BUG_EDGE             = 1024;
-  FF_BUG_HPEL_CHROMA      = 2048;
-  FF_BUG_DC_CLIP          = 4096;
-  FF_BUG_MS               = 8192; ///< workaround various bugs in microsofts broken decoders
-  //FF_BUG_FAKE_SCALABILITY = 16 //Autodetection should work 100%.
-
-  FF_COMPLIANCE_VERY_STRICT   =  2; ///< strictly conform to a older more strict version of the spec or reference software
-  FF_COMPLIANCE_STRICT        =  1; ///< strictly conform to all the things in the spec no matter what consequences
-  FF_COMPLIANCE_NORMAL        =  0;
-  FF_COMPLIANCE_INOFFICIAL    = -1; ///< allow inofficial extensions
-  FF_COMPLIANCE_EXPERIMENTAL  = -2; ///< allow non standarized experimental things
-
-  FF_ER_CAREFUL         = 1;
-  FF_ER_COMPLIANT       = 2;
-  FF_ER_AGGRESSIVE      = 3;
-  FF_ER_VERY_AGGRESSIVE = 4;
-
-  FF_DCT_AUTO    = 0;
-  FF_DCT_FASTINT = 1;
-  FF_DCT_INT     = 2;
-  FF_DCT_MMX     = 3;
-  FF_DCT_MLIB    = 4;
-  FF_DCT_ALTIVEC = 5;
-  FF_DCT_FAAN    = 6;
-
-  FF_IDCT_AUTO         = 0;
-  FF_IDCT_INT          = 1;
-  FF_IDCT_SIMPLE       = 2;
-  FF_IDCT_SIMPLEMMX    = 3;
-  FF_IDCT_LIBMPEG2MMX  = 4;
-  FF_IDCT_PS2          = 5;
-  FF_IDCT_MLIB         = 6;
-  FF_IDCT_ARM          = 7;
-  FF_IDCT_ALTIVEC      = 8;
-  FF_IDCT_SH4          = 9;
-  FF_IDCT_SIMPLEARM    = 10;
-  FF_IDCT_H264         = 11;
-  FF_IDCT_VP3          = 12;
-  FF_IDCT_IPP          = 13;
-  FF_IDCT_XVIDMMX      = 14;
-  FF_IDCT_CAVS         = 15;
-  FF_IDCT_SIMPLEARMV5TE= 16;
-  FF_IDCT_SIMPLEARMV6  = 17;
-  FF_IDCT_SIMPLEVIS    = 18;
-  FF_IDCT_WMV2         = 19;
-  FF_IDCT_FAAN         = 20;
-
-  FF_EC_GUESS_MVS   = 1;
-  FF_EC_DEBLOCK     = 2;
-
-  FF_MM_FORCE	      = $80000000; (* force usage of selected flags (OR) *)
-  (* lower 16 bits - CPU features *)
-  FF_MM_MMX	        = $0001; ///< standard MMX
-  FF_MM_3DNOW	      = $0004; ///< AMD 3DNOW
-  FF_MM_MMXEXT	    = $0002; ///< SSE integer functions or AMD MMX ext
-  FF_MM_SSE	        = $0008; ///< SSE functions
-  FF_MM_SSE2	      = $0010; ///< PIV SSE2 functions
-  FF_MM_3DNOWEXT	  = $0020; ///< AMD 3DNowExt
-  FF_MM_SSE3        = $0040; ///< Prescott SSE3 functions
-  FF_MM_SSSE3       = $0080; ///< Conroe SSSE3 functions
-  FF_MM_IWMMXT	    = $0100; ///< XScale IWMMXT
-
-  FF_PRED_LEFT   = 0;
-  FF_PRED_PLANE  = 1;
-  FF_PRED_MEDIAN = 2;
-
-  FF_DEBUG_PICT_INFO    = 1;
-  FF_DEBUG_RC           = 2;
-  FF_DEBUG_BITSTREAM    = 4;
-  FF_DEBUG_MB_TYPE      = 8;
-  FF_DEBUG_QP           = 16;
-  FF_DEBUG_MV           = 32;
-  FF_DEBUG_DCT_COEFF    = $00000040;
-  FF_DEBUG_SKIP         = $00000080;
-  FF_DEBUG_STARTCODE    = $00000100;
-  FF_DEBUG_PTS          = $00000200;
-  FF_DEBUG_ER           = $00000400;
-  FF_DEBUG_MMCO         = $00000800;
-  FF_DEBUG_BUGS         = $00001000;
-  FF_DEBUG_VIS_QP       = $00002000;
-  FF_DEBUG_VIS_MB_TYPE  = $00004000;
-  FF_DEBUG_BUFFERS      = $00008000;
-
-  FF_DEBUG_VIS_MV_P_FOR  = $00000001; //visualize forward predicted MVs of P frames
-  FF_DEBUG_VIS_MV_B_FOR  = $00000002; //visualize forward predicted MVs of B frames
-  FF_DEBUG_VIS_MV_B_BACK = $00000004; //visualize backward predicted MVs of B frames
 
-  FF_CMP_SAD    = 0;
-  FF_CMP_SSE    = 1;
-  FF_CMP_SATD   = 2;
-  FF_CMP_DCT    = 3;
-  FF_CMP_PSNR   = 4;
-  FF_CMP_BIT    = 5;
-  FF_CMP_RD     = 6;
-  FF_CMP_ZERO   = 7;
-  FF_CMP_VSAD   = 8;
-  FF_CMP_VSSE   = 9;
-  FF_CMP_NSSE   = 10;
-  FF_CMP_W53    = 11;
-  FF_CMP_W97    = 12;
-  FF_CMP_DCTMAX = 13;
-  FF_CMP_DCT264 = 14;
-  FF_CMP_CHROMA = 256;
-
-  FF_DTG_AFD_SAME         = 8;
-  FF_DTG_AFD_4_3          = 9;
-  FF_DTG_AFD_16_9         = 10;
-  FF_DTG_AFD_14_9         = 11;
-  FF_DTG_AFD_4_3_SP_14_9  = 13;
-  FF_DTG_AFD_16_9_SP_14_9 = 14;
-  FF_DTG_AFD_SP_4_3       = 15;
-
-  FF_DEFAULT_QUANT_BIAS   = 999999;
-
-  FF_LAMBDA_SHIFT   = 7;
-  FF_LAMBDA_SCALE   = (1 shl FF_LAMBDA_SHIFT);
-  FF_QP2LAMBDA      = 118; ///< factor to convert from H.263 QP to lambda
-  FF_LAMBDA_MAX     = (256 * 128 - 1);
-
-  FF_QUALITY_SCALE  = FF_LAMBDA_SCALE; //FIXME maybe remove
-
-  FF_CODER_TYPE_VLC     = 0;
-  FF_CODER_TYPE_AC      = 1;
-  FF_CODER_TYPE_RAW     = 2;
-  FF_CODER_TYPE_RLE     = 3;
-  FF_CODER_TYPE_DEFLATE = 4;
-
-  SLICE_FLAG_CODED_ORDER    = $0001; ///< draw_horiz_band() is called in coded order instead of display
-  SLICE_FLAG_ALLOW_FIELD    = $0002; ///< allow draw_horiz_band() with field slices (MPEG2 field pics)
-  SLICE_FLAG_ALLOW_PLANE    = $0004; ///< allow draw_horiz_band() with 1 component at a time (SVQ1)
-
-  FF_MB_DECISION_SIMPLE = 0;        ///< uses mb_cmp
-  FF_MB_DECISION_BITS   = 1;        ///< chooses the one which needs the fewest bits
-  FF_MB_DECISION_RD     = 2;        ///< rate distortion
-
-  FF_AA_AUTO    = 0;
-  FF_AA_FASTINT = 1; //not implemented yet
-  FF_AA_INT     = 2;
-  FF_AA_FLOAT   = 3;
-
-  FF_PROFILE_UNKNOWN  = -99;
-  FF_PROFILE_AAC_MAIN = 0;
-  FF_PROFILE_AAC_LOW  = 1;
-  FF_PROFILE_AAC_SSR  = 2;
-  FF_PROFILE_AAC_LTP  = 3;
-
-  FF_LEVEL_UNKNOWN    = -99;
-
-  X264_PART_I4X4 = $001;  (* Analyse i4x4 *)
-  X264_PART_I8X8 = $002;  (* Analyse i8x8 (requires 8x8 transform) *)
-  X264_PART_P8X8 = $010;  (* Analyse p16x8, p8x16 and p8x8 *)
-  X264_PART_P4X4 = $020;  (* Analyse p8x4, p4x8, p4x4 *)
-  X264_PART_B8X8 = $100;  (* Analyse b16x8, b8x16 and b8x8 *)
-
-  FF_COMPRESSION_DEFAULT = -1;
+    {$IF LIBAVCODEC_VERSION >= 52002000} // >= 52.2.0
+    (**
+     * Audio channel layout.
+     * - encoding: set by user.
+     * - decoding: set by libavcodec.
+     *)
+    channel_layout: cint64;
 
-const
-  AVPALETTE_SIZE = 1024;
-  AVPALETTE_COUNT = 256;
+    (**
+     * Request decoder to use this channel layout if it can (0 for default)
+     * - encoding: unused
+     * - decoding: Set by user.
+     *)
+    request_channel_layout: cint64;
+    {$IFEND}
 
-type
-(**
- * AVPaletteControl
- * This structure defines a method for communicating palette changes
- * between and demuxer and a decoder.
- *
- * @deprecated Use AVPacket to send palette changes instead.
- * This is totally broken.
- *)
-  PAVPaletteControl = ^TAVPaletteControl;
-  TAVPaletteControl = record
-    (* demuxer sets this to 1 to indicate the palette has changed;
-     * decoder resets to 0 *)
-    palette_changed: cint;
+    {$IF LIBAVCODEC_VERSION >= 52004000} // >= 52.4.0
+    (**
+     * Ratecontrol attempt to use, at maximum, <value> of what can be used without an underflow.
+     * - encoding: Set by user.
+     * - decoding: unused.
+     *)
+    rc_max_available_vbv_use: cfloat;
 
-    (* 4-byte ARGB palette entries, stored in native byte order; note that
-     * the individual palette components should be on a 8-bit scale; if
-     * the palette data comes from a IBM VGA native format, the component
-     * data is probably 6 bits in size and needs to be scaled *)
-    palette: array [0..AVPALETTE_COUNT - 1] of cuint;
-  end; {deprecated;}
+    (**
+     * Ratecontrol attempt to use, at least, <value> times the amount needed to prevent a vbv overflow.
+     * - encoding: Set by user.
+     * - decoding: unused.
+     *)
+    rc_min_vbv_overflow_use: cfloat;
+    {$IFEND}
+    {$IF LIBAVCODEC_VERSION >= 52018000} // >= 52.18.0
+    (**
+     * Hardware accelerator in use
+     * - encoding: unused.
+     * - decoding: Set by libavcodec
+     *)
+    hwaccel: PAVHWAccel;
+    {$IFEND}
+    {$IF LIBAVCODEC_VERSION >= 52020000} // >= 52.20.0
+    (**
+     * For some codecs, the time base is closer to the field rate than the frame rate.
+     * Most notably, H.264 and MPEG-2 specify time_base as half of frame duration
+     * if no telecine is used ...
+     *
+     * Set to time_base ticks per frame. Default 1, e.g., H.264/MPEG-2 set it to 2.
+     *)
+    ticks_per_frame: cint;
+    {$IFEND}
+    {$IF LIBAVCODEC_VERSION >= 52021000} // >= 52.21.0
+    (**
+     * Hardware accelerator context.
+     * For some hardware accelerators, a global context needs to be
+     * provided by the user. In that case, this holds display-dependent
+     * data FFmpeg cannot instantiate itself. Please refer to the
+     * FFmpeg HW accelerator documentation to know how to fill this
+     * is. e.g. for VA API, this is a struct vaapi_context.
+     * - encoding: unused
+     * - decoding: Set by user
+     *)
+    hwaccel_context: pointer;
+    {$IFEND}
+    {$IF LIBAVCODEC_VERSION >= 52028000} // >= 52.28.0
+    (**
+     * Chromaticity coordinates of the source primaries.
+     * - encoding: Set by user
+     * - decoding: Set by libavcodec
+     *)
+    color_primaries: TAVColorPrimaries;
 
-type
-  PAVClass = ^TAVClass; {const}
-  PAVCodecContext = ^TAVCodecContext;
+    (**
+     * Color Transfer Characteristic.
+     * - encoding: Set by user
+     * - decoding: Set by libavcodec
+     *)
+    color_trc: TAVColorTransferCharacteristic;
 
-  PAVCodec = ^TAVCodec;
+    (**
+     * YUV colorspace type.
+     * - encoding: Set by user
+     * - decoding: Set by libavcodec
+     *)
+    colorspace: TAVColorSpace;
 
-  // int[4]
-  PQuadIntArray = ^TQuadIntArray;
-  TQuadIntArray = array[0..3] of cint;
-  // int (*func)(struct AVCodecContext *c2, void *arg)
-  TExecuteFunc = function(c2: PAVCodecContext; arg: Pointer): cint; cdecl;
+    (**
+     * MPEG vs JPEG YUV range.
+     * - encoding: Set by user
+     * - decoding: Set by libavcodec
+     *)
+    color_range: TAVColorRange;
 
-  TAVClass = record {12}
-    class_name: pchar;
-    (* actually passing a pointer to an AVCodecContext
-					or AVFormatContext, which begin with an AVClass.
-					Needed because av_log is in libavcodec and has no visibility
-					of AVIn/OutputFormat *)
-    item_name: function (): pchar; cdecl;
-    option: PAVOption;
+    (**
+     * This defines the location of chroma samples.
+     * - encoding: Set by user
+     * - decoding: Set by libavcodec
+     *)
+    chroma_sample_location: TAVChromaLocation;
+    {$IFEND}
   end;
 
   (**
@@ -1191,6 +1570,13 @@ type
      * decoder to draw a horizontal band. It improves cache usage. Not
      * all codecs can do that. You must check the codec capabilities
      * beforehand.
+     * The function is also used by hardware acceleration APIs.
+     * It is called at least once during frame decoding to pass
+     * the data needed for hardware render.
+     * In that mode instead of pixel data, AVFrame points to
+     * a structure specific to the acceleration API. The application
+     * reads the structure and can change some fields to indicate progress
+     * or mark state.
      * - encoding: unused
      * - decoding: Set by user.
      * @param height the height of the slice
@@ -1211,7 +1597,7 @@ type
      * - encoding: Set by user.
      * - decoding: Set by libavcodec.
      *)
-    sample_fmt: TSampleFormat;  ///< sample format, currenly unused
+    sample_fmt: TSampleFormat;  ///< sample format
 
     (* The following data should not be initialized. *)
     (**
@@ -1219,7 +1605,9 @@ type
      *)
     frame_size: cint;
     frame_number: cint;   ///< audio or video frame number
+{$IF LIBAVCODEC_MAX_VERSION_MAJOR < 53}
     real_pict_num: cint;  ///< returns the real picture number of previous encoded frame
+{$IFEND}
 
     (**
      * Number of frames the decoded output will be delayed relative to
@@ -1334,7 +1722,7 @@ type
      *)
     opaque: pointer;
 
-    codec_name: array [0..31] of char;
+    codec_name: array [0..31] of AnsiChar;
     codec_type: TCodecType; (* see CODEC_TYPE_xxx *)
     codec_id: TCodecID; (* see CODEC_ID_xxx *)
 
@@ -1408,6 +1796,9 @@ type
      * If pic.reference is set then the frame will be read later by libavcodec.
      * avcodec_align_dimensions() should be used to find the required width and
      * height, as they normally need to be rounded up to the next multiple of 16.
+     * if CODEC_CAP_DR1 is not set then get_buffer() must call
+     * avcodec_default_get_buffer() instead of providing buffers allocated by
+     * some other means.
      * - encoding: unused
      * - decoding: Set by libavcodec., user can override.
      *)
@@ -1423,7 +1814,8 @@ type
     release_buffer: procedure (c: PAVCodecContext; pic: PAVFrame); cdecl;
 
     (**
-     * If 1 the stream has a 1 frame delay during decoding.
+     * Size of the frame reordering buffer in the decoder.
+     * For MPEG-2 it is 1 IPB or 0 low delay IP.
      * - encoding: Set by libavcodec.
      * - decoding: Set by libavcodec.
      *)
@@ -1451,7 +1843,7 @@ type
      * - encoding: Set by libavcodec.
      * - decoding: unused
      *)
-    stats_out: pchar;
+    stats_out: PByteArray;
 
     (**
      * pass2 encoding statistics input buffer
@@ -1459,7 +1851,7 @@ type
      * - encoding: Allocated/set/freed by user.
      * - decoding: unused
      *)
-    stats_in: pchar;
+    stats_in: PByteArray;
 
     (**
      * ratecontrol qmin qmax limiting method
@@ -1485,7 +1877,7 @@ type
      * - encoding: Set by user
      * - decoding: unused
      *)
-    rc_eq: {const} pchar; 
+    rc_eq: {const} PByteArray; 
 
     (**
      * maximum bitrate
@@ -1886,7 +2278,7 @@ type
      * - encoding: unused
      * - decoding: Set by user, will be converted to uppercase by libavcodec during init.
      *)
-    stream_codec_tag: array [0..3] of char; //cuint;
+    stream_codec_tag: array [0..3] of AnsiChar; //cuint;
 
     (**
      * scene change detection threshold
@@ -1930,6 +2322,9 @@ type
      * libavcodec will pass previous buffer in pic, function should return
      * same buffer or new buffer with old frame "painted" into it.
      * If pic.data[0] == NULL must behave like get_buffer().
+     * if CODEC_CAP_DR1 is not set then reget_buffer() must call
+     * avcodec_default_reget_buffer() instead of providing buffers allocated by
+     * some other means.
      * - encoding: unused
      * - decoding: Set by libavcodec., user can override
      *)
@@ -1994,7 +2389,11 @@ type
      * - encoding: Set by libavcodec, user can override.
      * - decoding: Set by libavcodec, user can override.
      *)
+    {$IF LIBAVCODEC_VERSION < 52004000} // < 52.4.0
     execute: function (c: PAVCodecContext; func: TExecuteFunc; arg: PPointer; ret: PCint; count: cint): cint; cdecl;
+    {$ELSE}
+    execute: function (c: PAVCodecContext; func: TExecuteFunc; arg: Pointer; ret: PCint; count: cint; size: cint): cint; cdecl;
+    {$IFEND}
 
     (**
      * thread opaque
@@ -2197,7 +2596,7 @@ type
     (**
      * number of reference frames
      * - encoding: Set by user.
-     * - decoding: unused
+     * - decoding: Set by lavc.
      *)
     refs: cint;
 
@@ -2349,13 +2748,16 @@ type
     {$IFEND}
 
     {$IF LIBAVCODEC_VERSION >= 51042000} // 51.42.0
+    {$IF LIBAVCODEC_MAX_VERSION_MAJOR < 53}
     (**
      * Decoder should decode to this many channels if it can (0 for default)
      * - encoding: unused
      * - decoding: Set by user.
+     * @deprecated Deprecated in favor of request_channel_layout.
      *)
     request_channels: cint;
     {$IFEND}
+    {$IFEND}
 
     {$IF LIBAVCODEC_VERSION > 51049000} // > 51.49.0
     (**
@@ -2376,21 +2778,66 @@ type
      *)
     reordered_opaque: cint64;
     {$IFEND}
+    
+    {$IF LIBAVCODEC_VERSION >= 52028000} // 52.28.0
+    (**
+     * This defines the location of chroma samples.
+     * - encoding: Set by user
+     * - decoding: Set by libavcodec
+     *)
+     chroma_sample_location: TAVChromaLocation;
+    {$IFEND}
+    {$IF LIBAVCODEC_VERSION >= 52037000} // >= 52.37.0
+    (**
+     * The codec may call this to execute several independent things.
+     * It will return only after finishing all tasks.
+     * The user may replace this with some multithreaded implementation,
+     * the default implementation will execute the parts serially.
+     * Also see avcodec_thread_init and e.g. the --enable-pthread configure option.
+     * @param c context passed also to func
+     * @param count the number of things to execute
+     * @param arg2 argument passed unchanged to func
+     * @param ret return values of executed functions, must have space for "count" values. May be NULL.
+     * @param func function that will be called count times, with jobnr from 0 to count-1.
+     *             threadnr will be in the range 0 to c->thread_count-1 < MAX_THREADS and so that no
+     *             two instances of func executing at the same time will have the same threadnr.
+     * @return always 0 currently, but code should handle a future improvement where when any call to func
+     *         returns < 0 no further calls to func may be done and < 0 is returned.
+     * - encoding: Set by libavcodec, user can override.
+     * - decoding: Set by libavcodec, user can override.
+     *)
+    execute2: function (c: PAVCodecContext; func: function (c2: PAVCodecContext; arg: Pointer; jobnr: cint; threadnr: cint): cint; cdecl; arg2: Pointer; ret: Pcint; count: cint): cint; cdecl;
+    {$IFEND}
+    {$IF LIBAVCODEC_VERSION >= 52042000} // >= 52.42.0
+    (**
+     * explicit P-frame weighted prediction analysis method
+     * 0: off
+     * 1: fast blind weighting (one reference duplicate with -1 offset)
+     * 2: smart weighting (full fade detection analysis)
+     * - encoding: Set by user.
+     * - decoding: unused
+     *)
+    weighted_p_pred: cint;
+    {$IFEND}
   end;
 
 (**
  * AVCodec.
  *)
   TAVCodec = record
-    name: pchar;
+    name: PAnsiChar;
     type_: TCodecType;
     id: TCodecID;
     priv_data_size: cint;
     init: function (avctx: PAVCodecContext): cint; cdecl; (* typo corretion by the Creative CAT *)
-    encode: function (avctx: PAVCodecContext; buf: pchar; buf_size: cint; data: pointer): cint; cdecl;
+    encode: function (avctx: PAVCodecContext; buf: PByteArray; buf_size: cint; data: pointer): cint; cdecl;
     close: function (avctx: PAVCodecContext): cint; cdecl;
     decode: function (avctx: PAVCodecContext; outdata: pointer; var outdata_size: cint;
-                      buf: {const} pchar; buf_size: cint): cint; cdecl;
+    {$IF LIBAVCODEC_VERSION < 52025000} // 52.25.0
+                      buf: {const} PByteArray; buf_size: cint): cint; cdecl;
+    {$ELSE}
+                      avpkt: PAVPacket): cint; cdecl;
+    {$IFEND}
     (**
      * Codec capabilities.
      * see CODEC_CAP_*
@@ -2406,10 +2853,10 @@ type
     pix_fmts: {const} PAVPixelFormat;       ///< array of supported pixel formats, or NULL if unknown, array is terminated by -1
     {$IF LIBAVCODEC_VERSION >= 51055000} // 51.55.0
     (**
-     * Descriptive name for the codec, meant to be more human readable than \p name.
-     * You \e should use the NULL_IF_CONFIG_SMALL() macro to define it.
+     * Descriptive name for the codec, meant to be more human readable than name.
+     * You should use the NULL_IF_CONFIG_SMALL() macro to define it.
      *)
-    long_name: {const} PChar;
+    long_name: {const} PAnsiChar;
     {$IFEND}
     {$IF LIBAVCODEC_VERSION >= 51056000} // 51.56.0
     supported_samplerates: {const} PCint;       ///< array of supported audio samplerates, or NULL if unknown, array is terminated by 0
@@ -2417,7 +2864,109 @@ type
     {$IF LIBAVCODEC_VERSION >= 51062000} // 51.62.0
     sample_fmts: {const} PSampleFormatArray;   ///< array of supported sample formats, or NULL if unknown, array is terminated by -1
     {$IFEND}
+    {$IF LIBAVCODEC_VERSION >= 52002000} // 52.2.0
+    channel_layouts: {const} PCint64;         ///< array of support channel layouts, or NULL if unknown. array is terminated by 0
+    {$IFEND}
+  end;
+
+{$IF LIBAVCODEC_VERSION >= 52018000} // 52.18.0
+(**
+ * AVHWAccel.
+ *)
+  TAVHWAccel = record
+    (**
+     * Name of the hardware accelerated codec.
+     * The name is globally unique among encoders and among decoders (but an
+     * encoder and a decoder can share the same name).
+     *)
+    name: PAnsiChar;
+
+    (**
+     * Type of codec implemented by the hardware accelerator.
+     *
+     * See CODEC_TYPE_xxx
+     *)
+    type_: TCodecType;
+
+    (**
+     * Codec implemented by the hardware accelerator.
+     *
+     * See CODEC_ID_xxx
+     *)
+    id: TCodecID;
+
+    (**
+     * Supported pixel format.
+     *
+     * Only hardware accelerated formats are supported here.
+     *)
+    pix_fmt: {const} PAVPixelFormat; 
+
+    (**
+     * Hardware accelerated codec capabilities.
+     * see FF_HWACCEL_CODEC_CAP_*
+     *)
+    capabilities: cint;
+
+    next: PAVCodec;
+
+    (**
+     * Called at the beginning of each frame or field picture.
+     *
+     * Meaningful frame information (codec specific) is guaranteed to
+     * be parsed at this point. This function is mandatory.
+     *
+     * Note that buf can be NULL along with buf_size set to 0.
+     * Otherwise, this means the whole frame is available at this point.
+     *
+     * @param avctx the codec context
+     * @param buf the frame data buffer base
+     * @param buf_size the size of the frame in bytes
+     * @return zero if successful, a negative value otherwise
+     *)
+    start_frame: function (avctx:    PAVCodecContext; 
+                           buf:      PByteArray; 
+                           buf_size: cint): cint; cdecl;
+
+    (**
+     * Callback for each slice.
+     *
+     * Meaningful slice information (codec specific) is guaranteed to
+     * be parsed at this point. This function is mandatory.
+     *
+     * @param avctx the codec context
+     * @param buf the slice data buffer base
+     * @param buf_size the size of the slice in bytes
+     * @return zero if successful, a negative value otherwise
+     *)
+    decode_slice: function (avctx:    PAVCodecContext;
+                            buf:      PByteArray; 
+                            buf_size: cint): cint; cdecl;
+
+    (**
+     * Called at the end of each frame or field picture.
+     *
+     * The whole picture is parsed at this point and can now be sent
+     * to the hardware accelerator. This function is mandatory.
+     *
+     * @param avctx the codec context
+     * @return zero if successful, a negative value otherwise
+     *)
+    end_frame: function (avctx: PAVCodecContext): cint; cdecl;
+        
+{$IF LIBAVCODEC_VERSION >= 52021000} // >= 52.21.0
+    (**
+     * Size of HW accelerator private data.
+     *
+     * Private data is allocated with av_mallocz() before
+     * AVCodecContext.get_buffer() and deallocated after
+     * AVCodecContext.release_buffer().
+     *)
+    priv_data_size: cint;
+{$IFEND}
+        
   end;
+{$IFEND}
 
 (**
  * four components are given, that's all.
@@ -2425,35 +2974,149 @@ type
  *)
   PAVPicture = ^TAVPicture;
   TAVPicture = record
-    data: array [0..3] of pchar;
+    data: array [0..3] of PByteArray;
     linesize: array [0..3] of cint;       ///< number of bytes per line
   end;
 
 type
+  TAVSubtitleType = (
+    SUBTITLE_NONE,
+
+    SUBTITLE_BITMAP,                ///< A bitmap, pict will be set
+
+    (**
+     * Plain text, the text field must be set by the decoder and is
+     * authoritative. ass and pict fields may contain approximations.
+     *)
+    SUBTITLE_TEXT,
+
+    (**
+     * Formatted text, the ass field must be set by the decoder and is
+     * authoritative. pict and text fields may contain approximations.
+     *)
+    SUBTITLE_ASS
+  );
+
+type
+  PPAVSubtitleRect = ^PAVSubtitleRect;
   PAVSubtitleRect = ^TAVSubtitleRect;
+  {$IF LIBAVCODEC_VERSION < 52010000} // < 52.10.0
   TAVSubtitleRect = record
-    x: word;
-    y: word;
-    w: word;
-    h: word;
-    nb_colors: word;
+    x: cuint16;
+    y: cuint16;
+    w: cuint16;
+    h: cuint16;
+    nb_colors: cuint16;
     linesize: cint;
-    rgba_palette: PCuint;
-    bitmap: pchar;
+    rgba_palette: PCuint32;
+    bitmap: PCuint8;
+  end;
+  {$ELSE}
+  TAVSubtitleRect = record
+    x: cint;        ///< top left corner  of pict, undefined when pict is not set
+    y: cint;        ///< top left corner  of pict, undefined when pict is not set
+    w: cint;        ///< width            of pict, undefined when pict is not set
+    h: cint;        ///< height           of pict, undefined when pict is not set
+    nb_colors: cint; ///< number of colors in pict, undefined when pict is not set
+
+    (**
+     * data+linesize for the bitmap of this subtitle.
+     * can be set for text/ass as well once they where rendered
+     *)
+    pict: TAVPicture;
+    type_: TAVSubtitleType;
+
+    text: PAnsiChar;                     ///< 0 terminated plain UTF-8 text
+
+    (**
+     * 0 terminated ASS/SSA compatible event line.
+     * The pressentation of this is unaffected by the other values in this
+     * struct.
+     *)
+    ass: PByteArray;
   end;
+  {$IFEND}
 
+  PPAVSubtitle = ^PAVSubtitle;
   PAVSubtitle = ^TAVSubtitle;
-  TAVSubtitle = record {20}
-    format: word; (* 0 = graphics *)
-    start_display_time: cuint; (* relative to packet pts, in ms *)
-    end_display_time: cuint; (* relative to packet pts, in ms *)
+  TAVSubtitle = record
+    format: cuint16; (* 0 = graphics *)
+    start_display_time: cuint32; (* relative to packet pts, in ms *)
+    end_display_time: cuint32; (* relative to packet pts, in ms *)
     num_rects: cuint;
+    {$IF LIBAVCODEC_VERSION < 52010000} // < 52.10.0
     rects: PAVSubtitleRect;
+    {$ELSE}
+    rects: PPAVSubtitleRect;
+    {$IFEND}
+    {$IF LIBAVCODEC_VERSION >= 52032000} // >= 52.32.0
+    pts: cint64;     ///< Same as packet pts, in AV_TIME_BASE
+    {$IFEND}
   end;
 
+{$IF LIBAVCODEC_VERSION >= 52025000} // 52.25.0
+{ packet functions  }
 
-(* resample.c *)
+(**
+ * @deprecated use NULL instead
+ *)
+procedure av_destruct_packet_nofree(pkt: PAVPacket);
+  cdecl; external av__codec;
+
+(*
+ * Default packet destructor.
+ *)
+procedure av_destruct_packet(pkt: PAVPacket);
+  cdecl; external av__codec;
 
+(*
+ * Initialize optional fields of a packet with default values.
+ *
+ * @param pkt packet
+ *)
+procedure av_init_packet(var pkt: TAVPacket);
+  cdecl; external av__codec;
+
+(*
+ * Allocate the payload of a packet and initialize its fields with
+ * default values.
+ *
+ * @param pkt packet
+ * @param size wanted payload size
+ * @return 0 if OK, AVERROR_xxx otherwise
+ *)
+function av_new_packet(pkt: PAVPacket; size: cint): cint;
+  cdecl; external av__codec;
+
+(*
+ * Reduce packet size, correctly zeroing padding
+ *
+ * @param pkt packet
+ * @param size new size
+ *)
+procedure av_shrink_packet(pkt: PAVPacket; size: cint);
+  cdecl; external av__codec;
+
+(*
+ * @warning This is a hack - the packet memory allocation stuff is broken. The
+ * packet is allocated if it was not really allocated.
+ *)
+function av_dup_packet(pkt: PAVPacket): cint;
+  cdecl; external av__codec;
+
+(*
+ * Free a packet.
+ *
+ * @param pkt packet to free
+ *)
+procedure av_free_packet(pkt: PAVPacket);
+{$IF LIBAVCODEC_VERSION >= 52028000} // 52.28.0
+  cdecl; external av__codec;
+{$IFEND}
+{$IFEND}
+
+(* resample.c *)
+type
   PReSampleContext = pointer;
   PAVResampleContext = pointer;
   PImgReSampleContext = pointer;
@@ -2468,15 +3131,44 @@ function audio_resample (s: PReSampleContext; output: PSmallint; input: PSmallin
 procedure audio_resample_close (s: PReSampleContext);
   cdecl; external av__codec;
 
-
+(**
+ * Initializes an audio resampler.
+ * Note, if either rate is not an integer then simply scale both rates up so they are.
+ * @param filter_length length of each FIR filter in the filterbank relative to the cutoff freq
+ * @param log2_phase_count log2 of the number of entries in the polyphase filterbank
+ * @param linear If 1 then the used FIR filter will be linearly interpolated
+                 between the 2 closest, if 0 the closest will be used
+ * @param cutoff cutoff frequency, 1.0 corresponds to half the output sampling rate
+ *)
 function av_resample_init (out_rate: cint; in_rate: cint; filter_length: cint;
                            log2_phase_count: cint; linear: cint; cutoff: cdouble): PAVResampleContext;
   cdecl; external av__codec;
 
+(**
+ * resamples.
+ * @param src an array of unconsumed samples
+ * @param consumed the number of samples of src which have been consumed are returned here
+ * @param src_size the number of unconsumed samples available
+ * @param dst_size the amount of space in samples available in dst
+ * @param update_ctx If this is 0 then the context will not be modified, that way several channels can be resampled with the same context.
+ * @return the number of samples written in dst or -1 if an error occurred
+ *)
 function av_resample (c: PAVResampleContext; dst: PSmallint; src: PSmallint; var consumed: cint;
                       src_size: cint; dst_size: cint; update_ctx: cint): cint;
   cdecl; external av__codec;
 
+(**
+ * Compensates samplerate/timestamp drift. The compensation is done by changing
+ * the resampler parameters, so no audible clicks or similar distortions occur
+ * @param compensation_distance distance in output samples over which the compensation should be performed
+ * @param sample_delta number of output samples which should be output less
+ *
+ * example: av_resample_compensate(c, 10, 500)
+ * here instead of 510 samples only 500 samples would be output
+ *
+ * note, due to rounding the actual compensation might be slightly different,
+ * especially if the compensation_distance is large and the in_rate used during init is small
+ *)
 procedure av_resample_compensate (c: PAVResampleContext; sample_delta: cint;
                                   compensation_distance: cint);
   cdecl; external av__codec;
@@ -2484,7 +3176,6 @@ procedure av_resample_compensate (c: PAVResampleContext; sample_delta: cint;
 procedure av_resample_close (c: PAVResampleContext);
   cdecl; external av__codec;
 
-
 {$IF LIBAVCODEC_VERSION < 52000000} // 52.0.0
 (* YUV420 format is assumed ! *)
 
@@ -2517,7 +3208,6 @@ procedure img_resample (s: PImgReSampleContext; output: PAVPicture; input: {cons
  *)
 procedure img_resample_close (s: PImgReSampleContext);
   cdecl; external av__codec; deprecated;
-
 {$IFEND}
 
 (**
@@ -2549,6 +3239,7 @@ procedure avpicture_free (picture: PAVPicture);
  * If a planar format is specified, several pointers will be set pointing to
  * the different picture planes and the line sizes of the different planes
  * will be stored in the lines_sizes array.
+ * Call with ptr == NULL to get the required size for the ptr buffer.
  *
  * @param picture AVPicture whose fields are to be filled in
  * @param ptr Buffer which will contain or contains the actual image data
@@ -2563,17 +3254,20 @@ function avpicture_fill (picture: PAVPicture; ptr: pointer;
 
 function avpicture_layout (src: {const} PAVPicture; pix_fmt: TAVPixelFormat;
                    width: cint; height: cint;
-                   dest: pchar; dest_size: cint): cint;
+                   dest: PByteArray; dest_size: cint): cint;
   cdecl; external av__codec;
 
 (**
  * Calculate the size in bytes that a picture of the given width and height
  * would occupy if stored in the given picture format.
+ * Note that this returns the size of a compact representation as generated
+ * by avpicture_layout, which can be smaller than the size required for e.g.
+ * avpicture_fill.
  *
  * @param pix_fmt the given picture format
  * @param width the width of the image
  * @param height the height of the image
- * @return Image data size in bytes
+ * @return Image data size in bytes or -1 on error (e.g. too large dimensions).
  *)
 function avpicture_get_size (pix_fmt: TAVPixelFormat; width: cint; height: cint): cint;
   cdecl; external av__codec;
@@ -2581,13 +3275,35 @@ function avpicture_get_size (pix_fmt: TAVPixelFormat; width: cint; height: cint)
 procedure avcodec_get_chroma_sub_sample (pix_fmt: TAVPixelFormat; var h_shift: cint; var v_shift: cint);
   cdecl; external av__codec;
 
-function avcodec_get_pix_fmt_name(pix_fmt: TAVPixelFormat): pchar;
+(**
+ * Returns the pixel format corresponding to the name \p name.
+ *
+ * If there is no pixel format with name \p name, then looks for a
+ * pixel format with the name corresponding to the native endian
+ * format of \p name.
+ * For example in a little-endian system, first looks for "gray16",
+ * then for "gray16le".
+ *
+ * Finally if no pixel format has been found, returns \c PIX_FMT_NONE.
+ *)
+function avcodec_get_pix_fmt_name(pix_fmt: TAVPixelFormat): PAnsiChar;
   cdecl; external av__codec;
 
 procedure avcodec_set_dimensions(s: PAVCodecContext; width: cint; height: cint);
   cdecl; external av__codec;
 
-function avcodec_get_pix_fmt(name: {const} pchar): TAVPixelFormat;
+(**
+ * Returns the pixel format corresponding to the name name.
+ *
+ * If there is no pixel format with name name, then looks for a
+ * pixel format with the name corresponding to the native endian
+ * format of name.
+ * For example in a little-endian system, first looks for "gray16",
+ * then for "gray16le".
+ *
+ * Finally if no pixel format has been found, returns PIX_FMT_NONE.
+ *)
+function avcodec_get_pix_fmt(name: {const} PAnsiChar): TAVPixelFormat;
   cdecl; external av__codec;
 
 function avcodec_pix_fmt_to_codec_tag(p: TAVPixelFormat): cuint;
@@ -2630,7 +3346,7 @@ function avcodec_get_pix_fmt_loss (dst_pix_fmt: TAVPixelFormat; src_pix_fmt: TAV
  * some formats to other formats. avcodec_find_best_pix_fmt() searches which of
  * the given pixel formats should be used to suffer the least amount of loss.
  * The pixel formats from which it chooses one, are determined by the
- * \p pix_fmt_mask parameter.
+ * pix_fmt_mask parameter.
  *
  * @code
  * src_pix_fmt = PIX_FMT_YUV420P;
@@ -2648,10 +3364,14 @@ function avcodec_get_pix_fmt_loss (dst_pix_fmt: TAVPixelFormat; src_pix_fmt: TAV
 function avcodec_find_best_pix_fmt(pix_fmt_mask: cint64; src_pix_fmt: TAVPixelFormat;
                             has_alpha: cint; loss_ptr: PCint): cint;
   cdecl; external av__codec;
-{$ELSE}
+{$ELSEIF LIBAVCODEC_VERSION < 52022001}
 function avcodec_find_best_pix_fmt(pix_fmt_mask: cint; src_pix_fmt: TAVPixelFormat;
                             has_alpha: cint; loss_ptr: PCint): cint;
   cdecl; external av__codec;
+{$ELSE}
+function avcodec_find_best_pix_fmt(pix_fmt_mask: cint; src_pix_fmt: TAVPixelFormat;
+                            has_alpha: cint; loss_ptr: PCint): TAVPixelFormat;
+  cdecl; external av__codec;
 {$IFEND}
 
 {$IF LIBAVCODEC_VERSION >= 51041000} // 51.41.0
@@ -2665,9 +3385,14 @@ function avcodec_find_best_pix_fmt(pix_fmt_mask: cint; src_pix_fmt: TAVPixelForm
  * a negative value to print the corresponding header.
  * Meaningful values for obtaining a pixel format info vary from 0 to PIX_FMT_NB -1.
  *)
-procedure avcodec_pix_fmt_string (buf: PChar; buf_size: cint; pix_fmt: cint);
+{$IF LIBAVCODEC_VERSION < 52022001} // 52.22.1
+procedure avcodec_pix_fmt_string (buf: PAnsiChar; buf_size: cint; pix_fmt: cint);
+  cdecl; external av__codec;
+{$ELSE}
+procedure avcodec_pix_fmt_string (buf: PAnsiChar; buf_size: cint; pix_fmt: TAVPixelFormat);
   cdecl; external av__codec;
 {$IFEND}
+{$IFEND}
 
 const
   FF_ALPHA_TRANSP      = $0001; {* image has some totally transparent pixels *}
@@ -2679,7 +3404,8 @@ const
  *)
 function img_get_alpha_info (src: {const} PAVPicture;
                              pix_fmt: TAVPixelFormat;
-                             width: cint; height: cint): cint;
+                             width:   cint;
+                             height:  cint): cint;
   cdecl; external av__codec;
 
 {$IF LIBAVCODEC_VERSION < 52000000} // 52.0.0
@@ -2695,8 +3421,11 @@ function img_convert (dst: PAVPicture; dst_pix_fmt: TAVPixelFormat;
 
 (* deinterlace a picture *)
 (* deinterlace - if not supported return -1 *)
-function avpicture_deinterlace (dst: PAVPicture; src: {const} PAVPicture;
-                        pix_fmt: TAVPixelFormat; width: cint; height: cint): cint;
+function avpicture_deinterlace (dst: PAVPicture;
+                        src: {const} PAVPicture;
+                        pix_fmt: TAVPixelFormat;
+                        width:   cint;
+                        height:  cint): cint;
   cdecl; external av__codec;
 
 {* external high level API *}
@@ -2709,6 +3438,11 @@ var
 {$IFEND}
 
 {$IF LIBAVCODEC_VERSION >= 51049000} // 51.49.0
+(**
+ * If c is NULL, returns the first registered codec,
+ * if c is non-NULL, returns the next registered codec after c,
+ * or NULL if c is the last one.
+ *)
 function av_codec_next(c: PAVCodec): PAVCodec;
   cdecl; external av__codec;
 {$IFEND}
@@ -2725,18 +3459,44 @@ function avcodec_build(): cuint;
   cdecl; external av__codec; deprecated;
 {$IFEND}
 
+{$IF LIBAVCODEC_VERSION >= 52041000} // 52.41.0
+(**
+ * Returns the libavcodec build-time configuration.
+ *)
+function avcodec_configuration(): PAnsiChar;
+  cdecl; external av__codec;
+
+(**
+ * Returns the libavcodec license.
+ *)
+function avcodec_license(): PAnsiChar;
+  cdecl; external av__codec;
+{$IFEND}
+
 (**
  * Initializes libavcodec.
  *
- * @warning This function \e must be called before any other libavcodec
+ * @warning This function must be called before any other libavcodec
  * function.
  *)
 procedure avcodec_init();
   cdecl; external av__codec;
 
-procedure register_avcodec(format: PAVCodec);
+(**
+ * Register the codec codec and initialize libavcodec.
+ *
+ * @see avcodec_init()
+ *)
+{$IF LIBAVCODEC_VERSION >= 52014000} // 52.14.0
+procedure avcodec_register(codec: PAVCodec);
   cdecl; external av__codec;
-
+// Deprecated in favor of avcodec_register.
+procedure register_avcodec(codec: PAVCodec);
+  cdecl; external av__codec; deprecated;
+{$ELSEIF LIBAVCODEC_VERSION_MAJOR < 53}
+procedure register_avcodec(codec: PAVCodec);
+  cdecl; external av__codec;
+{$IFEND}
 (**
  * Finds a registered encoder with a matching codec ID.
  *
@@ -2752,7 +3512,7 @@ function avcodec_find_encoder(id: TCodecID): PAVCodec;
  * @param name name of the requested encoder
  * @return An encoder if one was found, NULL otherwise.
  *)
-function avcodec_find_encoder_by_name(name: pchar): PAVCodec;
+function avcodec_find_encoder_by_name(name: PAnsiChar): PAVCodec;
   cdecl; external av__codec;
 
 (**
@@ -2770,9 +3530,9 @@ function avcodec_find_decoder(id: TCodecID): PAVCodec;
  * @param name name of the requested decoder
  * @return A decoder if one was found, NULL otherwise.
  *)
-function avcodec_find_decoder_by_name(name: pchar): PAVCodec;
+function avcodec_find_decoder_by_name(name: PAnsiChar): PAVCodec;
   cdecl; external av__codec;
-procedure avcodec_string(buf: pchar; buf_size: cint; enc: PAVCodecContext; encode: cint);
+procedure avcodec_string(buf: PAnsiChar; buf_size: cint; enc: PAVCodecContext; encode: cint);
   cdecl; external av__codec;
 
 (**
@@ -2851,10 +3611,27 @@ function avcodec_thread_init(s: PAVCodecContext; thread_count: cint): cint;
   cdecl; external av__codec;
 procedure avcodec_thread_free(s: PAVCodecContext);
   cdecl; external av__codec;
+
+
+{$IF LIBAVCODEC_VERSION < 52004000} // < 52.4.0
 function avcodec_thread_execute(s: PAVCodecContext; func: TExecuteFunc; arg: PPointer; var ret: cint; count: cint): cint;
   cdecl; external av__codec;
+{$ELSE}
+function avcodec_thread_execute(s: PAVCodecContext; func: TExecuteFunc; arg: Pointer; var ret: cint; count: cint; size: cint): cint;
+  cdecl; external av__codec;
+{$IFEND}
+
+{$IF LIBAVCODEC_VERSION < 52004000} // < 52.4.0
 function avcodec_default_execute(s: PAVCodecContext; func: TExecuteFunc; arg: PPointer; var ret: cint; count: cint): cint;
   cdecl; external av__codec;
+{$ELSE}
+function avcodec_default_execute(s: PAVCodecContext; func: TExecuteFunc; arg: Pointer; var ret: cint; count: cint; size: cint): cint;
+  cdecl; external av__codec;
+{$IFEND}
+{$IF LIBAVCODEC_VERSION >= 52037000} // >= 52.37.0
+function avcodec_default_execute2(s: PAVCodecContext; func: TExecuteFunc; arg: Pointer; var ret: cint; count: cint): cint;
+  cdecl; external av__codec;
+{$IFEND}
 //FIXME func typedef
 
 (**
@@ -2889,122 +3666,191 @@ function avcodec_open(avctx: PAVCodecContext; codec: PAVCodec): cint;
 
 {$IF LIBAVCODEC_VERSION < 52000000} // < 52.0.0
 (**
- * @deprecated Use avcodec_decode_audio2() instead.
+ * @deprecated Use avcodec_decode_audio2 instead.
  *)
 function avcodec_decode_audio(avctx: PAVCodecContext; samples: PSmallint;
                            var frame_size_ptr: cint;
-                           buf: {const} pchar; buf_size: cint): cint;
-  cdecl; external av__codec;
+                           buf: {const} PByteArray; buf_size: cint): cint;
+  cdecl; external av__codec; {deprecated;}
 {$IFEND}
 
+{$IF LIBAVCODEC_MAX_VERSION_MAJOR < 53}
 {$IF LIBAVCODEC_VERSION >= 51030000} // 51.30.0
 (**
- * Decodes an audio frame from \p buf into \p samples.
- * The avcodec_decode_audio2() function decodes an audio frame from the input
- * buffer \p buf of size \p buf_size. To decode it, it makes use of the
- * audio codec which was coupled with \p avctx using avcodec_open(). The
- * resulting decoded frame is stored in output buffer \p samples.  If no frame
- * could be decompressed, \p frame_size_ptr is zero. Otherwise, it is the
- * decompressed frame size in \e bytes.
+ * Decodes an audio frame from buf into samples.
+ * Wrapper function which calls avcodec_decode_audio3.
  *
- * @warning You \e must set \p frame_size_ptr to the allocated size of the
- * output buffer before calling avcodec_decode_audio2().
+ * @deprecated Use avcodec_decode_audio3 instead.
+ * @param avctx the codec context
+ * @param[out] samples the output buffer, sample type in avctx->sample_fmt
+ * @param[in,out] frame_size_ptr the output buffer size in bytes
+ * @param[in] buf the input buffer
+ * @param[in] buf_size the input buffer size in bytes
+ * @return On error a negative value is returned, otherwise the number of bytes
+ * used or zero if no frame could be decompressed.
+ *)
+function avcodec_decode_audio2(avctx: PAVCodecContext; samples: PSmallint;
+               var frame_size_ptr: cint;
+               buf: {const} PByteArray; buf_size: cint): cint;
+  cdecl; external av__codec; {deprecated;}
+{$IFEND}
+{$IFEND}
+
+{$IF LIBAVCODEC_VERSION >= 52025000} // 52.25.0
+(**
+ * Decodes the audio frame of size avpkt->size from avpkt->data into samples.
+ * Some decoders may support multiple frames in a single AVPacket, such
+ * decoders would then just decode the first frame. In this case,
+ * avcodec_decode_audio3 has to be called again with an AVPacket that contains
+ * the remaining data in order to decode the second frame etc.
+ * If no frame
+ * could be outputted, frame_size_ptr is zero. Otherwise, it is the
+ * decompressed frame size in bytes.
+ *
+ * @warning You must set frame_size_ptr to the allocated size of the
+ * output buffer before calling avcodec_decode_audio3().
  *
- * @warning The input buffer must be \c FF_INPUT_BUFFER_PADDING_SIZE larger than
+ * @warning The input buffer must be FF_INPUT_BUFFER_PADDING_SIZE larger than
  * the actual read bytes because some optimized bitstream readers read 32 or 64
  * bits at once and could read over the end.
  *
- * @warning The end of the input buffer \p buf should be set to 0 to ensure that
+ * @warning The end of the input buffer avpkt->data should be set to 0 to ensure that
  * no overreading happens for damaged MPEG streams.
  *
- * @note You might have to align the input buffer \p buf and output buffer \p
+ * @note You might have to align the input buffer avpkt->data and output buffer
  * samples. The alignment requirements depend on the CPU: On some CPUs it isn't
  * necessary at all, on others it won't work at all if not aligned and on others
- * it will work but it will have an impact on performance. In practice, the
- * bitstream should have 4 byte alignment at minimum and all sample data should
- * be 16 byte aligned unless the CPU doesn't need it (AltiVec and SSE do). If
- * the linesize is not a multiple of 16 then there's no sense in aligning the
- * start of the buffer to 16.
+ * * it will work but it will have an impact on performance.
+ *
+ * In practice, avpkt->data should have 4 byte alignment at minimum and
+ * samples should be 16 byte aligned unless the CPU doesn't need it
+ * (AltiVec and SSE do).
+ *
+ * @note Some codecs have a delay between input and output, these need to be
+ * feeded with avpkt->data=NULL, avpkt->size=0 at the end to return the remaining frames.
  *
  * @param avctx the codec context
  * @param[out] samples the output buffer
  * @param[in,out] frame_size_ptr the output buffer size in bytes
- * @param[in] buf the input buffer
- * @param[in] buf_size the input buffer size in bytes
+ * @param[in] avpkt The input AVPacket containing the input buffer.
+ *            You can create such packet with av_init_packet() and by then setting
+ *            data and size, some decoders might in addition need other fields.
+ *            All decoders are designed to use the least fields possible though.
  * @return On error a negative value is returned, otherwise the number of bytes
- * used or zero if no frame could be decompressed.
+ * used or zero if no frame data was decompressed (used) from the input AVPacket.
  *)
-function avcodec_decode_audio2(avctx: PAVCodecContext; samples: PSmallint;
+function avcodec_decode_audio3(avctx: PAVCodecContext; samples: PSmallint;
                var frame_size_ptr: cint;
-               buf: {const} pchar; buf_size: cint): cint;
+               avpkt: PAVPacket): cint;
   cdecl; external av__codec;
 {$IFEND}
 
+{$IF LIBAVCODEC_MAX_VERSION_MAJOR < 53}
+(**
+ * Decodes a video frame from buf into picture.
+ * Wrapper function which calls avcodec_decode_video2.
+ *
+ * @deprecated Use avcodec_decode_video2 instead.
+ * @param avctx the codec context
+ * @param[out] picture The AVFrame in which the decoded video frame will be stored.
+ * @param[in] buf the input buffer
+ * @param[in] buf_size the size of the input buffer in bytes
+ * @param[in,out] got_picture_ptr Zero if no frame could be decompressed, otherwise, it is nonzero.
+ * @return On error a negative value is returned, otherwise the number of bytes
+ * used or zero if no frame could be decompressed.
+ *)
+function avcodec_decode_video(avctx: PAVCodecContext; picture: PAVFrame;
+                       var got_picture_ptr: cint;
+                       buf: {const} PByteArray; buf_size: cint): cint;
+  cdecl; external av__codec; {deprecated;}
+{$IFEND}
+
+{$IF LIBAVCODEC_VERSION >= 52025000} // 52.25.0
 (**
- * Decodes a video frame from \p buf into \p picture.
- * The avcodec_decode_video() function decodes a video frame from the input
- * buffer \p buf of size \p buf_size. To decode it, it makes use of the
- * video codec which was coupled with \p avctx using avcodec_open(). The
- * resulting decoded frame is stored in \p picture.
+ * Decodes the video frame of size avpkt->size from avpkt->data into picture.
+ * Some decoders may support multiple frames in a single AVPacket, such
+ * decoders would then just decode the first frame.
  *
- * @warning The input buffer must be \c FF_INPUT_BUFFER_PADDING_SIZE larger than
+ * @warning The input buffer must be FF_INPUT_BUFFER_PADDING_SIZE larger than
  * the actual read bytes because some optimized bitstream readers read 32 or 64
  * bits at once and could read over the end.
  *
- * @warning The end of the input buffer \p buf should be set to 0 to ensure that
+ * @warning The end of the input buffer buf should be set to 0 to ensure that
  * no overreading happens for damaged MPEG streams.
  *
- * @note You might have to align the input buffer \p buf and output buffer \p
- * samples. The alignment requirements depend on the CPU: on some CPUs it isn't
+ * @note You might have to align the input buffer avpkt->data.
+ * The alignment requirements depend on the CPU: on some CPUs it isn't
  * necessary at all, on others it won't work at all if not aligned and on others
- * it will work but it will have an impact on performance. In practice, the
- * bitstream should have 4 byte alignment at minimum and all sample data should
- * be 16 byte aligned unless the CPU doesn't need it (AltiVec and SSE do). If
- * the linesize is not a multiple of 16 then there's no sense in aligning the
- * start of the buffer to 16.
+ * it will work but it will have an impact on performance.
+ *
+ * In practice, avpkt->data should have 4 byte alignment at minimum.
  *
  * @param avctx the codec context
  * @param[out] picture The AVFrame in which the decoded video frame will be stored.
- * @param[in] buf the input buffer
- * @param[in] buf_size the size of the input buffer in bytes
+ * @param[in] avpkt The input AVpacket containing the input buffer.
+ *            You can create such packet with av_init_packet() and by then setting
+ *            data and size, some decoders might in addition need other fields like
+ *            flags&PKT_FLAG_KEY. All decoders are designed to use the least
+ *            fields possible.
  * @param[in,out] got_picture_ptr Zero if no frame could be decompressed, otherwise, it is nonzero.
  * @return On error a negative value is returned, otherwise the number of bytes
  * used or zero if no frame could be decompressed.
  *)
-function avcodec_decode_video(avctx: PAVCodecContext; picture: PAVFrame;
+function avcodec_decode_video2(avctx: PAVCodecContext; picture: PAVFrame;
                        var got_picture_ptr: cint;
-                       buf: {const} PChar; buf_size: cint): cint;
+                       avpkt: PAVPacket): cint;
   cdecl; external av__codec;
+{$IFEND}
 
+{$IF LIBAVCODEC_MAX_VERSION_MAJOR < 53}
 (* Decode a subtitle message. Return -1 if error, otherwise return the
  * number of bytes used. If no subtitle could be decompressed,
- * got_sub_ptr is zero. Otherwise, the subtitle is stored in *sub. *)
+ * got_sub_ptr is zero. Otherwise, the subtitle is stored in*sub.
+ *)
 function avcodec_decode_subtitle(avctx: PAVCodecContext; sub: PAVSubtitle;
                           var got_sub_ptr: cint;
-                          buf: {const} pchar; buf_size: cint): cint;
+                          buf: {const} PByteArray; buf_size: cint): cint;
+  cdecl; external av__codec;
+{$IFEND}
+  
+{$IF LIBAVCODEC_VERSION >= 52025000} // 52.25.0
+(* Decodes a subtitle message.
+ * Returns a negative value on error, otherwise returns the number of bytes used.
+ * If no subtitle could be decompressed, got_sub_ptr is zero.
+ * Otherwise, the subtitle is stored in sub.
+ *
+ * @param avctx the codec context
+ * @param[out] sub The AVSubtitle in which the decoded subtitle will be stored.
+ * @param[in,out] got_sub_ptr Zero if no subtitle could be decompressed, otherwise, it is nonzero.
+ * @param[in] avpkt The input AVPacket containing the input buffer.
+ *)
+function avcodec_decode_subtitle2(avctx: PAVCodecContext; sub: PAVSubtitle;
+                          var got_sub_ptr: cint;
+                          avpkt: PAVPacket): cint;
   cdecl; external av__codec;
+{$IFEND}
+  
 function avcodec_parse_frame(avctx: PAVCodecContext; pdata: PPointer;
                       data_size_ptr: PCint;
-                      buf: pchar; buf_size: cint): cint;
+                      buf: PByteArray; buf_size: cint): cint;
   cdecl; external av__codec;
 
 (**
- * Encodes an audio frame from \p samples into \p buf.
- * The avcodec_encode_audio() function encodes an audio frame from the input
- * buffer \p samples. To encode it, it makes use of the audio codec which was
- * coupled with \p avctx using avcodec_open(). The resulting encoded frame is
- * stored in output buffer \p buf.
+ * Encodes an audio frame from samples into buf.
  *
- * @note The output buffer should be at least \c FF_MIN_BUFFER_SIZE bytes large.
+ * @note The output buffer should be at least FF_MIN_BUFFER_SIZE bytes large.
+ * However, for PCM audio the user will know how much space is needed
+ * because it depends on the value passed in buf_size as described
+ * below. In that case a lower value can be used.
  *
  * @param avctx the codec context
  * @param[out] buf the output buffer
  * @param[in] buf_size the output buffer size
  * @param[in] samples the input buffer containing the samples
  * The number of samples read from this buffer is frame_size*channels,
- * both of which are defined in \p avctx.
- * For PCM audio the number of samples read from \p samples is equal to
- * \p buf_size * input_sample_size / output_sample_size.
+ * both of which are defined in avctx.
+ * For PCM audio the number of samples read from samples is equal to
+ * buf_size * input_sample_size / output_sample_size.
  * @return On error a negative value is returned, on success zero or the number
  * of bytes used to encode the data read from the input buffer.
  *)
@@ -3013,30 +3859,38 @@ function avcodec_encode_audio(avctx: PAVCodecContext; buf: PByte;
   cdecl; external av__codec;
 
 (**
- * Encodes a video frame from \p pict into \p buf.
- * The avcodec_encode_video() function encodes a video frame from the input
- * \p pict. To encode it, it makes use of the video codec which was coupled with
- * \p avctx using avcodec_open(). The resulting encoded bytes representing the
- * frame are stored in the output buffer \p buf. The input picture should be
- * stored using a specific format, namely \c avctx.pix_fmt.
+ * Encodes a video frame from pict into buf.
+ * The input picture should be
+ * stored using a specific format, namely avctx.pix_fmt.
  *
  * @param avctx the codec context
  * @param[out] buf the output buffer for the bitstream of encoded frame
  * @param[in] buf_size the size of the output buffer in bytes
  * @param[in] pict the input picture to encode
  * @return On error a negative value is returned, on success zero or the number
- * of bytes used from the input buffer.
+ * of bytes used from the output buffer.
  *)
 function avcodec_encode_video(avctx: PAVCodecContext; buf: PByte;
                       buf_size: cint; pict: PAVFrame): cint;
   cdecl; external av__codec;
-function avcodec_encode_subtitle(avctx: PAVCodecContext; buf: pchar;
+function avcodec_encode_subtitle(avctx: PAVCodecContext; buf: PByteArray;
                       buf_size: cint; sub: {const} PAVSubtitle): cint;
   cdecl; external av__codec;
 
 function avcodec_close(avctx: PAVCodecContext): cint;
   cdecl; external av__codec;
 
+(**
+ * Register all the codecs, parsers and bitstream filters which were enabled at
+ * configuration time. If you do not call this function you can select exactly
+ * which formats you want to support, by using the individual registration
+ * functions.
+ *
+ * @see register_avcodec
+ * @see avcodec_register
+ * @see av_register_codec_parser
+ * @see av_register_bitstream_filter
+ *)
 procedure avcodec_register_all();
   cdecl; external av__codec;
 
@@ -3052,12 +3906,12 @@ procedure avcodec_default_free_buffers(s: PAVCodecContext);
 (* misc useful functions *)
 
 (**
- * Returns a single letter to describe the given picture type \p pict_type.
+ * Returns a single letter to describe the given picture type pict_type.
  *
  * @param[in] pict_type the picture type
  * @return A single character representing the picture type.
  *)
-function av_get_pict_type_char(pict_type: cint): char;
+function av_get_pict_type_char(pict_type: cint): AnsiChar;
   cdecl; external av__codec;
 
 (**
@@ -3097,6 +3951,15 @@ type
     next_frame_offset: cint64; (* offset of the next frame *)
     (* video info *)
     pict_type: cint; (* XXX: put it back in AVCodecContext *)
+    (**
+     * This field is used for proper frame duration computation in lavf.
+     * It signals, how much longer the frame duration of the current frame
+     * is compared to normal frame duration.
+     *
+     * frame_duration = (1 + repeat_pict) * time_base
+     *
+     * It is used by codecs like H.264 to display telecined material.
+     *)
     repeat_pict: cint; (* XXX: put it back in AVCodecContext *)
     pts: cint64;     (* pts of the current frame *)
     dts: cint64;     (* dts of the current frame *)
@@ -3119,6 +3982,94 @@ type
     {$IF LIBAVCODEC_VERSION >= 51057001} // 51.57.1
     cur_frame_end: array [0..AV_PARSER_PTS_NB - 1] of cint64;
     {$IFEND}
+    {$IF LIBAVCODEC_VERSION >= 52016000} // 52.16.0
+    (*!
+     * Set by parser to 1 for key frames and 0 for non-key frames.
+     * It is initialized to -1, so if the parser doesn't set this flag,
+     * old-style fallback using FF_I_TYPE picture type as key frames
+     * will be used.
+     *)
+    key_frame: cint;
+    {$IFEND}
+    {$IF LIBAVCODEC_VERSION >= 52018000} // 52.18.0
+    (**
+     * Time difference in stream time base units from the pts of this
+     * packet to the point at which the output from the decoder has converged
+     * independent from the availability of previous frames. That is, the
+     * frames are virtually identical no matter if decoding started from
+     * the very first frame or from this keyframe.
+     * Is AV_NOPTS_VALUE if unknown.
+     * This field is not the display duration of the current frame.
+     *
+     * The purpose of this field is to allow seeking in streams that have no
+     * keyframes in the conventional sense. It corresponds to the
+     * recovery point SEI in H.264 and match_time_delta in NUT. It is also
+     * essential for some types of subtitle streams to ensure that all
+     * subtitles are correctly displayed after seeking.
+     *)
+    convergence_duration: cint64;
+    {$IFEND}
+    {$IF LIBAVCODEC_VERSION >= 52019000} // 52.19.0
+    // Timestamp generation support:
+    (**
+     * Synchronization point for start of timestamp generation.
+     *
+     * Set to >0 for sync point, 0 for no sync point and <0 for undefined
+     * (default).
+     *
+     * For example, this corresponds to presence of H.264 buffering period
+     * SEI message.
+     *)
+    dts_sync_point: cint;
+
+    (**
+     * Offset of the current timestamp against last timestamp sync point in
+     * units of AVCodecContext.time_base.
+     *
+     * Set to INT_MIN when dts_sync_point unused. Otherwise, it must
+     * contain a valid timestamp offset.
+     *
+     * Note that the timestamp of sync point has usually a nonzero
+     * dts_ref_dts_delta, which refers to the previous sync point. Offset of
+     * the next frame after timestamp sync point will be usually 1.
+     *
+     * For example, this corresponds to H.264 cpb_removal_delay.
+     *)
+    dts_ref_dts_delta: cint;
+
+    (**
+     * Presentation delay of current frame in units of AVCodecContext.time_base.
+     *
+     * Set to INT_MIN when dts_sync_point unused. Otherwise, it must
+     * contain valid non-negative timestamp delta (presentation time of a frame
+     * must not lie in the past).
+     *
+     * This delay represents the difference between decoding and presentation
+     * time of the frame.
+     *
+     * For example, this corresponds to H.264 dpb_output_delay.
+     *)
+    pts_dts_delta: cint;
+    {$IFEND}
+
+    {$IF LIBAVCODEC_VERSION >= 52021000} // 52.21.0
+    (**
+     * Position of the packet in file.
+     *
+     * Analogous to cur_frame_pts/dts
+     *)
+    cur_frame_pos: array [0..AV_PARSER_PTS_NB - 1] of cint64;
+
+    (**
+     * Byte position of currently parsed frame in stream.
+     *)
+    pos: cint64;
+
+    (**
+     * Previous frame byte position.
+     *)
+    last_pos: cint64;
+    {$IFEND}
   end;
 
   TAVCodecParser = record
@@ -3127,9 +4078,9 @@ type
     parser_init: function(s: PAVCodecParserContext): cint; cdecl;
     parser_parse: function(s: PAVCodecParserContext; avctx: PAVCodecContext;
                             poutbuf: {const} PPointer; poutbuf_size: PCint;
-                            buf: {const} pchar; buf_size: cint): cint; cdecl;
+                            buf: {const} PByteArray; buf_size: cint): cint; cdecl;
     parser_close: procedure(s: PAVCodecParserContext); cdecl;
-    split: function(avctx: PAVCodecContext; buf: {const} pchar;
+    split: function(avctx: PAVCodecContext; buf: {const} PByteArray;
                     buf_size: cint): cint; cdecl;
     next: PAVCodecParser;
   end;
@@ -3153,16 +4104,64 @@ procedure av_register_codec_parser(parser: PAVCodecParser);
 function av_parser_init(codec_id: cint): PAVCodecParserContext;
   cdecl; external av__codec;
 
+{$IF LIBAVCODEC_MAX_VERSION_MAJOR < 53}
 function av_parser_parse(s: PAVCodecParserContext;
                   avctx: PAVCodecContext;
-                  poutbuf: PPointer; poutbuf_size: PCint;
-                  buf: {const} pchar; buf_size: cint;
-                  pts: cint64; dts: cint64): cint;
-  cdecl; external av__codec;
+                  poutbuf: PPointer;
+                  poutbuf_size: PCint;
+                  buf: {const} PByteArray;
+                  buf_size: cint;
+                  pts: cint64;
+                  dts: cint64): cint;
+  cdecl; external av__codec; deprecated;
+{$IFEND}
+
+{$IF LIBAVCODEC_VERSION >= 52021000} // 52.21.0
+(**
+ * Parse a packet.
+ *
+ * @param s             parser context.
+ * @param avctx         codec context.
+ * @param poutbuf       set to pointer to parsed buffer or NULL if not yet finished.
+ * @param poutbuf_size  set to size of parsed buffer or zero if not yet finished.
+ * @param buf           input buffer.
+ * @param buf_size      input length, to signal EOF, this should be 0 (so that the last frame can be output).
+ * @param pts           input presentation timestamp.
+ * @param dts           input decoding timestamp.
+ * @param pos           input byte position in stream.
+ * @return the number of bytes of the input bitstream used.
+ *
+ * Example:
+ * @code
+ *   while (in_len) do
+ *   begin
+ *     len := av_parser_parse2(myparser, AVCodecContext, data, size,
+ *                                       in_data, in_len,
+ *                                       pts, dts, pos);
+ *      in_data := in_data + len;
+ *      in_len  := in_len  - len;
+ *
+ *      if (size) then
+ *        decode_frame(data, size);
+ *   end;
+ * @endcode
+ *)
+function av_parser_parse2(s:    PAVCodecParserContext;
+                  avctx:        PAVCodecContext;
+                  poutbuf:      PPointer;
+                  poutbuf_size: PCint;
+                  buf: {const}  PByteArray;
+                  buf_size:     cint;
+                  pts:          cint64;
+                  dts:          cint64;
+                  pos:          cint64): cint;
+   cdecl; external av__codec;
+{$IFEND}
+
 function av_parser_change(s: PAVCodecParserContext;
                    avctx: PAVCodecContext;
                    poutbuf: PPointer; poutbuf_size: PCint;
-                   buf: {const} pchar; buf_size: cint; keyframe: cint): cint;
+                   buf: {const} PByteArray; buf_size: cint; keyframe: cint): cint;
   cdecl; external av__codec;
 procedure av_parser_close(s: PAVCodecParserContext);
   cdecl; external av__codec;
@@ -3179,10 +4178,10 @@ type
   end;
 
   TAVBitStreamFilter = record
-    name: pchar;
+    name: PAnsiChar;
     priv_data_size: cint;
     filter: function(bsfc: PAVBitStreamFilterContext;
-                  avctx: PAVCodecContext; args: pchar;
+                  avctx: PAVCodecContext; args: PByteArray;
                   poutbuf: PPointer; poutbuf_size: PCint;
                   buf: PByte; buf_size: cint; keyframe: cint): cint; cdecl;
     {$IF LIBAVCODEC_VERSION >= 51043000} // 51.43.0
@@ -3194,11 +4193,11 @@ type
 procedure av_register_bitstream_filter(bsf: PAVBitStreamFilter);
   cdecl; external av__codec;
 
-function av_bitstream_filter_init(name: pchar): PAVBitStreamFilterContext;
+function av_bitstream_filter_init(name: PAnsiChar): PAVBitStreamFilterContext;
   cdecl; external av__codec;
 
 function av_bitstream_filter_filter(bsfc: PAVBitStreamFilterContext;
-                               avctx: PAVCodecContext; args: pchar;
+                               avctx: PAVCodecContext; args: PByteArray;
                                poutbuf: PPointer; poutbuf_size: PCint;
                                buf: PByte; buf_size: cint; keyframe: cint): cint;
   cdecl; external av__codec;
@@ -3221,6 +4220,22 @@ function av_bitstream_filter_next(f: PAVBitStreamFilter): PAVBitStreamFilter;
 procedure av_fast_realloc(ptr: pointer; size: PCuint; min_size: cuint);
   cdecl; external av__codec;
 
+{$IF LIBAVCODEC_VERSION >= 52025000} // >= 52.25.0
+(**
+ * Allocates a buffer, reusing the given one if large enough.
+ *
+ * Contrary to av_fast_realloc the current buffer contents might not be
+ * preserved and on error the old buffer is freed, thus no special
+ * handling to avoid memleaks is necessary.
+ *
+ * @param ptr pointer to pointer to already allocated buffer, overwritten with pointer to new buffer
+ * @param size size of the buffer *ptr points to
+ * @param min_size minimum size of *ptr buffer after returning, *ptr will be NULL and
+ *                 *size 0 if an error occurred.
+ *)
+procedure av_fast_malloc(ptr: pointer; size: PCuint; min_size: cuint);
+  cdecl; external av__codec;
+{$IFEND}
 
 {$IF LIBAVCODEC_VERSION < 51057000} // 51.57.0
 (* for static data only *)
@@ -3233,7 +4248,7 @@ procedure av_fast_realloc(ptr: pointer; size: PCuint; min_size: cuint);
  * and should correctly use static arrays
  *
  *)
-procedure  av_free_static();
+procedure av_free_static();
   cdecl; external av__codec; deprecated;
 
 (**
@@ -3259,22 +4274,49 @@ procedure av_realloc_static(ptr: pointer; size: cuint);
 (**
  * Copy image 'src' to 'dst'.
  *)
-procedure av_picture_copy(dst: PAVPicture; src: {const} PAVPicture;
-              pix_fmt: cint; width: cint; height: cint);
+procedure av_picture_copy(dst: PAVPicture; 
+              src: {const} PAVPicture;
+{$IF LIBAVCODEC_VERSION < 52022001} // 52.22.1
+              pix_fmt: cint;
+{$ELSE}
+              pix_fmt: TAVPixelFormat;
+{$IFEND}
+              width:  cint;
+              height: cint);
   cdecl; external av__codec;
 
 (**
  * Crop image top and left side.
  *)
-function av_picture_crop(dst: PAVPicture; src: {const} PAVPicture;
-             pix_fmt: cint; top_band: cint; left_band: cint): cint;
+function av_picture_crop(dst: PAVPicture;
+              src: {const} PAVPicture;
+{$IF LIBAVCODEC_VERSION < 52022001} // 52.22.1
+              pix_fmt: cint;
+{$ELSE}
+              pix_fmt: TAVPixelFormat;
+{$IFEND}
+              top_band:  cint;
+              left_band: cint): cint;
   cdecl; external av__codec;
 
 (**
  * Pad image.
  *)
-function av_picture_pad(dst: PAVPicture; src: {const} PAVPicture; height: cint; width: cint; pix_fmt: cint;
-            padtop: cint; padbottom: cint; padleft: cint; padright: cint; color: PCint): cint;
+function av_picture_pad(dst: PAVPicture;
+            src: {const} PAVPicture;
+            height: cint;
+            width: cint;
+{$IF LIBAVCODEC_VERSION < 52022001} // 52.22.1
+            pix_fmt: cint;
+{$ELSE}
+            pix_fmt: TAVPixelFormat;
+{$IFEND}
+            padtop: cint;
+            padbottom: cint;
+            padleft: cint;
+            padright:
+            cint;
+            color: PCint): cint;
   cdecl; external av__codec;
 {$IFEND}
 
@@ -3307,7 +4349,7 @@ function av_xiphlacing(s: PByte; v: cuint): cuint;
 
 {$IF LIBAVCODEC_VERSION >= 51041000} // 51.41.0
 (**
- * Parses \p str and put in \p width_ptr and \p height_ptr the detected values.
+ * Parses str and put in width_ptr and height_ptr the detected values.
  *
  * @return 0 in case of a successful parsing, a negative value otherwise
  * @param[in] str the string to parse: it has to be a string in the format
@@ -3317,34 +4359,19 @@ function av_xiphlacing(s: PByte; v: cuint): cuint;
  * @param[in,out] height_ptr pointer to the variable which will contain the detected
  * frame height value
  *)
-function av_parse_video_frame_size(width_ptr: PCint; height_ptr: PCint; str: {const} PChar): cint;
+function av_parse_video_frame_size(width_ptr: PCint; height_ptr: PCint; str: {const} PAnsiChar): cint;
   cdecl; external av__codec;
 
 (**
- * Parses \p str and put in \p frame_rate the detected values.
+ * Parses str and put in frame_rate the detected values.
  *
  * @return 0 in case of a successful parsing, a negative value otherwise
  * @param[in] str the string to parse: it has to be a string in the format
- * <frame_rate_nom>/<frame_rate_den>, a float number or a valid video rate abbreviation
+ * <frame_rate_num>/<frame_rate_den>, a float number or a valid video rate abbreviation
  * @param[in,out] frame_rate pointer to the AVRational which will contain the detected
  * frame rate
  *)
-function av_parse_video_frame_rate(frame_rate: PAVRational; str: {const} PChar): cint;
-  cdecl; external av__codec;
-{$IFEND}
-
-{$IF LIBAVCODEC_VERSION >= 51064000} // 51.64.0
-(**
- * Logs a generic warning message about a missing feature.
- * @param[in] avc a pointer to an arbitrary struct of which the first field is
- * a pointer to an AVClass struct
- * @param[in] feature string containing the name of the missing feature
- * @param[in] want_sample indicates if samples are wanted which exhibit this feature.
- * If \p want_sample is non-zero, additional verbage will be added to the log
- * message which tells the user how to report samples to the development
- * mailing list.
- *)
-procedure av_log_missing_feature(avc: Pointer; feature: {const} PChar; want_sample: cint);
+function av_parse_video_frame_rate(frame_rate: PAVRational; str: {const} PAnsiChar): cint;
   cdecl; external av__codec;
 {$IFEND}
 
@@ -3359,11 +4386,13 @@ const
   EDOM   = ESysEDOM;
   ENOSYS = ESysENOSYS;
   EILSEQ = ESysEILSEQ;
+  EPIPE  = ESysEPIPE;
 {$ELSE}
   ENOENT = 2;
   EIO    = 5;
   ENOMEM = 12;
   EINVAL = 22;
+  EPIPE  = 32;  // just an assumption. needs to be checked.
   EDOM   = 33;
   {$IFDEF MSWINDOWS}
   // Note: we assume that ffmpeg was compiled with MinGW.
@@ -3400,11 +4429,101 @@ const
   AVERROR_NOMEM       = AVERROR_SIGN * ENOMEM;  (**< not enough memory *)
   AVERROR_NOFMT       = AVERROR_SIGN * EILSEQ;  (**< unknown format *)
   AVERROR_NOTSUPP     = AVERROR_SIGN * ENOSYS;  (**< Operation not supported. *)
-  AVERROR_NOENT       = AVERROR_SIGN * ENOENT;  {**< No such file or directory. *}
+  AVERROR_NOENT       = AVERROR_SIGN * ENOENT;  (**< No such file or directory. *)
+{$IF LIBAVCODEC_VERSION >= 52017000} // 52.17.0
+  AVERROR_EOF         = AVERROR_SIGN * EPIPE;   (**< End of file. *)
+{$IFEND}
   // Note: function calls as constant-initializers are invalid
   //AVERROR_PATCHWELCOME = -MKTAG('P','A','W','E'); {**< Not yet implemented in FFmpeg. Patches welcome. *}
   AVERROR_PATCHWELCOME = -(ord('P') or (ord('A') shl 8) or (ord('W') shl 16) or (ord('E') shl 24));
 
+{$IF LIBAVCODEC_VERSION >= 52032000} // >= 52.32.0
+(**
+ * Logs a generic warning message about a missing feature. This function is
+ * intended to be used internally by FFmpeg (libavcodec, libavformat, etc.)
+ * only, and would normally not be used by applications.
+ * @param[in] avc a pointer to an arbitrary struct of which the first field is
+ * a pointer to an AVClass struct
+ * @param[in] feature string containing the name of the missing feature
+ * @param[in] want_sample indicates if samples are wanted which exhibit this feature.
+ * If want_sample is non-zero, additional verbage will be added to the log
+ * message which tells the user how to report samples to the development
+ * mailing list.
+ *)
+procedure av_log_missing_feature(avc: Pointer; feature: {const} Pchar; want_sample: cint);
+  cdecl; external av__codec;
+
+(**
+ * Logs a generic warning message asking for a sample. This function is
+ * intended to be used internally by FFmpeg (libavcodec, libavformat, etc.)
+ * only, and would normally not be used by applications.
+ * @param[in] avc a pointer to an arbitrary struct of which the first field is
+ * a pointer to an AVClass struct
+ * @param[in] msg string containing an optional message, or NULL if no message
+ *)
+procedure av_log_ask_for_sample(avc: Pointer; msg: {const} Pchar);
+  cdecl; external av__codec;
+{$IFEND}
+
+{$IF LIBAVCODEC_VERSION >= 52018000} // 52.18.0
+(**
+ * Registers the hardware accelerator hwaccel.
+ *)
+procedure av_register_hwaccel (hwaccel: PAVHWAccel)
+  cdecl; external av__codec;
+
+(**
+ * If hwaccel is NULL, returns the first registered hardware accelerator,
+ * if hwaccel is non-NULL, returns the next registered hardware accelerator
+ * after hwaccel, or NULL if hwaccel is the last one.
+ *)
+function av_hwaccel_next (hwaccel: PAVHWAccel): PAVHWAccel;
+  cdecl; external av__codec;
+{$IFEND}
+
+{$IF LIBAVCODEC_VERSION >= 52030000} // 52.30.0
+(**
+ * Lock operation used by lockmgr
+ *)
+type
+  TAVLockOp = (
+    AV_LOCK_CREATE,  ///< Create a mutex
+    AV_LOCK_OBTAIN,  ///< Lock the mutex
+    AV_LOCK_RELEASE, ///< Unlock the mutex
+    AV_LOCK_DESTROY  ///< Free mutex resources
+  );
+
+(**
+ * Register a user provided lock manager supporting the operations
+ * specified by AVLockOp. mutex points to a (void) where the
+ * lockmgr should store/get a pointer to a user allocated mutex. It's
+ * NULL upon AV_LOCK_CREATE and != NULL for all other ops.
+ *
+ * @param cb User defined callback. Note: FFmpeg may invoke calls to this
+ *           callback during the call to av_lockmgr_register().
+ *           Thus, the application must be prepared to handle that.
+ *           If cb is set to NULL the lockmgr will be unregistered.
+ *           Also note that during unregistration the previously registered
+ *           lockmgr callback may also be invoked.
+ *)
+// ToDo: Implement and test this
+//function av_lockmgr_register(cb: function (mutex: pointer; op: TAVLockOp)): cint;
+//  cdecl; external av__codec;
+{$IFEND}
+
 implementation
 
+{$IF (LIBAVCODEC_VERSION >= 52025000) and (LIBAVCODEC_VERSION <= 52027000)} // 52.25.0 - 52.27.0
+procedure av_free_packet(pkt: PAVPacket);{$IFDEF HASINLINE} inline; {$ENDIF} 
+begin
+  if assigned(pkt) then
+  begin
+    if assigned(pkt^.destruct) then
+      pkt^.destruct(pkt);
+    pkt^.data := NIL;
+    pkt^.size := 0;
+  end;
+end;
+{$IFEND}
+
 end.
diff --git a/Lua/src/lib/ffmpeg/avformat.pas b/Lua/src/lib/ffmpeg/avformat.pas
index c516aea0..2b8a5e4f 100644
--- a/Lua/src/lib/ffmpeg/avformat.pas
+++ b/Lua/src/lib/ffmpeg/avformat.pas
@@ -27,8 +27,13 @@
 (*
  * Conversion of libavformat/avformat.h
  * Min. version: 50.5.0 , revision 6577,  Sat Oct 7 15:30:46 2006 UTC
- * Max. version: 52.22.1, revision 15441, Sat Sep 27 20:05:12 2008 UTC 
+ * Max. version: 52.25.0, revision 16986, Wed Feb 4 05:56:39 2009 UTC 
  *)
+{
+ * update to
+ * Max. version: 52.41.0, Sun Dec 6 20:15:00 2009 CET 
+ * MiSchi
+}
 
 unit avformat;
 
@@ -54,13 +59,14 @@ uses
   avutil,
   avio,
   rational,
+  SysUtils,
   UConfig;
 
 const
   (* Max. supported version by this header *)
   LIBAVFORMAT_MAX_VERSION_MAJOR   = 52;
-  LIBAVFORMAT_MAX_VERSION_MINOR   = 22;
-  LIBAVFORMAT_MAX_VERSION_RELEASE = 1;
+  LIBAVFORMAT_MAX_VERSION_MINOR   = 41;
+  LIBAVFORMAT_MAX_VERSION_RELEASE = 0;
   LIBAVFORMAT_MAX_VERSION = (LIBAVFORMAT_MAX_VERSION_MAJOR * VERSION_MAJOR) +
                             (LIBAVFORMAT_MAX_VERSION_MINOR * VERSION_MINOR) +
                             (LIBAVFORMAT_MAX_VERSION_RELEASE * VERSION_RELEASE);
@@ -91,33 +97,105 @@ function avformat_version(): cuint;
   cdecl; external av__format;
 {$IFEND}
 
+{$IF LIBAVFORMAT_VERSION >= 52039002} // 52.39.2
+(**
+ * Returns the libavformat build-time configuration.
+ *)
+function avformat_configuration(): {const} PansiChar;
+  cdecl; external av__format;
+
+(**
+ * Returns the libavformat license.
+ *)
+function avformat_license(): {const} PansiChar;
+  cdecl; external av__format;
+{$IFEND}
 
 type
   PAVFile = Pointer;
 
+(*
+ * Public Metadata API.
+ * The metadata API allows libavformat to export metadata tags to a client
+ * application using a sequence of key/value pairs.
+ * Important concepts to keep in mind:
+ * 1. Keys are unique; there can never be 2 tags with the same key. This is
+ *    also meant semantically, i.e., a demuxer should not knowingly produce
+ *    several keys that are literally different but semantically identical.
+ *    E.g., key=Author5, key=Author6. In this example, all authors must be
+ *    placed in the same tag.
+ * 2. Metadata is flat, not hierarchical; there are no subtags. If you
+ *    want to store, e.g., the email address of the child of producer Alice
+ *    and actor Bob, that could have key=alice_and_bobs_childs_email_address.
+ * 3. A tag whose value is localized for a particular language is appended
+ *    with a dash character ('-') and the ISO 639-2/B 3-letter language code.
+ *    For example: Author-ger=Michael, Author-eng=Mike
+ *    The original/default language is in the unqualified "Author" tag.
+ *    A demuxer should set a default if it sets any translated tag.
+ *)
+const
+  AV_METADATA_MATCH_CASE    = 1;
+  AV_METADATA_IGNORE_SUFFIX = 2;
+
+type
+  PAVMetadataTag = ^TAVMetadataTag;
+  TAVMetadataTag = record
+    key:   PAnsiChar;
+    value: PAnsiChar;
+  end;
+
+  PAVMetadata = Pointer;
+
+{$IF LIBAVFORMAT_VERSION > 52024001} // > 52.24.1
+(**
+ * Gets a metadata element with matching key.
+ * @param prev Set to the previous matching element to find the next.
+ * @param flags Allows case as well as suffix-insensitive comparisons.
+ * @return Found tag or NULL, changing key or value leads to undefined behavior.
+ *)
+function av_metadata_get(m: PAVMetadata; key: {const} PAnsiChar;
+                         prev: {const} PAVMetadataTag ; flags: cint): PAVMetadataTag;
+  cdecl; external av__format;
+
+(**
+ * Sets the given tag in m, overwriting an existing tag.
+ * @param key tag key to add to m (will be av_strduped)
+ * @param value tag value to add to m (will be av_strduped)
+ * @return >= 0 on success otherwise an error code <0
+ *)
+function av_metadata_set(var pm: PAVMetadata; key: {const} PAnsiChar; value: {const} PAnsiChar): cint;
+  cdecl; external av__format;
+
+(**
+ * Frees all the memory allocated for an AVMetadata struct.
+ *)
+procedure av_metadata_free(var m: PAVMetadata);
+  cdecl; external av__format;
+{$IFEND}
+
 (* packet functions *)
 
+{$IF LIBAVCODEC_VERSION < 52032000} // < 52.32.0
 type
   PAVPacket = ^TAVPacket;
   TAVPacket = record
     (**
-     * Presentation time stamp in time_base units.
-     * This is the time at which the decompressed packet will be presented
-     * to the user.
+     * Presentation timestamp in time_base units; the time at which the
+     * decompressed packet will be presented to the user.
      * Can be AV_NOPTS_VALUE if it is not stored in the file.
      * pts MUST be larger or equal to dts as presentation can not happen before
      * decompression, unless one wants to view hex dumps. Some formats misuse
-     * the terms dts and pts/cts to mean something different, these timestamps
+     * the terms dts and pts/cts to mean something different. Such timestamps
      * must be converted to true pts/dts before they are stored in AVPacket.
      *)
     pts: cint64;
     (**
-     * Decompression time stamp in time_base units.
-     * This is the time at which the packet is decompressed.
+     * Decompression timestamp in time_base units; the time at which the
+     * packet is decompressed.
      * Can be AV_NOPTS_VALUE if it is not stored in the file.
      *)
     dts: cint64;
-    data: PChar;
+    data: PByteArray;
     size: cint;
     stream_index: cint;
     flags: cint;
@@ -126,7 +204,7 @@ type
      * Equals next_pts - this_pts in presentation order.
      *)
     duration: cint;
-    destruct: procedure (p: PAVPacket); cdecl; 
+    destruct: procedure (p: PAVPacket); cdecl;
     priv: pointer;
     pos: cint64;                            ///< byte position in stream, -1 if unknown
 
@@ -182,6 +260,7 @@ procedure av_init_packet(var pkt: TAVPacket);
  *)
 function av_new_packet(var pkt: TAVPacket; size: cint): cint;
   cdecl; external av__format;
+{$IFEND}
 
 (**
  * Allocate and read the payload of a packet and initialize its fields with
@@ -194,6 +273,7 @@ function av_new_packet(var pkt: TAVPacket; size: cint): cint;
 function av_get_packet(s: PByteIOContext; var pkt: TAVPacket; size: cint): cint;
   cdecl; external av__format;
 
+{$IF LIBAVCODEC_VERSION < 52032000} // < 52.32.0
 (**
  * @warning This is a hack - the packet memory allocation stuff is broken. The
  * packet is allocated if it was not really allocated.
@@ -207,6 +287,7 @@ function av_dup_packet(pkt: PAVPacket): cint;
  * @param pkt packet to free
  *)
 procedure av_free_packet(pkt: PAVPacket); {$IFDEF HasInline}inline;{$ENDIF}
+{$IFEND}
 
 (*************************************************)
 (* fractional numbers for exact pts handling *)
@@ -215,12 +296,11 @@ type
  (**
   * The exact value of the fractional number is: 'val + num / den'.
   * num is assumed to be 0 <= num < den.
-  * @deprecated Use AVRational instead.
   *)
   PAVFrac = ^TAVFrac;
   TAVFrac = record
     val, num, den: cint64;
-  end; {deprecated}
+  end;
 
 (*************************************************)
 (* input/output formats *)
@@ -228,13 +308,13 @@ type
 type
   (** This structure contains the data a format has to probe a file. *)
   TAVProbeData = record
-    filename: pchar;
-    buf: pchar;
-    buf_size: cint;
+    filename: PAnsiChar;
+    buf: PByteArray;  (**< Buffer must have AVPROBE_PADDING_SIZE of extra allocated bytes filled with zero. *)
+    buf_size: cint;   (**< Size of buf except extra allocated bytes *)
   end;
 
 const
-  AVPROBE_SCORE_MAX   = 100;   ///< Maximum score, half of that is used for file-extension-based detection.
+  AVPROBE_SCORE_MAX   = 100;   ///< Maximum score, half of that is used for file-extension-based detection
   AVPROBE_PADDING_SIZE = 32;   ///< extra allocated bytes at the end of the probe buffer
 
   //! Demuxer will use url_fopen, no opened file should be provided by the caller.
@@ -247,6 +327,9 @@ const
   AVFMT_NOTIMESTAMPS  = $0080; (**< Format does not need / have any timestamps. *)
   AVFMT_GENERIC_INDEX = $0100; (**< Use generic index building code. *)
   AVFMT_TS_DISCONT    = $0200; (**< Format allows timestamp discontinuities. *)
+  {$IF LIBAVFORMAT_VERSION >= 52029002} // 52.29.2
+  AVFMT_VARIABLE_FPS  = $0400; (**< Format allows variable fps. *)
+  {$IFEND}
 
   // used by AVIndexEntry
   AVINDEX_KEYFRAME = $0001;
@@ -257,7 +340,7 @@ const
 
   AVFMT_NOOUTPUTLOOP = -1;
   AVFMT_INFINITEOUTPUTLOOP = 0;
-  AVFMT_FLAG_GENPTS = $0001;   ///< Generate pts if missing even if it requires parsing future frames.
+  AVFMT_FLAG_GENPTS = $0001;   ///< Generate missing pts even if it requires parsing future frames.
   AVFMT_FLAG_IGNIDX = $0002;   ///< Ignore index.
   AVFMT_FLAG_NONBLOCK = $0004; ///< Do not block when reading packets from input.
 
@@ -276,7 +359,23 @@ const
   AV_DISPOSITION_KARAOKE   = $0020;
 
   // used by TAVFormatContext.debug
-  FF_FDEBUG_TS       = 0001;
+  FF_FDEBUG_TS = 0001;
+
+  {$IF LIBAVFORMAT_VERSION >= 52034000}  // >= 52.34.0
+    {$IF LIBAVFORMAT_VERSION < 52039000} // <  52.39.0
+  MAX_PROBE_PACKETS = 100;
+    {$ELSE}
+  MAX_PROBE_PACKETS = 2500;
+    {$IFEND}
+  {$IFEND}
+
+  {$IF LIBAVFORMAT_VERSION >= 52035000}  // >= 52.35.0
+    {$IF LIBAVFORMAT_VERSION < 52039000} // <  52.39.0
+  RAW_PACKET_BUFFER_SIZE 32000
+    {$ELSE}
+  RAW_PACKET_BUFFER_SIZE 2500000
+    {$IFEND}
+  {$IFEND}
 
 type
   PPAVCodecTag = ^PAVCodecTag;
@@ -304,12 +403,32 @@ type
   PAVImageInfo = ^TAVImageInfo;
   {$IFEND}
 
+{$IF LIBAVFORMAT_VERSION >= 52030001} // >= 52.30.1
+(**
+ * Convert all the metadata sets from ctx according to the source and
+ * destination conversion tables.
+ * @param d_conv destination tags format conversion table
+ * @param s_conv source tags format conversion table
+ *)
+  PAVMetadataConv = ^TAVMetadataConv;
+  TAVMetadataConv = record
+    ctx:            PAVFormatContext;
+    d_conv: {const} PAVMetadataConv;
+    s_conv: {const} PAVMetadataConv;
+  end;
+{$IFEND}
+
   PAVChapter = ^TAVChapter;
   TAVChapter = record
     id: cint;                 ///< unique ID to identify the chapter
     time_base: TAVRational;   ///< time base in which the start/end timestamps are specified
     start, end_: cint64;      ///< chapter start/end time in time_base units
-    title: PChar;             ///< chapter title
+    {$IF LIBAVFORMAT_VERSION < 53000000}  // 53.00.0
+    title: PAnsiChar;         ///< chapter title
+    {$IFEND}
+    {$IF LIBAVFORMAT_VERSION >= 52024001} // 52.24.1
+    metadata: PAVMetadata;
+    {$IFEND}
   end;
   TAVChapterArray = array[0..(MaxInt div SizeOf(TAVChapter))-1] of TAVChapter;
   PAVChapterArray = ^TAVChapterArray;
@@ -326,9 +445,9 @@ type
     {$IFEND}
     channel: cint; (**< Used to select DV channel. *)
     {$IF LIBAVFORMAT_VERSION_MAJOR < 52}
-    device: pchar; (* video, audio or DV device, if LIBAVFORMAT_VERSION_INT < (52<<16) *)
+    device: PAnsiChar; (* video, audio or DV device, if LIBAVFORMAT_VERSION_INT < (52<<16) *)
     {$IFEND}
-    standard: pchar; (**< TV standard, NTSC, PAL, SECAM *)
+    standard: PAnsiChar; (**< TV standard, NTSC, PAL, SECAM *)
     { Delphi does not support bit fields -> use bf_flags instead
     unsigned int mpeg2ts_raw:1;  (**< Force raw MPEG-2 transport stream output, if possible. *)
     unsigned int mpeg2ts_compute_pcr:1; (**< Compute exact PCR for each transport
@@ -346,16 +465,16 @@ type
   end;
 
   TAVOutputFormat = record
-    name: pchar;
+    name: PAnsiChar;
     (**
      * Descriptive name for the format, meant to be more human-readable
-     * than \p name. You \e should use the NULL_IF_CONFIG_SMALL() macro
+     * than name. You should use the NULL_IF_CONFIG_SMALL() macro
      * to define it.
      *)
-    long_name: pchar;
-    mime_type: pchar;
-    extensions: pchar; (**< comma-separated filename extensions *)
-    (** Size of private data so that it can be allocated in the wrapper. *)
+    long_name: PAnsiChar;
+    mime_type: PAnsiChar;
+    extensions: PAnsiChar; (**< comma-separated filename extensions *)
+    (** size of private data so that it can be allocated in the wrapper *)
     priv_data_size: cint;
     (* output support *)
     audio_codec: TCodecID; (**< default audio codec *)
@@ -373,7 +492,7 @@ type
     {$IF LIBAVFORMAT_VERSION >= 51008000} // 51.8.0
     (**
      * List of supported codec_id-codec_tag pairs, ordered by "better
-     * choice first". The arrays are all CODEC_ID_NONE terminated.
+     * choice first". The arrays are all terminated by CODEC_ID_NONE.
      *)
     codec_tag: {const} PPAVCodecTag;
     {$IFEND}
@@ -382,22 +501,26 @@ type
     subtitle_codec: TCodecID; (**< default subtitle codec *)
     {$IFEND}
 
+    {$IF LIBAVFORMAT_VERSION >= 52030001} // 52.30.1
+    {const} metadata_conv: PAVMetadataConv;
+    {$IFEND}
+
     (* private fields *)
     next: PAVOutputFormat;
   end;
 
   TAVInputFormat = record
-    name: pchar;
+    name: PAnsiChar;
     (**
      * Descriptive name for the format, meant to be more human-readable
-     * than \p name. You \e should use the NULL_IF_CONFIG_SMALL() macro
+     * than name. You should use the NULL_IF_CONFIG_SMALL() macro
      * to define it.
      *)
-    long_name: pchar;
+    long_name: PAnsiChar;
     (** Size of private data so that it can be allocated in the wrapper. *)
     priv_data_size: cint;
     (**
-     * Tell if a given file has a chance of being parsed by this format.
+     * Tell if a given file has a chance of being parsed as this format.
      * The buffer provided is guaranteed to be AVPROBE_PADDING_SIZE bytes
      * big so you do not have to check for that unless you need more.
      *)
@@ -409,21 +532,28 @@ type
     read_header: function (c: PAVFormatContext; ap: PAVFormatParameters): cint; cdecl;
     (** Read one packet and put it in 'pkt'. pts and flags are also
        set. 'av_new_stream' can be called only if the flag
-       AVFMTCTX_NOHEADER is used. *)
+       AVFMTCTX_NOHEADER is used.
+       @return 0 on success, < 0 on error.
+               When returning an error, pkt must not have been allocated
+               or must be freed before returning *)
     read_packet: function (c: PAVFormatContext; var pkt: TAVPacket): cint; cdecl;
     (** Close the stream. The AVFormatContext and AVStreams are not
        freed by this function *)
     read_close: function (c: PAVFormatContext): cint; cdecl;
+
+{$IF LIBAVFORMAT_VERSION_MAJOR < 53}
     (**
      * Seek to a given timestamp relative to the frames in
      * stream component stream_index.
-     * @param stream_index must not be -1
-     * @param flags selects which direction should be preferred if no exact
-     *              match is available
+     * @param stream_index Must not be -1.
+     * @param flags Selects which direction should be preferred if no exact
+     *              match is available.
      * @return >= 0 on success (but not necessarily the new offset)
      *)
     read_seek: function (c: PAVFormatContext; stream_index: cint;
                   timestamp: cint64; flags: cint): cint; cdecl;
+{$IFEND}
+
     (**
      * Gets the next timestamp in stream[stream_index].time_base units.
      * @return the timestamp or AV_NOPTS_VALUE if an error occurred
@@ -435,15 +565,15 @@ type
     (** If extensions are defined, then no probe is done. You should
        usually not use extension format guessing because it is not
        reliable enough *)
-    extensions: pchar;
+    extensions: PAnsiChar;
     (** General purpose read-only value that the format can use. *)
     value: cint;
 
-    (** Start/resume playing - only meaningful if using a network-based format
+    (** Starts/resumes playing - only meaningful if using a network-based format
        (RTSP). *)
     read_play: function (c: PAVFormatContext): cint; cdecl;
 
-    (** Pause playing - only meaningful if using a network-based format
+    (** Pauses playing - only meaningful if using a network-based format
       (RTSP). *)  
     read_pause: function (c: PAVFormatContext): cint; cdecl;
 
@@ -451,6 +581,25 @@ type
     codec_tag: {const} PPAVCodecTag;
     {$IFEND}
 
+    {$IF LIBAVFORMAT_VERSION >= 52030000} // 52.30.0
+    (**
+     * Seeks to timestamp ts.
+     * Seeking will be done so that the point from which all active streams
+     * can be presented successfully will be closest to ts and within min/max_ts.
+     * Active streams are all streams that have AVStream.discard < AVDISCARD_ALL.
+     *)
+    read_seek2: function (s:            PAVFormatContext;
+                          stream_index: cint;
+			  min_ts:       cint64;
+			  ts:           cint64; 
+			  max_ts:       cint64;
+			  flags:        cint): cint; cdecl;
+    {$IFEND}
+    
+    {$IF LIBAVFORMAT_VERSION >= 52030001} // 52.30.1
+    {const} metadata_conv: PAVMetadataConv;
+    {$IFEND}
+
     (* private fields *)
     next: PAVInputFormat;
   end;
@@ -485,11 +634,11 @@ type
     id: cint;       (**< format-specific stream ID *)
     codec: PAVCodecContext; (**< codec context *)
     (**
-     * Real base frame rate of the stream.
-     * This is the lowest frame rate with which all timestamps can be
+     * Real base framerate of the stream.
+     * This is the lowest framerate with which all timestamps can be
      * represented accurately (it is the least common multiple of all
-     * frame rates in the stream). Note, this value is just a guess!
-     * For example if the timebase is 1/90000 and all frames have either
+     * framerates in the stream). Note, this value is just a guess!
+     * For example, if the time base is 1/90000 and all frames have either
      * approximately 3600 or 1800 timer ticks, then r_frame_rate will be 50/1.
      *)
     r_frame_rate: TAVRational;
@@ -506,7 +655,7 @@ type
     (**
      * This is the fundamental unit of time (in seconds) in terms
      * of which frame timestamps are represented. For fixed-fps content,
-     * time base should be 1/frame rate and timestamp increments should be 1.
+     * time base should be 1/framerate and timestamp increments should be 1.
      *)
     time_base: TAVRational;
     pts_wrap_bits: cint; (* number of bits in pts (used for wrapping control) *)
@@ -533,7 +682,9 @@ type
      *)
     duration: cint64;
 
-    language: array [0..3] of char; (* ISO 639 3-letter language code (empty string if undefined) *)
+    {$IF LIBAVFORMAT_VERSION_MAJOR < 53}
+    language: array [0..3] of PAnsiChar; (* ISO 639-2/B 3-letter language code (empty string if undefined) *)
+    {$IFEND}
 
     (* av_read_frame() support *)
     need_parsing: TAVStreamParseType;
@@ -554,8 +705,8 @@ type
     unused: array [0..4] of cint64;
     {$IFEND}
 
-    {$IF LIBAVFORMAT_VERSION >= 52006000} // 52.6.0
-    filename: PChar; (**< source filename of the stream *)
+    {$IF (LIBAVFORMAT_VERSION >= 52006000) and (LIBAVFORMAT_VERSION_MAJOR < 53)} // 52.6.0 - 53.0.0
+    filename: PAnsiChar; (**< source filename of the stream *)
     {$IFEND}
 
     {$IF LIBAVFORMAT_VERSION >= 52008000} // 52.8.0
@@ -576,6 +727,43 @@ type
      *)
     sample_aspect_ratio: TAVRational;
     {$IFEND}
+
+    {$IF LIBAVFORMAT_VERSION >= 52024001} // 52.24.1
+    metadata: PAVMetadata;
+    {$IFEND}
+
+    {$IF LIBAVFORMAT_VERSION > 52024001} // > 52.24.1
+    {* av_read_frame() support *}
+    cur_ptr: {const} PCuint8;
+    cur_len: cint;
+    cur_pkt: TAVPacket;
+    {$IFEND}
+
+    {$IF LIBAVFORMAT_VERSION >= 52030000} // > 52.30.0
+    // Timestamp generation support:
+    (**
+     * Timestamp corresponding to the last dts sync point.
+     *
+     * Initialized when AVCodecParserContext.dts_sync_point >= 0 and
+     * a DTS is received from the underlying container. Otherwise set to
+     * AV_NOPTS_VALUE by default.
+     *)
+    reference_dts: cint64;
+    {$IFEND}
+    {$IF LIBAVFORMAT_VERSION >= 52034000} // >= 52.34.0
+    (**
+     * Number of packets to buffer for codec probing
+     * NOT PART OF PUBLIC API
+     *)
+    probe_packets: cint;
+    {$IFEND}
+    {$IF LIBAVFORMAT_VERSION >= 52038000} // >= 52.38.0
+    (**
+     * last packet in packet_buffer for this stream when muxing.
+     * used internally, NOT PART OF PUBLIC API, dont read or write from outside of libav*
+     *)
+    last_in_packet_buffer: PAVPacketList;
+    {$IFEND}
   end;
 
  (**
@@ -586,7 +774,7 @@ type
   * sizeof(AVFormatContext) must not be used outside libav*.
   *)
   TAVFormatContext = record
-    av_class: PAVClass; (**< Set by av_alloc_format_context. *)
+    av_class: PAVClass; (**< Set by avformat_alloc_context. *)
     (* Can only be iformat or oformat, not both at the same time. *)
     iformat: PAVInputFormat;
     oformat: PAVOutputFormat;
@@ -600,17 +788,19 @@ type
 
     nb_streams: cuint;
     streams: array [0..MAX_STREAMS - 1] of PAVStream;
-    filename: array [0..1023] of char; (* input or output filename *)
+    filename: array [0..1023] of AnsiChar; (* input or output filename *)
     (* stream info *)
     timestamp: cint64;
-    title: array [0..511] of char;
-    author: array [0..511] of char;
-    copyright: array [0..511] of char;
-    comment: array [0..511] of char;
-    album: array [0..511] of char;
+    {$IF LIBAVFORMAT_VERSION < 53000000} // 53.00.0
+    title: array [0..511] of AnsiChar;
+    author: array [0..511] of AnsiChar;
+    copyright: array [0..511] of AnsiChar;
+    comment: array [0..511] of AnsiChar;
+    album: array [0..511] of AnsiChar;
     year: cint;  (**< ID3 year, 0 if none *)
     track: cint; (**< track number, 0 if none *)
-    genre: array [0..31] of char; (**< ID3 genre *)
+    genre: array [0..31] of AnsiChar; (**< ID3 genre *)
+    {$IFEND}
 
     ctx_flags: cint; (**< Format-specific flags, see AVFMTCTX_xx *)
     (* private data for pts handling (do not modify directly). *)
@@ -636,16 +826,22 @@ type
 
     (* av_read_frame() support *)
     cur_st: PAVStream;
-    cur_ptr: pbyte;
-    cur_len: cint;
-    cur_pkt: TAVPacket;
+    {$IF LIBAVFORMAT_VERSION_MAJOR < 53}
+    cur_ptr_deprecated: pbyte;
+    cur_len_deprecated: cint;
+    cur_pkt_deprecated: TAVPacket;
+    {$IFEND}
 
     (* av_seek_frame() support *)
     data_offset: cint64; (* offset of the first packet *)
     index_built: cint;
 
     mux_rate: cint;
+    {$IF LIBAVFORMAT_VERSION < 52034001} // < 52.34.1
     packet_size: cint;
+    {$ELSE}
+    packet_size: cuint;
+    {$IFEND}
     preload: cint;
     max_delay: cint;
 
@@ -656,7 +852,7 @@ type
     loop_input: cint;
 
     {$IF LIBAVFORMAT_VERSION >= 50006000} // 50.6.0
-    (** Decoding: size of data to probe; encoding: unused. *)
+    (** decoding: size of data to probe; encoding: unused. *)
     probesize: cuint;
     {$IFEND}
 
@@ -696,8 +892,8 @@ type
 
     {$IF LIBAVFORMAT_VERSION >= 52004000} // 52.4.0
     (**
-     * Maximum amount of memory in bytes to use per stream for the index.
-     * If the needed index exceeds this size, entries will be discarded as
+     * Maximum amount of memory in bytes to use for the index of each stream.
+     * If the index exceeds this size, entries will be discarded as
      * needed to maintain a smaller size. This can lead to slower or less
      * accurate seeking (depends on demuxer).
      * Demuxers for which a full in-memory index is mandatory will ignore
@@ -740,6 +936,19 @@ type
 
     packet_buffer_end: PAVPacketList;
     {$IFEND}
+
+    {$IF LIBAVFORMAT_VERSION >= 52024001} // 52.24.1
+    metadata: PAVMetadata;
+    {$IFEND}
+    
+    {$IF LIBAVFORMAT_VERSION >= 52035000} // 52.35.0
+    (**
+     * Remaining size available for raw_packet_buffer, in bytes.
+     * NOT PART OF PUBLIC API
+     *)
+    raw_packet_buffer_remaining_size: cint;
+    {$IFEND}
+
   end;
 
   (**
@@ -750,14 +959,19 @@ type
    *)
   TAVProgram = record
       id                : cint;
-      provider_name     : PChar;      ///< network name for DVB streams
-      name              : PChar;      ///< service name for DVB streams
+      {$IF LIBAVFORMAT_VERSION < 53000000} // 53.00.0
+      provider_name     : PAnsiChar;  ///< network name for DVB streams
+      name              : PAnsiChar;  ///< service name for DVB streams
+      {$IFEND}
       flags             : cint;
       discard           : TAVDiscard; ///< selects which program to discard and which to feed to the caller
       {$IF LIBAVFORMAT_VERSION >= 51016000} // 51.16.0
       stream_index      : PCardinal;
       nb_stream_indexes : PCardinal;
       {$IFEND}
+      {$IF LIBAVFORMAT_VERSION >= 52024001} // 52.24.1
+      metadata: PAVMetadata;
+      {$IFEND}
   end;
 
   TAVPacketList = record
@@ -779,8 +993,8 @@ type
   end; {deprecated}
 
   TAVImageFormat = record
-    name: pchar;
-    extensions: pchar;
+    name: PAnsiChar;
+    extensions: PAnsiChar;
     (* tell if a given file has a chance of being parsing by this format *)
     img_probe: function (d: PAVProbeData): cint; cdecl;
     (* read a whole image. 'alloc_cb' is called when the image size is
@@ -801,10 +1015,10 @@ procedure av_register_image_format(img_fmt: PAVImageFormat);
 function av_probe_image_format(pd: PAVProbeData): PAVImageFormat;
     cdecl; external av__format; deprecated;
 
-function guess_image_format(filename: pchar): PAVImageFormat;
+function guess_image_format(filename: PAnsiChar): PAVImageFormat;
     cdecl; external av__format; deprecated;
 
-function av_read_image(pb: PByteIOContext; filename: pchar;
+function av_read_image(pb: PByteIOContext; filename: PAnsiChar;
                   fmt: PAVImageFormat;
                   alloc_cb: pointer; opaque: pointer): cint;
     cdecl; external av__format; deprecated;
@@ -822,17 +1036,27 @@ var
 {$IFEND}
 
 {$IF LIBAVFORMAT_VERSION >= 52003000} // 52.3.0
+(**
+ * If f is NULL, returns the first registered input format,
+ * if f is non-NULL, returns the next registered input format after f
+ * or NULL if f is the last one.
+ *)
 function av_iformat_next(f: PAVInputFormat): PAVInputFormat;
     cdecl; external av__format;
+(**
+ * If f is NULL, returns the first registered output format,
+ * if f is non-NULL, returns the next registered input format after f
+ * or NULL if f is the last one.
+ *)
 function av_oformat_next(f: PAVOutputFormat): PAVOutputFormat;
     cdecl; external av__format;
 {$IFEND}
 
-function av_guess_image2_codec(filename: {const} PChar): TCodecID;
+function av_guess_image2_codec(filename: {const} PAnsiChar): TCodecID;
     cdecl; external av__format;
 
-(* XXX: use automatic init with either ELF sections or C file parser *)
-(* modules *)
+(* XXX: Use automatic init with either ELF sections or C file parser *)
+(* modules. *)
 
 (* utils.c *)
 procedure av_register_input_format(format: PAVInputFormat);
@@ -841,26 +1065,26 @@ procedure av_register_input_format(format: PAVInputFormat);
 procedure av_register_output_format(format: PAVOutputFormat);
   cdecl; external av__format;
 
-function guess_stream_format(short_name: pchar;
-                             filename: pchar;
-                             mime_type: pchar): PAVOutputFormat;
+function guess_stream_format(short_name: PAnsiChar;
+                             filename: PAnsiChar;
+                             mime_type: PAnsiChar): PAVOutputFormat;
   cdecl; external av__format;
 
-function guess_format(short_name: pchar;
-                      filename: pchar;
-                      mime_type: pchar): PAVOutputFormat;
+function guess_format(short_name: PAnsiChar;
+                      filename: PAnsiChar;
+                      mime_type: PAnsiChar): PAVOutputFormat;
   cdecl; external av__format;
 
 (**
  * Guesses the codec ID based upon muxer and filename.
  *)
-function av_guess_codec(fmt: PAVOutputFormat; short_name: pchar;
-                        filename: pchar; mime_type: pchar;
+function av_guess_codec(fmt: PAVOutputFormat; short_name: PAnsiChar;
+                        filename: PAnsiChar; mime_type: PAnsiChar;
                         type_: TCodecType): TCodecID;
   cdecl; external av__format;
 
 (**
- * Send a nice hexadecimal dump of a buffer to the specified file stream.
+ * Sends a nice hexadecimal dump of a buffer to the specified file stream.
  *
  * @param f The file stream pointer where the dump should be sent to.
  * @param buf buffer
@@ -868,12 +1092,12 @@ function av_guess_codec(fmt: PAVOutputFormat; short_name: pchar;
  *
  * @see av_hex_dump_log, av_pkt_dump, av_pkt_dump_log
  *)
-procedure av_hex_dump(f: PAVFile; buf: pchar; size: cint);
+procedure av_hex_dump(f: PAVFile; buf: PByteArray; size: cint);
   cdecl; external av__format;
 
 {$IF LIBAVFORMAT_VERSION >= 51011000} // 51.11.0
 (**
- * Send a nice hexadecimal dump of a buffer to the log.
+ * Sends a nice hexadecimal dump of a buffer to the log.
  *
  * @param avcl A pointer to an arbitrary struct of which the first field is a
  * pointer to an AVClass struct.
@@ -884,12 +1108,12 @@ procedure av_hex_dump(f: PAVFile; buf: pchar; size: cint);
  *
  * @see av_hex_dump, av_pkt_dump, av_pkt_dump_log
  *)
-procedure av_hex_dump_log(avcl: Pointer; level: cint; buf: PChar; size: cint);
+procedure av_hex_dump_log(avcl: Pointer; level: cint; buf: PByteArray; size: cint);
   cdecl; external av__format;
 {$IFEND}
 
 (**
- * Send a nice dump of a packet to the specified file stream.
+ * Sends a nice dump of a packet to the specified file stream.
  *
  * @param f The file stream pointer where the dump should be sent to.
  * @param pkt packet to dump
@@ -900,7 +1124,7 @@ procedure av_pkt_dump(f: PAVFile; pkt: PAVPacket; dump_payload: cint);
 
 {$IF LIBAVFORMAT_VERSION >= 51011000} // 51.11.0
 (**
- * Send a nice dump of a packet to the log.
+ * Sends a nice dump of a packet to the log.
  *
  * @param avcl A pointer to an arbitrary struct of which the first field is a
  * pointer to an AVClass struct.
@@ -913,6 +1137,15 @@ procedure av_pkt_dump_log(avcl: Pointer; level: cint; pkt: PAVPacket; dump_paylo
   cdecl; external av__format;
 {$IFEND}
 
+(**
+ * Initializes libavformat and registers all the muxers, demuxers and
+ * protocols. If you do not call this function, then you can select
+ * exactly which formats you want to support.
+ *
+ * @see av_register_input_format()
+ * @see av_register_output_format()
+ * @see av_register_protocol()
+ *)
 procedure av_register_all();
   cdecl; external av__format;
 
@@ -929,11 +1162,11 @@ function av_codec_get_tag(var tags: PAVCodecTag; id: TCodecID): cuint;
 (**
  * Finds AVInputFormat based on the short name of the input format.
  *)
-function av_find_input_format(short_name: pchar): PAVInputFormat;
+function av_find_input_format(short_name: PAnsiChar): PAVInputFormat;
   cdecl; external av__format;
 
 (**
- * Guess file format.
+ * Guesses file format.
  *
  * @param is_opened Whether the file is already opened; determines whether
  *                  demuxers with or without AVFMT_NOFILE are probed.
@@ -945,13 +1178,13 @@ function av_probe_input_format(pd: PAVProbeData; is_opened: cint): PAVInputForma
  * Allocates all the structures needed to read an input stream.
  *        This does not open the needed codecs for decoding the stream[s].
  *)
-function av_open_input_stream(ic_ptr: PAVFormatContext;
-                       pb: PByteIOContext; filename: pchar;
+function av_open_input_stream(var ic_ptr: PAVFormatContext;
+                       pb: PByteIOContext; filename: PAnsiChar;
                        fmt: PAVInputFormat; ap: PAVFormatParameters): cint;
   cdecl; external av__format;
 
 (**
- * Open a media file as input. The codecs are not opened. Only the file
+ * Opens a media file as input. The codecs are not opened. Only the file
  * header (if present) is read.
  *
  * @param ic_ptr The opened media file handle is put here.
@@ -962,23 +1195,33 @@ function av_open_input_stream(ic_ptr: PAVFormatContext;
  *           (NULL if default).
  * @return 0 if OK, AVERROR_xxx otherwise
  *)
-function av_open_input_file(var ic_ptr: PAVFormatContext; filename: pchar;
+function av_open_input_file(var ic_ptr: PAVFormatContext; filename: PAnsiChar;
                      fmt: PAVInputFormat; buf_size: cint;
                      ap: PAVFormatParameters): cint;
   cdecl; external av__format;
 
+{$IF LIBAVFORMAT_VERSION >= 52026000} // 52.26.0
 (**
- * Allocate an AVFormatContext.
+ * Allocates an AVFormatContext.
  * Can be freed with av_free() but do not forget to free everything you
  * explicitly allocated as well!
  *)
+function avformat_alloc_context(): PAVFormatContext;
+  cdecl; external av__format;
+{$ELSE}
+  {$IF LIBAVFORMAT_VERSION_MAJOR < 53}
+(**
+ * @deprecated Use avformat_alloc_context() instead.
+ *)
 function av_alloc_format_context(): PAVFormatContext;
   cdecl; external av__format;
+  {$IFEND}
+{$IFEND}
 
 (**
- * Read packets of a media file to get stream information. This
+ * Reads packets of a media file to get stream information. This
  * is useful for file formats with no headers such as MPEG. This
- * function also computes the real frame rate in case of MPEG-2 repeat
+ * function also computes the real framerate in case of MPEG-2 repeat
  * frame mode.
  * The logical file position is not changed by this function;
  * examined packets may be buffered for later processing.
@@ -992,7 +1235,7 @@ function av_find_stream_info(ic: PAVFormatContext): cint;
   cdecl; external av__format;
 
 (**
- * Read a transport packet from a media file.
+ * Reads a transport packet from a media file.
  *
  * This function is obsolete and should never be used.
  * Use av_read_frame() instead.
@@ -1005,7 +1248,7 @@ function av_read_packet(s: PAVFormatContext; var pkt: TAVPacket): cint;
   cdecl; external av__format;
 
 (**
- * Return the next frame of a stream.
+ * Returns the next frame of a stream.
  *
  * The returned packet is valid
  * until the next av_read_frame() or until av_close_input_file() and
@@ -1016,7 +1259,7 @@ function av_read_packet(s: PAVFormatContext; var pkt: TAVPacket): cint;
  * then it contains one frame.
  *
  * pkt->pts, pkt->dts and pkt->duration are always set to correct
- * values in AVStream.timebase units (and guessed if the format cannot
+ * values in AVStream.time_base units (and guessed if the format cannot
  * provide them). pkt->pts can be AV_NOPTS_VALUE if the video format
  * has B-frames, so it is better to rely on pkt->dts if you do not
  * decompress the payload.
@@ -1027,7 +1270,7 @@ function av_read_frame(s: PAVFormatContext; var pkt: TAVPacket): cint;
   cdecl; external av__format;
 
 (**
- * Seek to the key frame at timestamp.
+ * Seeks to the keyframe at timestamp.
  * 'timestamp' in 'stream_index'.
  * @param stream_index If stream_index is (-1), a default
  * stream is selected, and timestamp is automatically converted
@@ -1041,15 +1284,51 @@ function av_seek_frame(s: PAVFormatContext; stream_index: cint; timestamp: cint6
                        flags: cint): cint;
   cdecl; external av__format;
 
+{$IF LIBAVFORMAT_VERSION >= 52026000} // 52.26.0
+(**
+ * Seeks to timestamp ts.
+ * Seeking will be done so that the point from which all active streams
+ * can be presented successfully will be closest to ts and within min/max_ts.
+ * Active streams are all streams that have AVStream.discard < AVDISCARD_ALL.
+ *
+ * If flags contain AVSEEK_FLAG_BYTE, then all timestamps are in byte and
+ * are the file position (this may not be supported by all demuxers).
+ * If flags contain AVSEEK_FLAG_FRAME then all timestamps are in frames
+ * in the stream with stream_index (this may not be supported by all demuxers).
+ * Otherwise all timestamps are in units of the stream selected by stream_index
+ * or if stream_index is -1, in AV_TIME_BASE units.
+ * If flags contain AVSEEK_FLAG_ANY, then non-keyframes are treated as
+ * keyframes (this may not be supported by all demuxers).
+ *
+ * @param stream_index index of the stream which is used as time base reference.
+ * @param min_ts smallest acceptable timestamp
+ * @param ts target timestamp
+ * @param max_ts largest acceptable timestamp
+ * @param flags flags
+ * @returns >=0 on success, error code otherwise
+ *
+ * @NOTE This is part of the new seek API which is still under construction.
+ *       Thus do not use this yet. It may change at any time, do not expect
+ *       ABI compatibility yet!
+ *)
+function avformat_seek_file(s:            PAVFormatContext;
+			    stream_index: cint;
+			    min_ts:       cint64;
+			    ts:           cint64;
+			    max_ts:       cint64;
+			    flags:        cint): cint;
+  cdecl; external av__format;
+{$IFEND}
+
 (**
- * Start playing a network based stream (e.g. RTSP stream) at the
+ * Starts playing a network-based stream (e.g. RTSP stream) at the
  * current position.
  *)
 function av_read_play(s: PAVFormatContext): cint;
   cdecl; external av__format;
 
 (**
- * Pause a network based stream (e.g. RTSP stream).
+ * Pauses a network-based stream (e.g. RTSP stream).
  *
  * Use av_read_play() to resume it.
  *)
@@ -1058,7 +1337,7 @@ function av_read_pause(s: PAVFormatContext): cint;
 
 {$IF LIBAVFORMAT_VERSION >= 52003000} // 52.3.0
 (**
- * Free a AVFormatContext allocated by av_open_input_stream.
+ * Frees a AVFormatContext allocated by av_open_input_stream.
  * @param s context to free
  *)
 procedure av_close_input_stream(s: PAVFormatContext);
@@ -1066,7 +1345,7 @@ procedure av_close_input_stream(s: PAVFormatContext);
 {$IFEND}
 
 (**
- * Close a media file (but not its codecs).
+ * Closes a media file (but not its codecs).
  *
  * @param s media file handle
  *)
@@ -1074,7 +1353,7 @@ procedure av_close_input_file(s: PAVFormatContext);
   cdecl; external av__format;
 
 (**
- * Add a new stream to a media file.
+ * Adds a new stream to a media file.
  *
  * Can only be called in the read_header() function. If the flag
  * AVFMTCTX_NOHEADER is in the format context, then new streams
@@ -1092,7 +1371,7 @@ function av_new_program(s: PAVFormatContext; id: cint): PAVProgram;
 
 {$IF LIBAVFORMAT_VERSION >= 52014000} // 52.14.0
 (**
- * Add a new chapter.
+ * Adds a new chapter.
  * This function is NOT part of the public API
  * and should ONLY be used by demuxers.
  *
@@ -1105,12 +1384,12 @@ function av_new_program(s: PAVFormatContext; id: cint): PAVProgram;
  * @return AVChapter or NULL on error
  *)
 function ff_new_chapter(s: PAVFormatContext; id: cint; time_base: TAVRational;
-                        start, end_: cint64; title: {const} Pchar): PAVChapter;
+                        start, end_: cint64; title: {const} PAnsiChar): PAVChapter;
   cdecl; external av__format;
 {$IFEND}
 
 (**
- * Set the pts for a given stream.
+ * Sets the pts for a given stream.
  *
  * @param s stream
  * @param pts_wrap_bits number of bits effectively used by the pts
@@ -1119,13 +1398,20 @@ function ff_new_chapter(s: PAVFormatContext; id: cint; time_base: TAVRational;
  * @param pts_den denominator to convert to seconds (MPEG: 90000)
  *)
 procedure av_set_pts_info(s: PAVStream; pts_wrap_bits: cint;
+{$IF LIBAVFORMAT_VERSION < 52036000} // < 52.36.0
                    pts_num: cint; pts_den: cint);
+{$ELSE}
+                   pts_num: cuint; pts_den: cuint);
+{$IFEND}
   cdecl; external av__format;
 
 const
   AVSEEK_FLAG_BACKWARD = 1; ///< seek backward
   AVSEEK_FLAG_BYTE     = 2; ///< seeking based on position in bytes
   AVSEEK_FLAG_ANY      = 4; ///< seek to any frame, even non-keyframes
+{$IF LIBAVFORMAT_VERSION >= 52037000} // >= 52.37.0
+  AVSEEK_FLAG_FRAME    = 8;
+{$IFEND}
 
 function av_find_default_stream_index(s: PAVFormatContext): cint;
   cdecl; external av__format;
@@ -1144,7 +1430,7 @@ function av_index_search_timestamp(st: PAVStream; timestamp: cint64; flags: cint
 {$IF LIBAVFORMAT_VERSION >= 52004000} // 52.4.0
 (**
  * Ensures the index uses less memory than the maximum specified in
- * AVFormatContext.max_index_size, by discarding entries if it grows
+ * AVFormatContext.max_index_size by discarding entries if it grows
  * too large.
  * This function is not part of the public API and should only be called
  * by demuxers.
@@ -1154,7 +1440,7 @@ procedure ff_reduce_index(s: PAVFormatContext; stream_index: cint);
 {$IFEND}
 
 (**
- * Add an index entry into a sorted list. Update the entry if the list
+ * Adds an index entry into a sorted list. Updates the entry if the list
  * already contains it.
  *
  * @param timestamp timestamp in the timebase of the given stream
@@ -1214,7 +1500,7 @@ function av_set_parameters(s: PAVFormatContext; ap: PAVFormatParameters): cint;
   cdecl; external av__format;
 
 (**
- * Allocate the stream private data and write the stream header to an
+ * Allocates the stream private data and writes the stream header to an
  * output media file.
  *
  * @param s media file handle
@@ -1224,7 +1510,7 @@ function av_write_header(s: PAVFormatContext): cint;
   cdecl; external av__format;
 
 (**
- * Write a packet to an output media file.
+ * Writes a packet to an output media file.
  *
  * The packet shall contain one audio or video frame.
  * The packet must be correctly interleaved according to the container
@@ -1242,7 +1528,7 @@ function av_write_frame(s: PAVFormatContext; var pkt: TAVPacket): cint;
  * Writes a packet to an output media file ensuring correct interleaving.
  *
  * The packet must contain one audio or video frame.
- * If the packets are already correctly interleaved the application should
+ * If the packets are already correctly interleaved, the application should
  * call av_write_frame() instead as it is slightly faster. It is also important
  * to keep in mind that completely non-interleaved input will need huge amounts
  * of memory to interleave with this, so it is preferable to interleave at the
@@ -1257,10 +1543,10 @@ function av_interleaved_write_frame(s: PAVFormatContext; var pkt: TAVPacket): ci
   cdecl; external av__format;
 
 (**
- * Interleave a packet per dts in an output media file.
+ * Interleaves a packet per dts in an output media file.
  *
  * Packets with pkt->destruct == av_destruct_packet will be freed inside this
- * function, so they cannot be used after it, note calling av_free_packet()
+ * function, so they cannot be used after it. Note that calling av_free_packet()
  * on them is still safe.
  *
  * @param s media file handle
@@ -1275,9 +1561,27 @@ function av_interleave_packet_per_dts(s: PAVFormatContext; _out: PAVPacket;
                                       pkt: PAVPacket; flush: cint): cint;
   cdecl; external av__format;
 
+{$IF LIBAVFORMAT_VERSION >= 52025000} // 52.25.0
 (**
- * @brief Write the stream trailer to an output media file and
- *        free the file private data.
+ * Add packet to AVFormatContext->packet_buffer list, determining its
+ * interleaved position using compare() function argument.
+ *
+ * This function is not part of the public API and should only be called
+ * by muxers using their own interleave function.
+ *)
+{
+procedure ff_interleave_add_packet(s:   PAVFormatContext;
+                                   pkt: PAVPacket;
+		   compare: function(para1: PAVFormatContext;
+				     para2: PAVPacket;
+				     para3: PAVPacket): cint);
+  cdecl; external av__format;
+}
+{$IFEND}
+
+(**
+ * Writes the stream trailer to an output media file and frees the
+ * file private data.
  *
  * May only be called after a successful call to av_write_header.
  *
@@ -1287,7 +1591,7 @@ function av_interleave_packet_per_dts(s: PAVFormatContext; _out: PAVPacket;
 function av_write_trailer(s: pAVFormatContext): cint;
   cdecl; external av__format;
 
-procedure dump_format(ic: PAVFormatContext; index: cint; url: pchar;
+procedure dump_format(ic: PAVFormatContext; index: cint; url: PAnsiChar;
                is_output: cint);
   cdecl; external av__format;
 
@@ -1296,19 +1600,21 @@ procedure dump_format(ic: PAVFormatContext; index: cint; url: pchar;
  * @deprecated Use av_parse_video_frame_size instead.
  *)
 function parse_image_size(width_ptr: PCint; height_ptr: PCint;
-                          str: pchar): cint;
+                          str: PAnsiChar): cint;
   cdecl; external av__format; deprecated;
 
+{$IF LIBAVFORMAT_VERSION_MAJOR < 53}
 (**
- * Converts frame rate from string to a fraction.
+ * Converts framerate from a string to a fraction.
  * @deprecated Use av_parse_video_frame_rate instead.
  *)
 function parse_frame_rate(frame_rate: PCint; frame_rate_base: PCint;
-                          arg: pchar): cint;
+                          arg: PByteArray): cint;
   cdecl; external av__format; deprecated;
+{$IFEND}
 
 (**
- * Parses \p datestr and returns a corresponding number of microseconds.
+ * Parses datestr and returns a corresponding number of microseconds.
  * @param datestr String representing a date or a duration.
  * - If a date the syntax is:
  * @code
@@ -1319,7 +1625,7 @@ function parse_frame_rate(frame_rate: PCint; frame_rate_base: PCint;
  * If the year-month-day part is not specified it takes the current
  * year-month-day.
  * Returns the number of microseconds since 1st of January, 1970 up to
- * the time of the parsed date or INT64_MIN if \p datestr cannot be
+ * the time of the parsed date or INT64_MIN if datestr cannot be
  * successfully parsed.
  * - If a duration the syntax is:
  * @code
@@ -1327,13 +1633,13 @@ function parse_frame_rate(frame_rate: PCint; frame_rate_base: PCint;
  *  [-]S+[.m...]
  * @endcode
  * Returns the number of microseconds contained in a time interval
- * with the specified duration or INT64_MIN if \p datestr cannot be
+ * with the specified duration or INT64_MIN if datestr cannot be
  * successfully parsed.
- * @param duration Flag which tells how to interpret \p datestr, if
- * not zero \p datestr is interpreted as a duration, otherwise as a
+ * @param duration Flag which tells how to interpret datestr, if
+ * not zero datestr is interpreted as a duration, otherwise as a
  * date.
  *)
-function parse_date(datestr: pchar; duration: cint): cint64;
+function parse_date(datestr: PAnsiChar; duration: cint): cint64;
   cdecl; external av__format;
 
 (** Gets the current time in microseconds. *)
@@ -1347,7 +1653,11 @@ const
 function ffm_read_write_index(fd: cint): cint64;
   cdecl; external av__format;
 
+{$IF LIBAVFORMAT_VERSION < 52027000} // 52.27.0
 procedure ffm_write_write_index(fd: cint; pos: cint64);
+{$ELSE}
+function ffm_write_write_index(fd: cint; pos: cint64): cint;
+{$IFEND}
   cdecl; external av__format;
 
 procedure ffm_set_write_index(s: PAVFormatContext; pos: cint64; file_size: cint64);
@@ -1359,11 +1669,11 @@ procedure ffm_set_write_index(s: PAVFormatContext; pos: cint64; file_size: cint6
  * syntax: '?tag1=val1&tag2=val2...'. Little URL decoding is done.
  * Return 1 if found.
  *)
-function find_info_tag(arg: pchar; arg_size: cint; tag1: pchar; info: pchar): cint;
+function find_info_tag(arg: PAnsiChar; arg_size: cint; tag1: PAnsiChar; info: PAnsiChar): cint;
   cdecl; external av__format;
 
 (**
- * Returns in 'buf' the path with '%d' replaced by number.
+ * Returns in 'buf' the path with '%d' replaced by a number.
  *
  * Also handles the '%0nd' format where 'n' is the total number
  * of digits and '%%'.
@@ -1374,20 +1684,20 @@ function find_info_tag(arg: pchar; arg_size: cint; tag1: pchar; info: pchar): ci
  * @param number frame number
  * @return 0 if OK, -1 on format error
  *)
-function av_get_frame_filename(buf: pchar; buf_size: cint;
-                               path: pchar; number: cint): cint;
+function av_get_frame_filename(buf: PAnsiChar; buf_size: cint;
+                               path: PAnsiChar; number: cint): cint;
   cdecl; external av__format
   {$IF LIBAVFORMAT_VERSION <= 50006000} // 50.6.0
   name 'get_frame_filename'
   {$IFEND};
 
 (**
- * Check whether filename actually is a numbered sequence generator.
+ * Checks whether filename actually is a numbered sequence generator.
  *
  * @param filename possible numbered sequence string
  * @return 1 if a valid numbered sequence string, 0 otherwise
  *)
-function av_filename_number_test(filename: pchar): cint;
+function av_filename_number_test(filename: PAnsiChar): cint;
   cdecl; external av__format
   {$IF LIBAVFORMAT_VERSION <= 50006000} // 50.6.0
   name 'filename_number_test'
@@ -1395,7 +1705,7 @@ function av_filename_number_test(filename: pchar): cint;
 
 {$IF LIBAVFORMAT_VERSION >= 51012002} // 51.12.2
 (**
- * Generate an SDP for an RTP session.
+ * Generates an SDP for an RTP session.
  *
  * @param ac array of AVFormatContexts describing the RTP streams. If the
  *           array is composed by only one context, such context can contain
@@ -1408,7 +1718,7 @@ function av_filename_number_test(filename: pchar): cint;
  * @param size the size of the buffer
  * @return 0 if OK, AVERROR_xxx on error
  *)
-function avf_sdp_create(ac: PPAVFormatContext; n_files: cint; buff: PChar; size: cint): cint;
+function avf_sdp_create(ac: PPAVFormatContext; n_files: cint; buff: PByteArray; size: cint): cint;
   cdecl; external av__format;
 {$IFEND}
 
@@ -1429,10 +1739,12 @@ begin
 end;
 {$IFEND}
 
+{$IF LIBAVCODEC_VERSION < 52032000} // < 52.32.0
 procedure av_free_packet(pkt: PAVPacket);
 begin
   if ((pkt <> nil) and (@pkt^.destruct <> nil)) then
     pkt^.destruct(pkt);
 end;
+{$IFEND}
 
 end.
diff --git a/Lua/src/lib/ffmpeg/avio.pas b/Lua/src/lib/ffmpeg/avio.pas
index 5107a9fb..73c90b69 100644
--- a/Lua/src/lib/ffmpeg/avio.pas
+++ b/Lua/src/lib/ffmpeg/avio.pas
@@ -27,9 +27,20 @@
 
 (*
  * Conversion of libavformat/avio.h
- * revision 15120, Sun Aug 31 07:39:47 2008 UTC 
+ * unbuffered I/O operations
+ * revision 16100, Sat Dec 13 13:39:13 2008 UTC
+ * update Tue, Jun 10 01:00:00 2009 UTC
+ *
+ * @warning This file has to be considered an internal but installed
+ * header, so it should not be directly included in your projects.
  *)
 
+{
+ * update to
+ * Max. avformat version: 52.41.0, Sun Dec 6 20:15:00 2009 CET 
+ * MiSchi
+}
+
 unit avio;
 
 {$IFDEF FPC}
@@ -48,13 +59,9 @@ uses
   ctypes,
   avutil,
   avcodec,
+  SysUtils,
   UConfig;
 
-(* output byte stream handling *)
-
-type
-  TOffset = cint64;
-
 (* unbuffered I/O *)
 
 const
@@ -92,7 +99,7 @@ type
     is_streamed: cint;  (**< true if streamed (no seek possible), default = false *)
     max_packet_size: cint;  (**< if non zero, the stream is packetized with this max packet size *)
     priv_data: pointer;
-    filename: PChar; (**< specified filename *)
+    filename: PAnsiChar; (**< specified filename *)
   end;
   PPURLContext = ^PURLContext;
 
@@ -104,23 +111,26 @@ type
   end;
 
   TURLProtocol = record
-    name: PChar;
-    url_open: function (h: PURLContext; filename: {const} PChar; flags: cint): cint; cdecl;
-    url_read: function (h: PURLContext; buf: PChar; size: cint): cint; cdecl;
-    url_write: function (h: PURLContext; buf: PChar; size: cint): cint; cdecl;
-    url_seek: function (h: PURLContext; pos: TOffset; whence: cint): TOffset; cdecl;
+    name: PAnsiChar;
+    url_open: function (h: PURLContext; filename: {const} PAnsiChar; flags: cint): cint; cdecl;
+    url_read: function (h: PURLContext; buf: PByteArray; size: cint): cint; cdecl;
+    {$IF LIBAVFORMAT_VERSION >= 52034001} // 52.34.1
+    url_read_complete: function (h: PURLContext; buf: PByteArray; size: cint): cint; cdecl;
+    {$IFEND}
+    url_write: function (h: PURLContext; buf: PByteArray; size: cint): cint; cdecl;
+    url_seek: function (h: PURLContext; pos: cint64; whence: cint): cint64; cdecl;
     url_close: function (h: PURLContext): cint; cdecl;
     next: PURLProtocol;
     {$IF (LIBAVFORMAT_VERSION >= 52001000) and (LIBAVFORMAT_VERSION < 52004000)} // 52.1.0 .. 52.4.0
-    url_read_play: function (h: PURLContext): cint;
-    url_read_pause: function (h: PURLContext): cint;
+    url_read_play: function (h: PURLContext): cint; cdecl;
+    url_read_pause: function (h: PURLContext): cint; cdecl;
     {$IFEND}
     {$IF LIBAVFORMAT_VERSION >= 52004000} // 52.4.0
     url_read_pause: function (h: PURLContext; pause: cint): cint; cdecl;
     {$IFEND}
     {$IF LIBAVFORMAT_VERSION >= 52001000} // 52.1.0
-    url_read_seek: function (h: PURLContext;
-                         stream_index: cint; timestamp: cint64; flags: cint): TOffset; cdecl;
+    url_read_seek: function (h: PURLContext; stream_index: cint;
+                             timestamp: cint64; flags: cint): cint64; cdecl;
     {$IFEND}
   end;
 
@@ -133,23 +143,23 @@ type
   *)
   PByteIOContext = ^TByteIOContext;
   TByteIOContext = record
-    buffer: PChar;
+    buffer: PByteArray;
     buffer_size: cint;
-    buf_ptr: PChar;
-    buf_end: PChar;
+    buf_ptr: PByteArray;
+    buf_end: PByteArray;
     opaque: pointer;
-    read_packet: function (opaque: pointer; buf: PChar; buf_size: cint): cint; cdecl;
-    write_packet: function (opaque: pointer; buf: PChar; buf_size: cint): cint; cdecl;
-    seek: function (opaque: pointer; offset: TOffset; whence: cint): TOffset; cdecl;
-    pos: TOffset; (* position in the file of the current buffer *)
+    read_packet: function (opaque: pointer; buf: PByteArray; buf_size: cint): cint; cdecl;
+    write_packet: function (opaque: pointer; buf: PByteArray; buf_size: cint): cint; cdecl;
+    seek: function (opaque: pointer; offset: cint64; whence: cint): cint64; cdecl;
+    pos: cint64; (* position in the file of the current buffer *)
     must_flush: cint; (* true if the next seek should flush *)
     eof_reached: cint; (* true if eof reached *)
     write_flag: cint;  (* true if open for writing *)
     is_streamed: cint;
     max_packet_size: cint;
     checksum: culong;
-    checksum_ptr: PCuchar;
-    update_checksum: function (checksum: culong; buf: {const} PChar; size: cuint): culong; cdecl;
+    checksum_ptr: PByteArray;
+    update_checksum: function (checksum: culong; buf: {const} PByteArray; size: cuint): culong; cdecl;
     error: cint;         ///< contains the error code or 0 if no error happened
     {$IF (LIBAVFORMAT_VERSION >= 52001000) and (LIBAVFORMAT_VERSION < 52004000)} // 52.1.0 .. 52.4.0
     read_play: function(opaque: Pointer): cint; cdecl;
@@ -159,30 +169,40 @@ type
     read_pause: function(opaque: Pointer; pause: cint): cint; cdecl;
     {$IFEND}
     {$IF LIBAVFORMAT_VERSION >= 52001000} // 52.1.0
-    read_seek: function(opaque: Pointer;
-                     stream_index: cint; timestamp: cint64; flags: cint): TOffset; cdecl;
+    read_seek: function(opaque: Pointer; stream_index: cint;
+                        timestamp: cint64; flags: cint): cint64; cdecl;
     {$IFEND}
   end;
 
 
 {$IF LIBAVFORMAT_VERSION >= 52021000} // 52.21.0
 function url_open_protocol(puc: PPURLContext; up: PURLProtocol;
-                           filename: {const} PChar; flags: cint): cint;
+                           filename: {const} PAnsiChar; flags: cint): cint;
   cdecl; external av__format;
 {$IFEND}
-function url_open(h: PPointer; filename: {const} PChar; flags: cint): cint;
+function url_open(h: PPointer; filename: {const} PAnsiChar; flags: cint): cint;
   cdecl; external av__format;
-function url_read (h: PURLContext; buf: PChar; size: cint): cint;
+function url_read (h: PURLContext; buf: PByteArray; size: cint): cint;
   cdecl; external av__format;
-function url_write (h: PURLContext; buf: PChar; size: cint): cint;
+function url_write (h: PURLContext; buf: PByteArray; size: cint): cint;
   cdecl; external av__format;
-function url_seek (h: PURLContext; pos: TOffset; whence: cint): TOffset;
+function url_seek (h: PURLContext; pos: cint64; whence: cint): cint64;
   cdecl; external av__format;
 function url_close (h: PURLContext): cint;
   cdecl; external av__format;
-function url_exist(filename: {const} PChar): cint;
+function url_exist(filename: {const} PAnsiChar): cint;
   cdecl; external av__format;
-function url_filesize (h: PURLContext): TOffset;
+function url_filesize (h: PURLContext): cint64;
+  cdecl; external av__format;
+{
+ * Return the file descriptor associated with this URL. For RTP, this
+ * will return only the RTP file descriptor, not the RTCP file descriptor.
+ * To get both, use rtp_get_file_handles().
+ *
+ * @return the file descriptor associated with this URL, or <0 on error.
+}
+(* not implemented *)
+function url_get_file_handle(h: PURLContext): cint;
   cdecl; external av__format;
 
 (**
@@ -195,7 +215,7 @@ function url_filesize (h: PURLContext): TOffset;
  *)
 function url_get_max_packet_size(h: PURLContext): cint;
   cdecl; external av__format;
-procedure url_get_filename(h: PURLContext; buf: PChar; buf_size: cint);
+procedure url_get_filename(h: PURLContext; buf: PAnsiChar; buf_size: cint);
   cdecl; external av__format;
 
 (**
@@ -239,31 +259,49 @@ function av_url_read_pause(h: PURLContext; pause: cint): cint;
  * @return >= 0 on success
  * @see AVInputFormat::read_seek
  *)
-function av_url_read_seek(h: PURLContext;
-                     stream_index: cint; timestamp: cint64; flags: cint): TOffset;
+function av_url_read_seek(h: PURLContext; stream_index: cint;
+                          timestamp: cint64; flags: cint): cint64;
   cdecl; external av__format;
 {$IFEND}
 
-{
+(**
 var
+{$IF LIBAVFORMAT_VERSION_MAJOR < 53}
   first_protocol: PURLProtocol; external av__format;
+{$IFEND}
   url_interrupt_cb: PURLInterruptCB; external av__format;
-}
+**)
 
+{
+* If protocol is NULL, returns the first registered protocol,
+* if protocol is non-NULL, returns the next registered protocol after protocol,
+* or NULL if protocol is the last one.
+}
 {$IF LIBAVFORMAT_VERSION >= 52002000} // 52.2.0
 function av_protocol_next(p: PURLProtocol): PURLProtocol;
   cdecl; external av__format;
 {$IFEND}
 
-function register_protocol (protocol: PURLProtocol): cint;
+{$IF LIBAVFORMAT_VERSION <= 52028000} // 52.28.0
+(**
+ * @deprecated Use av_register_protocol() instead.
+ *)
+function register_protocol(protocol: PURLProtocol): cint;
   cdecl; external av__format;
+(** Alias for register_protocol() *)
+function av_register_protocol(protocol: PURLProtocol): cint;
+  cdecl; external av__format name 'register_protocol';
+{$ELSE}
+function av_register_protocol(protocol: PURLProtocol): cint;
+  cdecl; external av__format;
+{$IFEND}
 
 type
-  TReadWriteFunc = function (opaque: Pointer; buf: PChar; buf_size: cint): cint; cdecl;
-  TSeekFunc = function (opaque: Pointer; offset: TOffset; whence: cint): TOffset; cdecl;
+  TReadWriteFunc = function(opaque: Pointer; buf: PByteArray; buf_size: cint): cint; cdecl;
+  TSeekFunc = function(opaque: Pointer; offset: cint64; whence: cint): cint64; cdecl;
 
 function init_put_byte(s: PByteIOContext;
-                buffer: PChar;
+                buffer: PByteArray;
                 buffer_size: cint; write_flag: cint;
                 opaque: pointer;
                 read_packet: TReadWriteFunc;
@@ -272,7 +310,7 @@ function init_put_byte(s: PByteIOContext;
   cdecl; external av__format;
 {$IF LIBAVFORMAT_VERSION >= 52004000} // 52.4.0
 function av_alloc_put_byte(
-                  buffer: PChar;
+                  buffer: PByteArray;
                   buffer_size: cint;
                   write_flag: cint;
                   opaque: Pointer;
@@ -284,7 +322,7 @@ function av_alloc_put_byte(
 
 procedure put_byte(s: PByteIOContext; b: cint);
   cdecl; external av__format;
-procedure put_buffer (s: PByteIOContext; buf: {const} PChar; size: cint);
+procedure put_buffer (s: PByteIOContext; buf: {const} PByteArray; size: cint);
   cdecl; external av__format;
 procedure put_le64(s: PByteIOContext; val: cuint64);
   cdecl; external av__format;
@@ -302,38 +340,38 @@ procedure put_le16(s: PByteIOContext; val: cuint);
   cdecl; external av__format;
 procedure put_be16(s: PByteIOContext; val: cuint);
   cdecl; external av__format;
-procedure put_tag(s: PByteIOContext; tag: {const} PChar);
+procedure put_tag(s: PByteIOContext; tag: {const} PAnsiChar);
   cdecl; external av__format;
 
-procedure put_strz(s: PByteIOContext; buf: {const} PChar);
+procedure put_strz(s: PByteIOContext; buf: {const} PAnsiChar);
   cdecl; external av__format;
 
 (**
  * fseek() equivalent for ByteIOContext.
  * @return new position or AVERROR.
  *)
-function url_fseek(s: PByteIOContext; offset: TOffset; whence: cint): TOffset;
+function url_fseek(s: PByteIOContext; offset: cint64; whence: cint): cint64;
   cdecl; external av__format;
 
 (**
  * Skip given number of bytes forward.
  * @param offset number of bytes
  *)
-procedure url_fskip(s: PByteIOContext; offset: TOffset);
+procedure url_fskip(s: PByteIOContext; offset: cint64);
   cdecl; external av__format;
 
 (**
  * ftell() equivalent for ByteIOContext.
  * @return position or AVERROR.
  *)
-function url_ftell(s: PByteIOContext): TOffset;
+function url_ftell(s: PByteIOContext): cint64;
   cdecl; external av__format;
 
 (**
  * Gets the filesize.
  * @return filesize or AVERROR
  *)
-function url_fsize(s: PByteIOContext): TOffset;
+function url_fsize(s: PByteIOContext): cint64;
   cdecl; external av__format;
 
 (**
@@ -351,8 +389,8 @@ function av_url_read_fpause(h: PByteIOContext; pause: cint): cint;
   cdecl; external av__format;
 {$IFEND}
 {$IF LIBAVFORMAT_VERSION >= 52001000} // 52.1.0
-function av_url_read_fseek(h: PByteIOContext;
-                      stream_index: cint; timestamp: cint64; flags: cint): TOffset;
+function av_url_read_fseek(h: PByteIOContext; stream_index: cint;
+                           timestamp: cint64; flags: cint): cint64;
   cdecl; external av__format;
 {$IFEND}
 
@@ -363,12 +401,12 @@ function url_fgetc(s: PByteIOContext): cint;
   cdecl; external av__format;
 
 (** @warning currently size is limited *)
-function url_fprintf(s: PByteIOContext; fmt: {const} PChar; args: array of const): cint;
+function url_fprintf(s: PByteIOContext; fmt: {const} PAnsiChar; args: array of const): cint;
   cdecl; external av__format;
 
 (** @note unlike fgets, the EOL character is not returned and a whole
    line is parsed. return NULL if first char read was EOF *)
-function url_fgets(s: PByteIOContext; buf: PChar; buf_size: cint): PChar;
+function url_fgets(s: PByteIOContext; buf: PAnsiChar; buf_size: cint): PAnsiChar;
   cdecl; external av__format;
 
 procedure put_flush_packet (s: PByteIOContext);
@@ -379,7 +417,7 @@ procedure put_flush_packet (s: PByteIOContext);
  * Reads size bytes from ByteIOContext into buf.
  * @returns number of bytes read or AVERROR
  *)
-function get_buffer(s: PByteIOContext; buf: PChar; size: cint): cint;
+function get_buffer(s: PByteIOContext; buf: PByteArray; size: cint): cint;
   cdecl; external av__format;
 
 (**
@@ -388,7 +426,7 @@ function get_buffer(s: PByteIOContext; buf: PChar; size: cint): cint;
  * returned.
  * @returns number of bytes read or AVERROR
  *)
-function get_partial_buffer(s: PByteIOContext; buf: PChar; size: cint): cint;
+function get_partial_buffer(s: PByteIOContext; buf: PByteArray; size: cint): cint;
   cdecl; external av__format;
 
 (** @note return 0 if EOF, so you cannot use it if EOF handling is
@@ -404,7 +442,7 @@ function get_le64(s: PByteIOContext): cuint64;
 function get_le16(s: PByteIOContext): cuint;
   cdecl; external av__format;
 
-function get_strz(s: PByteIOContext; buf: PChar; maxlen: cint): PChar;
+function get_strz(s: PByteIOContext; buf: PAnsiChar; maxlen: cint): PAnsiChar;
   cdecl; external av__format;
 function get_be16(s: PByteIOContext): cuint;
   cdecl; external av__format;
@@ -435,6 +473,7 @@ function url_fdopen (s: PByteIOContext; h: PURLContext): cint;
 function url_setbufsize (s: PByteIOContext; buf_size: cint): cint;
   cdecl; external av__format;
 
+{$IF LIBAVFORMAT_VERSION_MAJOR < 53}
 {$IF LIBAVFORMAT_VERSION >= 51015000} // 51.15.0
 (** Reset the buffer for reading or writing.
  * @note Will drop any data currently in the buffer without transmitting it.
@@ -443,13 +482,14 @@ function url_setbufsize (s: PByteIOContext; buf_size: cint): cint;
 function url_resetbuf(s: PByteIOContext; flags: cint): cint;
   cdecl; external av__format;
 {$IFEND}
+{$IFEND}
 
 (** @note when opened as read/write, the buffers are only used for
    writing *)
 {$IF LIBAVFORMAT_VERSION >= 52000000} // 52.0.0
-function url_fopen(var s: PByteIOContext; filename: {const} PChar; flags: cint): cint;
+function url_fopen(var s: PByteIOContext; filename: {const} PAnsiChar; flags: cint): cint;
 {$ELSE}
-function url_fopen(s: PByteIOContext; filename: {const} PChar; flags: cint): cint;
+function url_fopen(s: PByteIOContext; filename: {const} PAnsiChar; flags: cint): cint;
 {$IFEND}
   cdecl; external av__format;
 function url_fclose(s: PByteIOContext): cint;
@@ -469,9 +509,9 @@ function url_fget_max_packet_size (s: PByteIOContext): cint;
   cdecl; external av__format;
 
 {$IF LIBAVFORMAT_VERSION >= 52000000} // 52.0.0
-function url_open_buf(var s: PByteIOContext; buf: PChar; buf_size: cint; flags: cint): cint;
+function url_open_buf(var s: PByteIOContext; buf: PAnsiChar; buf_size: cint; flags: cint): cint;
 {$ELSE}
-function url_open_buf(s: PByteIOContext; buf: PChar; buf_size: cint; flags: cint): cint;
+function url_open_buf(s: PByteIOContext; buf: PAnsiChar; buf_size: cint; flags: cint): cint;
 {$IFEND}
   cdecl; external av__format;
 
@@ -519,22 +559,27 @@ function url_close_dyn_buf(s: PByteIOContext; pbuffer:PPointer): cint;
   cdecl; external av__format;
 
 {$IF LIBAVFORMAT_VERSION >= 51017001} // 51.17.1
-function ff_crc04C11DB7_update(checksum: culong; buf: {const} PChar; len: cuint): culong;
+function ff_crc04C11DB7_update(checksum: culong; buf: {const} PByteArray;
+                               len: cuint): culong;
   cdecl; external av__format;
 {$IFEND}
 function get_checksum(s: PByteIOContext): culong;
   cdecl; external av__format;
-procedure init_checksum (s: PByteIOContext; update_checksum: pointer; checksum: culong);
+procedure init_gsum(s: PByteIOContext;
+                        update_checksum: pointer;
+                        checksum: culong);
   cdecl; external av__format;
 
 (* udp.c *)
-function udp_set_remote_url(h: PURLContext; uri: {const} PChar): cint;
+function udp_set_remote_url(h: PURLContext; uri: {const} PAnsiChar): cint;
   cdecl; external av__format;
 function udp_get_local_port(h: PURLContext): cint;
   cdecl; external av__format;
+{$IF LIBAVFORMAT_VERSION_MAJOR <= 52}
 function udp_get_file_handle(h: PURLContext): cint;
   cdecl; external av__format;
-
+{$IFEND}
+  
 implementation
 
 function url_is_streamed(s: PByteIOContext): cint;
diff --git a/Lua/src/lib/ffmpeg/avutil.pas b/Lua/src/lib/ffmpeg/avutil.pas
index b4fae422..55bab601 100644
--- a/Lua/src/lib/ffmpeg/avutil.pas
+++ b/Lua/src/lib/ffmpeg/avutil.pas
@@ -29,14 +29,21 @@
  *
  * libavutil/avutil.h:
  *  Min. version: 49.0.1, revision 6577,  Sat Oct 7 15:30:46 2006 UTC
- *  Max. version: 49.11.0, revision 15415, Thu Sep 25 19:23:13 2008 UTC 
+ *  Max. version: 49.14.0, revision 16912, Sun Feb 1 02:00:19 2009 UTC
  *
  * libavutil/mem.h:
- *  revision 15120, Sun Aug 31 07:39:47 2008 UTC 
+ *  revision 16590, Tue Jan 13 23:44:16 2009 UTC
  *
  * libavutil/log.h:
- *  revision 15120, Sun Aug 31 07:39:47 2008 UTC 
+ *  revision 16571, Tue Jan 13 00:14:43 2009 UTC
  *)
+{
+ Update changes auf avutil.h, mem.h and log.h
+ Max. version 50.05.1, Sun, Dec 6 24:00:00 2009 UTC 
+ include/keep pixfmt.h (change in revision 50.01.0)
+ Maybe, the pixelformats are not needed, but it has not been checked.
+ log.h is only partial.
+}
 
 unit avutil;
 
@@ -62,9 +69,9 @@ uses
 
 const
   (* Max. supported version by this header *)
-  LIBAVUTIL_MAX_VERSION_MAJOR   = 49;
-  LIBAVUTIL_MAX_VERSION_MINOR   = 11;
-  LIBAVUTIL_MAX_VERSION_RELEASE = 0;
+  LIBAVUTIL_MAX_VERSION_MAJOR   = 50;
+  LIBAVUTIL_MAX_VERSION_MINOR   = 5;
+  LIBAVUTIL_MAX_VERSION_RELEASE = 1;
   LIBAVUTIL_MAX_VERSION = (LIBAVUTIL_MAX_VERSION_MAJOR * VERSION_MAJOR) +
                           (LIBAVUTIL_MAX_VERSION_MINOR * VERSION_MINOR) +
                           (LIBAVUTIL_MAX_VERSION_RELEASE * VERSION_RELEASE);
@@ -94,88 +101,179 @@ function avutil_version(): cuint;
   cdecl; external av__format;
 {$IFEND}
 
+{$IF LIBAVUTIL_VERSION >= 50004000} // >= 50.4.0
+(**
+ * Returns the libavutil build-time configuration.
+ *)
+function avutil_configuration(): PAnsiChar;
+  cdecl; external av__format;
+
+(**
+ * Returns the libavutil license.
+ *)
+function avutil_license(): PAnsiChar;
+  cdecl; external av__format;
+{$IFEND}
+
 type
 (**
  * Pixel format. Notes:
  *
- * PIX_FMT_RGB32 is handled in an endian-specific manner. A RGBA
+ * PIX_FMT_RGB32 is handled in an endian-specific manner. An RGBA
  * color is put together as:
  *  (A << 24) | (R << 16) | (G << 8) | B
- * This is stored as BGRA on little endian CPU architectures and ARGB on
- * big endian CPUs.
+ * This is stored as BGRA on little-endian CPU architectures and ARGB on
+ * big-endian CPUs.
  *
  * When the pixel format is palettized RGB (PIX_FMT_PAL8), the palettized
  * image data is stored in AVFrame.data[0]. The palette is transported in
- * AVFrame.data[1] and, is 1024 bytes long (256 4-byte entries) and is
+ * AVFrame.data[1], is 1024 bytes long (256 4-byte entries) and is
  * formatted the same as in PIX_FMT_RGB32 described above (i.e., it is
  * also endian-specific). Note also that the individual RGB palette
  * components stored in AVFrame.data[1] should be in the range 0..255.
  * This is important as many custom PAL8 video codecs that were designed
  * to run on the IBM VGA graphics adapter use 6-bit palette components.
+ *
+ * For all the 8bit per pixel formats, an RGB32 palette is in data[1] like
+ * for pal8. This palette is filled in automatically by the function
+ * allocating the picture.
+ *
+ * Note, make sure that all newly added big endian formats have pix_fmt&1==1
+ * and that all newly added little endian formats have pix_fmt&1==0
+ * this allows simpler detection of big vs little endian.
  *)
 
   PAVPixelFormat = ^TAVPixelFormat;
   TAVPixelFormat = (
     PIX_FMT_NONE= -1,
-    PIX_FMT_YUV420P,   ///< Planar YUV 4:2:0, 12bpp, (1 Cr & Cb sample per 2x2 Y samples)
-    PIX_FMT_YUYV422,   ///< Packed YUV 4:2:2, 16bpp, Y0 Cb Y1 Cr
-    PIX_FMT_RGB24,     ///< Packed RGB 8:8:8, 24bpp, RGBRGB...
-    PIX_FMT_BGR24,     ///< Packed RGB 8:8:8, 24bpp, BGRBGR...
-    PIX_FMT_YUV422P,   ///< Planar YUV 4:2:2, 16bpp, (1 Cr & Cb sample per 2x1 Y samples)
-    PIX_FMT_YUV444P,   ///< Planar YUV 4:4:4, 24bpp, (1 Cr & Cb sample per 1x1 Y samples)
-    PIX_FMT_RGB32,     ///< Packed RGB 8:8:8, 32bpp, (msb)8A 8R 8G 8B(lsb), in cpu endianness
-    PIX_FMT_YUV410P,   ///< Planar YUV 4:1:0,  9bpp, (1 Cr & Cb sample per 4x4 Y samples)
-    PIX_FMT_YUV411P,   ///< Planar YUV 4:1:1, 12bpp, (1 Cr & Cb sample per 4x1 Y samples)
-    PIX_FMT_RGB565,    ///< Packed RGB 5:6:5, 16bpp, (msb)   5R 6G 5B(lsb), in cpu endianness
-    PIX_FMT_RGB555,    ///< Packed RGB 5:5:5, 16bpp, (msb)1A 5R 5G 5B(lsb), in cpu endianness most significant bit to 1
+    PIX_FMT_YUV420P,   ///< planar YUV 4:2:0, 12bpp, (1 Cr & Cb sample per 2x2 Y samples)
+    PIX_FMT_YUYV422,   ///< packed YUV 4:2:2, 16bpp, Y0 Cb Y1 Cr
+    PIX_FMT_RGB24,     ///< packed RGB 8:8:8, 24bpp, RGBRGB...
+    PIX_FMT_BGR24,     ///< packed RGB 8:8:8, 24bpp, BGRBGR...
+    PIX_FMT_YUV422P,   ///< planar YUV 4:2:2, 16bpp, (1 Cr & Cb sample per 2x1 Y samples)
+    PIX_FMT_YUV444P,   ///< planar YUV 4:4:4, 24bpp, (1 Cr & Cb sample per 1x1 Y samples)
+{$IF LIBAVUTIL_VERSION <= 50001000} // 50.01.0
+    PIX_FMT_RGB32,     ///< packed RGB 8:8:8, 32bpp, (msb)8A 8R 8G 8B(lsb), in CPU endianness
+{$IFEND}
+    PIX_FMT_YUV410P,   ///< planar YUV 4:1:0,  9bpp, (1 Cr & Cb sample per 4x4 Y samples)
+    PIX_FMT_YUV411P,   ///< planar YUV 4:1:1, 12bpp, (1 Cr & Cb sample per 4x1 Y samples)
+{$IF LIBAVUTIL_VERSION <= 50000000} // 50.00.0
+    PIX_FMT_RGB565,    ///< packed RGB 5:6:5, 16bpp, (msb)   5R 6G 5B(lsb), in CPU endianness
+    PIX_FMT_RGB555,    ///< packed RGB 5:5:5, 16bpp, (msb)1A 5R 5G 5B(lsb), in CPU endianness, most significant bit to 0
+{$IFEND}
     PIX_FMT_GRAY8,     ///<        Y        ,  8bpp
     PIX_FMT_MONOWHITE, ///<        Y        ,  1bpp, 0 is white, 1 is black
     PIX_FMT_MONOBLACK, ///<        Y        ,  1bpp, 0 is black, 1 is white
     PIX_FMT_PAL8,      ///< 8 bit with PIX_FMT_RGB32 palette
-    PIX_FMT_YUVJ420P,  ///< Planar YUV 4:2:0, 12bpp, full scale (jpeg)
-    PIX_FMT_YUVJ422P,  ///< Planar YUV 4:2:2, 16bpp, full scale (jpeg)
-    PIX_FMT_YUVJ444P,  ///< Planar YUV 4:4:4, 24bpp, full scale (jpeg)
-    PIX_FMT_XVMC_MPEG2_MC,///< XVideo Motion Acceleration via common packet passing(xvmc_render.h)
+    PIX_FMT_YUVJ420P,  ///< planar YUV 4:2:0, 12bpp, full scale (JPEG)
+    PIX_FMT_YUVJ422P,  ///< planar YUV 4:2:2, 16bpp, full scale (JPEG)
+    PIX_FMT_YUVJ444P,  ///< planar YUV 4:4:4, 24bpp, full scale (JPEG)
+    PIX_FMT_XVMC_MPEG2_MC,///< XVideo Motion Acceleration via common packet passing
     PIX_FMT_XVMC_MPEG2_IDCT,
-    PIX_FMT_UYVY422,   ///< Packed YUV 4:2:2, 16bpp, Cb Y0 Cr Y1
-    PIX_FMT_UYYVYY411, ///< Packed YUV 4:1:1, 12bpp, Cb Y0 Y1 Cr Y2 Y3
-    PIX_FMT_BGR32,     ///< Packed RGB 8:8:8, 32bpp, (msb)8A 8B 8G 8R(lsb), in cpu endianness
-    PIX_FMT_BGR565,    ///< Packed RGB 5:6:5, 16bpp, (msb)   5B 6G 5R(lsb), in cpu endianness
-    PIX_FMT_BGR555,    ///< Packed RGB 5:5:5, 16bpp, (msb)1A 5B 5G 5R(lsb), in cpu endianness most significant bit to 1
-    PIX_FMT_BGR8,      ///< Packed RGB 3:3:2,  8bpp, (msb)2B 3G 3R(lsb)
-    PIX_FMT_BGR4,      ///< Packed RGB 1:2:1,  4bpp, (msb)1B 2G 1R(lsb)
-    PIX_FMT_BGR4_BYTE, ///< Packed RGB 1:2:1,  8bpp, (msb)1B 2G 1R(lsb)
-    PIX_FMT_RGB8,      ///< Packed RGB 3:3:2,  8bpp, (msb)2R 3G 3B(lsb)
-    PIX_FMT_RGB4,      ///< Packed RGB 1:2:1,  4bpp, (msb)1R 2G 1B(lsb)
-    PIX_FMT_RGB4_BYTE, ///< Packed RGB 1:2:1,  8bpp, (msb)1R 2G 1B(lsb)
-    PIX_FMT_NV12,      ///< Planar YUV 4:2:0, 12bpp, 1 plane for Y and 1 for UV
+    PIX_FMT_UYVY422,   ///< packed YUV 4:2:2, 16bpp, Cb Y0 Cr Y1
+    PIX_FMT_UYYVYY411, ///< packed YUV 4:1:1, 12bpp, Cb Y0 Y1 Cr Y2 Y3
+{$IF LIBAVUTIL_VERSION <= 50001000} // 50.01.0
+    PIX_FMT_BGR32,     ///< packed RGB 8:8:8, 32bpp, (msb)8A 8B 8G 8R(lsb), in CPU endianness
+{$IFEND}
+{$IF LIBAVUTIL_VERSION <= 50000000} // 50.00.0
+    PIX_FMT_BGR565,    ///< packed RGB 5:6:5, 16bpp, (msb)   5B 6G 5R(lsb), in CPU endianness
+    PIX_FMT_BGR555,    ///< packed RGB 5:5:5, 16bpp, (msb)1A 5B 5G 5R(lsb), in CPU endianness, most significant bit to 1
+{$IFEND}
+    PIX_FMT_BGR8,      ///< packed RGB 3:3:2,  8bpp, (msb)2B 3G 3R(lsb)
+    PIX_FMT_BGR4,      ///< packed RGB 1:2:1,  4bpp, (msb)1B 2G 1R(lsb)
+    PIX_FMT_BGR4_BYTE, ///< packed RGB 1:2:1,  8bpp, (msb)1B 2G 1R(lsb)
+    PIX_FMT_RGB8,      ///< packed RGB 3:3:2,  8bpp, (msb)2R 3G 3B(lsb)
+    PIX_FMT_RGB4,      ///< packed RGB 1:2:1,  4bpp, (msb)1R 2G 1B(lsb)
+    PIX_FMT_RGB4_BYTE, ///< packed RGB 1:2:1,  8bpp, (msb)1R 2G 1B(lsb)
+    PIX_FMT_NV12,      ///< planar YUV 4:2:0, 12bpp, 1 plane for Y and 1 for UV
     PIX_FMT_NV21,      ///< as above, but U and V bytes are swapped
-
-    PIX_FMT_RGB32_1,   ///< Packed RGB 8:8:8, 32bpp, (msb)8R 8G 8B 8A(lsb), in cpu endianness
-    PIX_FMT_BGR32_1,   ///< Packed RGB 8:8:8, 32bpp, (msb)8B 8G 8R 8A(lsb), in cpu endianness
-
+{$IF LIBAVUTIL_VERSION <= 50001000} // 50.01.0
+    PIX_FMT_RGB32_1,   ///< packed RGB 8:8:8, 32bpp, (msb)8R 8G 8B 8A(lsb), in CPU endianness
+    PIX_FMT_BGR32_1,   ///< packed RGB 8:8:8, 32bpp, (msb)8B 8G 8R 8A(lsb), in CPU endianness
+{$ELSE} // 50.02.0
+    PIX_FMT_ARGB,      ///< packed ARGB 8:8:8:8, 32bpp, ARGBARGB...
+    PIX_FMT_RGBA,      ///< packed RGBA 8:8:8:8, 32bpp, RGBARGBA...
+    PIX_FMT_ABGR,      ///< packed ABGR 8:8:8:8, 32bpp, ABGRABGR...
+    PIX_FMT_BGRA,      ///< packed BGRA 8:8:8:8, 32bpp, BGRABGRA...
+{$IFEND}
     PIX_FMT_GRAY16BE,  ///<        Y        , 16bpp, big-endian
     PIX_FMT_GRAY16LE,  ///<        Y        , 16bpp, little-endian
-    PIX_FMT_YUV440P,   ///< Planar YUV 4:4:0 (1 Cr & Cb sample per 1x2 Y samples)
-    PIX_FMT_YUVJ440P,  ///< Planar YUV 4:4:0 full scale (jpeg)
-    PIX_FMT_YUVA420P,  ///< Planar YUV 4:2:0, 20bpp, (1 Cr & Cb sample per 2x2 Y & A samples)
+    PIX_FMT_YUV440P,   ///< planar YUV 4:4:0 (1 Cr & Cb sample per 1x2 Y samples)
+    PIX_FMT_YUVJ440P,  ///< planar YUV 4:4:0 full scale (JPEG)
+    PIX_FMT_YUVA420P,  ///< planar YUV 4:2:0, 20bpp, (1 Cr & Cb sample per 2x2 Y & A samples)
+    PIX_FMT_VDPAU_H264,///< H.264 HW decoding with VDPAU, data[0] contains a vdpau_render_state struct which contains the bitstream of the slices as well as various fields extracted from headers
+    PIX_FMT_VDPAU_MPEG1,///< MPEG-1 HW decoding with VDPAU, data[0] contains a vdpau_render_state struct which contains the bitstream of the slices as well as various fields extracted from headers
+    PIX_FMT_VDPAU_MPEG2,///< MPEG-2 HW decoding with VDPAU, data[0] contains a vdpau_render_state struct which contains the bitstream of the slices as well as various fields extracted from headers
+    PIX_FMT_VDPAU_WMV3,///< WMV3 HW decoding with VDPAU, data[0] contains a vdpau_render_state struct which contains the bitstream of the slices as well as various fields extracted from headers
+    PIX_FMT_VDPAU_VC1, ///< VC-1 HW decoding with VDPAU, data[0] contains a vdpau_render_state struct which contains the bitstream of the slices as well as various fields extracted from headers
+{$IF LIBAVUTIL_VERSION >= 49015000} // 49.15.0
+    PIX_FMT_RGB48BE,   ///< packed RGB 16:16:16, 48bpp, 16R, 16G, 16B, big-endian
+    PIX_FMT_RGB48LE,   ///< packed RGB 16:16:16, 48bpp, 16R, 16G, 16B, little-endian
+{$IFEND}
+{$IF LIBAVUTIL_VERSION >= 50001000} // 50.01.0
+    PIX_FMT_RGB565BE,  ///< packed RGB 5:6:5, 16bpp, (msb)   5R 6G 5B(lsb), big-endian
+    PIX_FMT_RGB565LE,  ///< packed RGB 5:6:5, 16bpp, (msb)   5R 6G 5B(lsb), little-endian
+    PIX_FMT_RGB555BE,  ///< packed RGB 5:5:5, 16bpp, (msb)1A 5R 5G 5B(lsb), big-endian, most significant bit to 0
+    PIX_FMT_RGB555LE,  ///< packed RGB 5:5:5, 16bpp, (msb)1A 5R 5G 5B(lsb), little-endian, most significant bit to 0
+
+    PIX_FMT_BGR565BE,  ///< packed BGR 5:6:5, 16bpp, (msb)   5B 6G 5R(lsb), big-endian
+    PIX_FMT_BGR565LE,  ///< packed BGR 5:6:5, 16bpp, (msb)   5B 6G 5R(lsb), little-endian
+    PIX_FMT_BGR555BE,  ///< packed BGR 5:5:5, 16bpp, (msb)1A 5B 5G 5R(lsb), big-endian, most significant bit to 1
+    PIX_FMT_BGR555LE,  ///< packed BGR 5:5:5, 16bpp, (msb)1A 5B 5G 5R(lsb), little-endian, most significant bit to 1
+
+    PIX_FMT_VAAPI_MOCO, ///< HW acceleration through VA API at motion compensation entry-point, Picture.data[3] contains a vaapi_render_state struct which contains macroblocks as well as various fields extracted from headers
+    PIX_FMT_VAAPI_IDCT, ///< HW acceleration through VA API at IDCT entry-point, Picture.data[3] contains a vaapi_render_state struct which contains fields extracted from headers
+    PIX_FMT_VAAPI_VLD,  ///< HW decoding through VA API, Picture.data[3] contains a vaapi_render_state struct which contains the bitstream of the slices as well as various fields extracted from headers
+{$IFEND}
     PIX_FMT_NB         ///< number of pixel formats, DO NOT USE THIS if you want to link with shared libav* because the number of formats might differ between versions
   );
 
 const
 {$ifdef WORDS_BIGENDIAN}
-  PIX_FMT_RGBA = PIX_FMT_RGB32_1;
-  PIX_FMT_BGRA = PIX_FMT_BGR32_1;
-  PIX_FMT_ARGB = PIX_FMT_RGB32;
-  PIX_FMT_ABGR = PIX_FMT_BGR32;
-  PIX_FMT_GRAY16 = PIX_FMT_GRAY16BE;
+  {$IF LIBAVUTIL_VERSION <= 50001000} // 50.01.0
+    PIX_FMT_RGBA    = PIX_FMT_RGB32_1;
+    PIX_FMT_BGRA    = PIX_FMT_BGR32_1;
+    PIX_FMT_ARGB    = PIX_FMT_RGB32;
+    PIX_FMT_ABGR    = PIX_FMT_BGR32;
+  {$ELSE} // 50.02.0
+    PIX_FMT_RGB32   = PIX_FMT_ARGB;
+    PIX_FMT_RGB32_1 = PIX_FMT_RGBA;
+    PIX_FMT_BGR32   = PIX_FMT_ABGR;
+    PIX_FMT_BGR32_1 = PIX_FMT_BGRA;
+  {$IFEND}
+  PIX_FMT_GRAY16  = PIX_FMT_GRAY16BE;
+  {$IF LIBAVUTIL_VERSION >= 49015000} // 49.15.0
+    PIX_FMT_RGB48   = PIX_FMT_RGB48BE;
+  {$IFEND}
+  {$IF LIBAVUTIL_VERSION >= 50001000} // 50.01.0
+    PIX_FMT_RGB565  = PIX_FMT_RGB565BE;
+    PIX_FMT_RGB555  = PIX_FMT_RGB555BE;
+    PIX_FMT_BGR565  = PIX_FMT_BGR565BE;
+    PIX_FMT_BGR555  = PIX_FMT_BGR555BE
+  {$IFEND}
 {$else}
-  PIX_FMT_RGBA = PIX_FMT_BGR32;
-  PIX_FMT_BGRA = PIX_FMT_RGB32;
-  PIX_FMT_ARGB = PIX_FMT_BGR32_1;
-  PIX_FMT_ABGR = PIX_FMT_RGB32_1;
-  PIX_FMT_GRAY16 = PIX_FMT_GRAY16LE;
-{$endif}
+  {$IF LIBAVUTIL_VERSION <= 50001000} // 50.01.0
+    PIX_FMT_RGBA    = PIX_FMT_BGR32;
+    PIX_FMT_BGRA    = PIX_FMT_RGB32;
+    PIX_FMT_ARGB    = PIX_FMT_BGR32_1;
+    PIX_FMT_ABGR    = PIX_FMT_RGB32_1;
+  {$ELSE} // 50.02.0
+    PIX_FMT_RGB32   = PIX_FMT_BGRA;
+    PIX_FMT_RGB32_1 = PIX_FMT_ABGR;
+    PIX_FMT_BGR32   = PIX_FMT_RGBA;
+    PIX_FMT_BGR32_1 = PIX_FMT_ARGB;
+  {$IFEND}
+  PIX_FMT_GRAY16  = PIX_FMT_GRAY16LE;
+  {$IF LIBAVUTIL_VERSION >= 49015000} // 49.15.0
+    PIX_FMT_RGB48   = PIX_FMT_RGB48LE;
+  {$IFEND}
+  {$IF LIBAVUTIL_VERSION >= 50001000} // 50.01.0
+    PIX_FMT_RGB565  = PIX_FMT_RGB565LE;
+    PIX_FMT_RGB555  = PIX_FMT_RGB555LE;
+    PIX_FMT_BGR565  = PIX_FMT_BGR565LE;
+    PIX_FMT_BGR555  = PIX_FMT_BGR555LE;
+  {$IFEND}
+{$ENDIF}
 
 {$IF LIBAVUTIL_VERSION_MAJOR < 50} // 50.0.0
   PIX_FMT_UYVY411 = PIX_FMT_UYYVYY411;
@@ -183,40 +281,41 @@ const
   PIX_FMT_YUV422  = PIX_FMT_YUYV422;
 {$IFEND}
 
-(* common.h *)
+(* libavutil/common.h *) // until now MKTAG is all from common.h KMS 9/6/2009
 
-function MKTAG(a,b,c,d: char): integer;
+function MKTAG(a, b, c, d: AnsiChar): integer;
 
-(* mem.h *)
+(* libavutil/mem.h *)
+(* memory handling functions *)
 
 (**
- * Allocate a block of \p size bytes with alignment suitable for all
+ * Allocates a block of size bytes with alignment suitable for all
  * memory accesses (including vectors if available on the CPU).
  * @param size Size in bytes for the memory block to be allocated.
- * @return Pointer to the allocated block, NULL if it cannot allocate
- * it.
+ * @return Pointer to the allocated block, NULL if the block cannot
+ * be allocated.
  * @see av_mallocz()
  *)
 function av_malloc(size: cuint): pointer;
   cdecl; external av__util; {av_malloc_attrib av_alloc_size(1)}
 
 (**
- * Allocate or reallocate a block of memory.
- * If \p ptr is NULL and \p size > 0, allocate a new block. If \p
- * size is zero, free the memory block pointed by \p ptr.
+ * Allocates or reallocates a block of memory.
+ * If ptr is NULL and size > 0, allocates a new block. If 
+ * size is zero, frees the memory block pointed to by ptr.
  * @param size Size in bytes for the memory block to be allocated or
  * reallocated.
  * @param ptr Pointer to a memory block already allocated with
  * av_malloc(z)() or av_realloc() or NULL.
- * @return Pointer to a newly reallocated block or NULL if it cannot
- * reallocate or the function is used to free the memory block.
+ * @return Pointer to a newly reallocated block or NULL if the block
+ * cannot be allocated or the function is used to free the memory block.
  * @see av_fast_realloc()
  *)
 function av_realloc(ptr: pointer; size: cuint): pointer;
   cdecl; external av__util; {av_alloc_size(2)}
 
 (**
- * Free a memory block which has been allocated with av_malloc(z)() or
+ * Frees a memory block which has been allocated with av_malloc(z)() or
  * av_realloc().
  * @param ptr Pointer to the memory block which should be freed.
  * @note ptr = NULL is explicitly allowed.
@@ -227,29 +326,28 @@ procedure av_free(ptr: pointer);
   cdecl; external av__util;
 
 (**
- * Allocate a block of \p size bytes with alignment suitable for all
+ * Allocates a block of size bytes with alignment suitable for all
  * memory accesses (including vectors if available on the CPU) and
- * set to zeroes all the bytes of the block.
+ * zeroes all the bytes of the block.
  * @param size Size in bytes for the memory block to be allocated.
- * @return Pointer to the allocated block, NULL if it cannot allocate
- * it.
+ * @return Pointer to the allocated block, NULL if it cannot be allocated.
  * @see av_malloc()
  *)
 function av_mallocz(size: cuint): pointer;
   cdecl; external av__util; {av_malloc_attrib av_alloc_size(1)}
 
 (**
- * Duplicate the string \p s.
- * @param s String to be duplicated.
+ * Duplicates the string s.
+ * @param s string to be duplicated.
  * @return Pointer to a newly allocated string containing a
- * copy of \p s or NULL if it cannot be allocated.
+ * copy of s or NULL if the string cannot be allocated.
  *)
-function av_strdup({const} s: PChar): PChar;
+function av_strdup({const} s: PAnsiChar): PAnsiChar;
   cdecl; external av__util; {av_malloc_attrib}
 
 (**
- * Free a memory block which has been allocated with av_malloc(z)() or
- * av_realloc() and set to NULL the pointer to it.
+ * Frees a memory block which has been allocated with av_malloc(z)() or
+ * av_realloc() and set the pointer pointing to it to NULL.
  * @param ptr Pointer to the pointer to the memory block which should
  * be freed.
  * @see av_free()
@@ -257,7 +355,7 @@ function av_strdup({const} s: PChar): PChar;
 procedure av_freep (ptr: pointer);
   cdecl; external av__util;
 
-(* log.h *)
+(* libavutil/log.h *)
 
 const
 {$IF LIBAVUTIL_VERSION_MAJOR < 50}
@@ -272,26 +370,26 @@ const
   AV_LOG_QUIET   = -8;
 
 (**
- * something went really wrong and we will crash now
+ * Something went really wrong and we will crash now.
  *)
   AV_LOG_PANIC   =  0;
 
 (**
- * something went wrong and recovery is not possible
- * like no header in a format which depends on it or a combination
- * of parameters which are not allowed
+ * Something went wrong and recovery is not possible.
+ * For example, no header was found for a format which depends
+ * on headers or an illegal combination of parameters is used.
  *)
   AV_LOG_FATAL   =  8;
 
 (**
- * something went wrong and cannot losslessly be recovered
- * but not all future data is affected
+ * Something went wrong and cannot losslessly be recovered.
+ * However, not all future data is affected.
  *)
   AV_LOG_ERROR   = 16;
 
 (**
- * something somehow does not look correct / something which may or may not
- * lead to some problems like use of -vstrict -2
+ * Something somehow does not look correct. This may or may not
+ * lead to problems. An example would be the use of '-vstrict -2'.
  *)
   AV_LOG_WARNING = 24;
 
@@ -299,7 +397,7 @@ const
   AV_LOG_VERBOSE = 40;
 
 (**
- * stuff which is only useful for libav* developers
+ * Stuff which is only useful for libav* developers.
  *)
   AV_LOG_DEBUG   = 48;
 {$IFEND}
@@ -312,7 +410,9 @@ procedure av_log_set_level(level: cint);
 
 implementation
 
-function MKTAG(a,b,c,d: char): integer;
+(* libavutil/common.h *)
+
+function MKTAG(a, b, c, d: AnsiChar): integer;
 begin
   Result := (ord(a) or (ord(b) shl 8) or (ord(c) shl 16) or (ord(d) shl 24));
 end;
diff --git a/Lua/src/lib/ffmpeg/mathematics.pas b/Lua/src/lib/ffmpeg/mathematics.pas
index 606d9189..f3a307b6 100644
--- a/Lua/src/lib/ffmpeg/mathematics.pas
+++ b/Lua/src/lib/ffmpeg/mathematics.pas
@@ -26,8 +26,16 @@
 
 (*
  * Conversion of libavutil/mathematics.h
- * revision 15120, Sun Aug 31 07:39:47 2008 UTC 
+ * revision 16844, Wed Jan 28 08:50:10 2009 UTC 
+ *
+ * update, MiSchi, no code change
+ * Fri Jun 12 2009 21:50:00 UTC
  *)
+{
+ * update to
+ * avutil max. version 50.05.1, Sun, Dec 6 24:00:00 2009 UTC 
+ * MiSchi
+}
 
 unit mathematics;
 
@@ -52,32 +60,41 @@ const
   M_LN10       = 2.30258509299404568402;  // log_e 10
   M_PI         = 3.14159265358979323846;  // pi
   M_SQRT1_2    = 0.70710678118654752440;  // 1/sqrt(2)
+{$IF LIBAVUTIL_VERSION >= 50005001} // >= 50.5.1
+  NAN          = 0.0/0.0;     
+  INFINITY     = 1.0/0.0;     
+{$IFEND}
 
 type
   TAVRounding = (
-    AV_ROUND_ZERO     = 0, ///< round toward zero
-    AV_ROUND_INF      = 1, ///< round away from zero
-    AV_ROUND_DOWN     = 2, ///< round toward -infinity
-    AV_ROUND_UP       = 3, ///< round toward +infinity
-    AV_ROUND_NEAR_INF = 5  ///< round to nearest and halfway cases away from zero
+    AV_ROUND_ZERO     = 0, ///< Round toward zero.
+    AV_ROUND_INF      = 1, ///< Round away from zero.
+    AV_ROUND_DOWN     = 2, ///< Round toward -infinity.
+    AV_ROUND_UP       = 3, ///< Round toward +infinity.
+    AV_ROUND_NEAR_INF = 5  ///< Round to nearest and halfway cases away from zero.
   );
 
+{$IF LIBAVUTIL_VERSION >= 49013000} // 49.13.0
+function av_gcd(a: cint64; b: cint64): cint64;
+  cdecl; external av__util; {av_const}
+{$IFEND}
+
 (**
- * rescale a 64bit integer with rounding to nearest.
- * a simple a*b/c isn't possible as it can overflow
+ * Rescales a 64-bit integer with rounding to nearest.
+ * A simple a*b/c isn't possible as it can overflow.
  *)
 function av_rescale (a, b, c: cint64): cint64;
   cdecl; external av__util; {av_const}
 
 (**
- * rescale a 64bit integer with specified rounding.
- * a simple a*b/c isn't possible as it can overflow
+ * Rescales a 64-bit integer with specified rounding.
+ * A simple a*b/c isn't possible as it can overflow.
  *)
 function av_rescale_rnd (a, b, c: cint64; enum: TAVRounding): cint64;
   cdecl; external av__util; {av_const}
 
 (**
- * rescale a 64bit integer by 2 rational numbers.
+ * Rescales a 64-bit integer by 2 rational numbers.
  *)
 function av_rescale_q (a: cint64; bq, cq: TAVRational): cint64;
   cdecl; external av__util; {av_const}
@@ -85,4 +102,3 @@ function av_rescale_q (a: cint64; bq, cq: TAVRational): cint64;
 implementation
 
 end.
- 
diff --git a/Lua/src/lib/ffmpeg/opt.pas b/Lua/src/lib/ffmpeg/opt.pas
index e734aa9f..65e055ce 100644
--- a/Lua/src/lib/ffmpeg/opt.pas
+++ b/Lua/src/lib/ffmpeg/opt.pas
@@ -27,8 +27,16 @@
 
 (*
  * Conversion of libavcodec/opt.h
- * revision 15120, Sun Aug 31 07:39:47 2008 UTC 
+ * revision 16912, Sun Feb 1 02:00:19 2009 UTC 
+ *
+ * update, MiSchi, no code change
+ * Fri Jun 12 2009 21:50:00 UTC
  *)
+{
+ * update to
+ * Max. version: 52.42.0, Sun Dec 6 19:20:00 2009 CET 
+ * MiSchi
+}
 
 unit opt;
 
@@ -74,13 +82,13 @@ type
    *)
   PAVOption = ^TAVOption;
   TAVOption = record
-    name: {const} PChar;
+    name: {const} PAnsiChar;
     
     (**
      * short English help text
      * @todo What about other languages?
      *)
-    help: {const} PChar;
+    help: {const} PAnsiChar;
 
     (**
      * The offset relative to the context structure where the option
@@ -104,34 +112,103 @@ type
      * options and corresponding named constants share the same
      * unit. May be NULL.
      *)
-    unit_: {const} PChar;
+    unit_: {const} PAnsiChar;
   end;
 
+{$IF LIBAVCODEC_VERSION >= 52042000} // >= 52.42.0
+(**
+ * AVOption2.
+ * THIS IS NOT PART OF THE API/ABI YET!
+ * This is identical to AVOption except that default_val was replaced by
+ * an union, it should be compatible with AVOption on normal platforms.
+ *)
+const
+  AV_OPT_FLAG_ENCODING_PARAM = 1;     ///< a generic parameter which can be set by the user for muxing or encoding
+  AV_OPT_FLAG_DECODING_PARAM = 2;     ///< a generic parameter which can be set by the user for demuxing or decoding
+  AV_OPT_FLAG_METADATA       = 4;     ///< some data extracted or inserted into the file like title, comment, ...
+  AV_OPT_FLAG_AUDIO_PARAM    = 8;     
+  AV_OPT_FLAG_VIDEO_PARAM    = 16;     
+  AV_OPT_FLAG_SUBTITLE_PARAM = 32;     
+type
+  PAVOption2 = ^TAVOption2;
+  TAVOption2 = record
+    name   : {const} PAnsiChar;
+
+    (**
+     * short English help text
+     * @todo What about other languages?
+     *)
+    help   : {const} PAnsiChar;
+
+    (**
+     * The offset relative to the context structure where the option
+     * value is stored. It should be 0 for named constants.
+     *)
+    offset : cint;
+    type_  : TAVOptionType;
+
+    (**
+     * the default value for scalar options
+     *)
+    default_val : record
+      case cint of
+        0 : (dbl: cdouble);
+        1 : (str: PAnsiChar);
+      end;
+    min   : cdouble;
+    max   : cdouble;
+    flags : cint;
+//FIXME think about enc-audio, ... style flags
+
+    (**
+     * The logical unit to which the option belongs. Non-constant
+     * options and corresponding named constants share the same
+     * unit. May be NULL.
+     *)
+    unit_: {const} PAnsiChar;
+  end;
+{$IFEND}
+
 {$IF LIBAVCODEC_VERSION >= 51039000} // 51.39.0
 (**
- * Looks for an option in \p obj. Looks only for the options which
- * have the flags set as specified in \p mask and \p flags (that is,
+ * Looks for an option in obj. Looks only for the options which
+ * have the flags set as specified in mask and flags (that is,
  * for which it is the case that opt->flags & mask == flags).
  *
  * @param[in] obj a pointer to a struct whose first element is a
- * pointer to an #AVClass
+ * pointer to an AVClass
  * @param[in] name the name of the option to look for
  * @param[in] unit the unit of the option to look for, or any if NULL
  * @return a pointer to the option found, or NULL if no option
  * has been found
  *)
-function av_find_opt(obj: Pointer; {const} name: {const} PChar; {const} unit_: PChar; mask: cint; flags: cint): {const} PAVOption;
+function av_find_opt(obj: Pointer; {const} name: {const} PAnsiChar; {const} unit_: PAnsiChar; mask: cint; flags: cint): {const} PAVOption;
   cdecl; external av__codec;
 {$IFEND}
 
+{$IF LIBAVCODEC_VERSION_MAJOR < 53}
+
 (**
  * @see av_set_string2()
  *)
-function av_set_string(obj: pointer; name: {const} pchar; val: {const} pchar): {const} PAVOption;
+function av_set_string(obj: pointer; name: {const} PAnsiChar; val: {const} PAnsiChar): {const} PAVOption;
   cdecl; external av__codec; deprecated;
 
 {$IF LIBAVCODEC_VERSION >= 51059000} // 51.59.0
 (**
+ * @return a pointer to the AVOption corresponding to the field set or
+ * NULL if no matching AVOption exists, or if the value val is not
+ * valid
+ * @see av_set_string3()
+ *)
+function av_set_string2(obj: Pointer; name: {const} PAnsiChar; val: {const} PAnsiChar; alloc: cint): {const} PAVOption;
+  cdecl; external av__codec; deprecated;
+{$IFEND}
+
+{$IFEND}
+
+{$IF LIBAVCODEC_VERSION >= 52007000} // 52.7.0
+(**
  * Sets the field of obj with the given name to value.
  *
  * @param[in] obj A struct whose first element is a pointer to an
@@ -147,36 +224,40 @@ function av_set_string(obj: pointer; name: {const} pchar; val: {const} pchar): {
  * scalars or named flags separated by '+' or '-'. Prefixing a flag
  * with '+' causes it to be set without affecting the other flags;
  * similarly, '-' unsets a flag.
- * @return a pointer to the AVOption corresponding to the field set or
- * NULL if no matching AVOption exists, or if the value \p val is not
- * valid
+ * @param[out] o_out if non-NULL put here a pointer to the AVOption
+ * found
  * @param alloc when 1 then the old value will be av_freed() and the
  *                     new av_strduped()
  *              when 0 then no av_free() nor av_strdup() will be used
+ * @return 0 if the value has been set, or an AVERROR code in case of
+ * error:
+ * AVERROR(ENOENT) if no matching option exists
+ * AVERROR(ERANGE) if the value is out of range
+ * AVERROR(EINVAL) if the value is not valid
  *)
-function av_set_string2(obj: Pointer; name: {const} PChar; val: {const} PChar; alloc: cint): {const} PAVOption;
+function av_set_string3(obj: Pointer; name: {const} PAnsiChar; val: {const} PAnsiChar; alloc: cint; out o_out: {const} PAVOption): cint;
   cdecl; external av__codec;
 {$IFEND}
 
-function av_set_double(obj: pointer; name: {const} pchar; n: cdouble): PAVOption;
+function av_set_double(obj: pointer; name: {const} PAnsiChar; n: cdouble): PAVOption;
   cdecl; external av__codec;
 
-function av_set_q(obj: pointer; name: {const} pchar; n: TAVRational): PAVOption;
+function av_set_q(obj: pointer; name: {const} PAnsiChar; n: TAVRational): PAVOption;
   cdecl; external av__codec;
 
-function av_set_int(obj: pointer; name: {const} pchar; n: cint64): PAVOption;
+function av_set_int(obj: pointer; name: {const} PAnsiChar; n: cint64): PAVOption;
   cdecl; external av__codec;
 
-function av_get_double(obj: pointer; name: {const} pchar; var o_out: PAVOption): cdouble;
+function av_get_double(obj: pointer; name: {const} PAnsiChar; var o_out: PAVOption): cdouble;
   cdecl; external av__codec;
 
-function av_get_q(obj: pointer; name: {const} pchar; var o_out: PAVOption): TAVRational;
+function av_get_q(obj: pointer; name: {const} PAnsiChar; var o_out: PAVOption): TAVRational;
   cdecl; external av__codec;
 
-function av_get_int(obj: pointer; name: {const} pchar; var o_out: {const} PAVOption): cint64;
+function av_get_int(obj: pointer; name: {const} PAnsiChar; var o_out: {const} PAVOption): cint64;
   cdecl; external av__codec;
 
-function av_get_string(obj: pointer; name: {const} pchar; var o_out: {const} PAVOption; buf: pchar; buf_len: cint): pchar;
+function av_get_string(obj: pointer; name: {const} PAnsiChar; var o_out: {const} PAVOption; buf: PAnsiChar; buf_len: cint): PAnsiChar;
   cdecl; external av__codec;
 
 function av_next_option(obj: pointer; last: {const} PAVOption): PAVOption;
diff --git a/Lua/src/lib/ffmpeg/rational.pas b/Lua/src/lib/ffmpeg/rational.pas
index 02d594ff..4b8a2dc8 100644
--- a/Lua/src/lib/ffmpeg/rational.pas
+++ b/Lua/src/lib/ffmpeg/rational.pas
@@ -1,5 +1,5 @@
 (*
- * Rational numbers
+ * rational numbers
  * Copyright (c) 2003 Michael Niedermayer <michaelni@gmx.at>
  *
  * This library is free software; you can redistribute it and/or
@@ -27,7 +27,13 @@
 
 (*
  * Conversion of libavutil/rational.h
- * revision 15415, Thu Sep 25 19:23:13 2008 UTC 
+ * revision 16912, Sun Feb 1 02:00:19 2009 UTC 
+ *
+ * update, MiSchi, no code change
+ * Fri Jun 12 2009 22:20:00 UTC
+ *
+ * update, MiSchi, no code change needed
+ * Sun Dec 6 2009 22:20:00 UTC
  *)
 
 unit rational;
@@ -49,9 +55,9 @@ uses
   UConfig;
 
 type
-(*
- * Rational number num/den.
- *)
+  (*
+   * rational number numerator/denominator
+   *)
   PAVRational = ^TAVRational;
   TAVRational = record
     num: cint; ///< numerator
@@ -62,65 +68,65 @@ type
   PAVRationalArray = ^TAVRationalArray;
 
 (**
- * Compare two rationals.
+ * Compares two rationals.
  * @param a first rational
  * @param b second rational
- * @return 0 if a==b, 1 if a>b and -1 if a<b.
+ * @return 0 if a==b, 1 if a>b and -1 if a<b
  *)
 function av_cmp_q(a: TAVRational; b: TAVRational): cint; {$IFDEF HasInline}inline;{$ENDIF}
 
 (**
- * Rational to double conversion.
+ * Converts rational to double.
  * @param a rational to convert
  * @return (double) a
  *)
 function av_q2d(a: TAVRational): cdouble; {$IFDEF HasInline}inline;{$ENDIF}
 
 (**
- * Reduce a fraction.
+ * Reduces a fraction.
  * This is useful for framerate calculations.
- * @param dst_nom destination numerator
+ * @param dst_num destination numerator
  * @param dst_den destination denominator
- * @param nom source numerator
+ * @param num source numerator
  * @param den source denominator
- * @param max the maximum allowed for dst_nom & dst_den
+ * @param max the maximum allowed for dst_num & dst_den
  * @return 1 if exact, 0 otherwise
  *)
-function av_reduce(dst_nom: PCint; dst_den: PCint; nom: cint64; den: cint64; max: cint64): cint;
+function av_reduce(dst_num: PCint; dst_den: PCint; num: cint64; den: cint64; max: cint64): cint;
   cdecl; external av__util;
 
 (**
  * Multiplies two rationals.
- * @param b first rational.
- * @param c second rational.
- * @return b*c.
+ * @param b first rational
+ * @param c second rational
+ * @return b*c
  *)
 function av_mul_q(b: TAVRational; c: TAVRational): TAVRational;
   cdecl; external av__util; {av_const}
 
 (**
  * Divides one rational by another.
- * @param b first rational.
- * @param c second rational.
- * @return b/c.
+ * @param b first rational
+ * @param c second rational
+ * @return b/c
  *)
 function av_div_q(b: TAVRational; c: TAVRational): TAVRational;
   cdecl; external av__util; {av_const}
 
 (**
  * Adds two rationals.
- * @param b first rational.
- * @param c second rational.
- * @return b+c.
+ * @param b first rational
+ * @param c second rational
+ * @return b+c
  *)
 function av_add_q(b: TAVRational; c: TAVRational): TAVRational;
   cdecl; external av__util; {av_const}
 
 (**
  * Subtracts one rational from another.
- * @param b first rational.
- * @param c second rational.
- * @return b-c.
+ * @param b first rational
+ * @param c second rational
+ * @return b-c
  *)
 function av_sub_q(b: TAVRational; c: TAVRational): TAVRational;
   cdecl; external av__util; {av_const}
@@ -129,28 +135,26 @@ function av_sub_q(b: TAVRational; c: TAVRational): TAVRational;
  * Converts a double precision floating point number to a rational.
  * @param d double to convert
  * @param max the maximum allowed numerator and denominator
- * @return (AVRational) d.
+ * @return (AVRational) d
  *)
 function av_d2q(d: cdouble; max: cint): TAVRational;
   cdecl; external av__util; {av_const}
 
 {$IF LIBAVUTIL_VERSION >= 49011000} // 49.11.0
-
 (**
- * @return 1 if \q1 is nearer to \p q than \p q2, -1 if \p q2 is nearer
- * than \p q1, 0 if they have the same distance.
+ * @return 1 if q1 is nearer to q than q2, -1 if q2 is nearer
+ * than q1, 0 if they have the same distance.
  *)
 function av_nearer_q(q, q1, q2: TAVRational): cint;
   cdecl; external av__util;
 
 (**
- * Finds the nearest value in \p q_list to \p q.
+ * Finds the nearest value in q_list to q.
  * @param q_list an array of rationals terminated by {0, 0}
  * @return the index of the nearest value found in the array
  *)
 function av_find_nearest_q_idx(q: TAVRational; q_list: {const} PAVRationalArray): cint;
   cdecl; external av__util;
-
 {$IFEND}
 
 implementation
diff --git a/Lua/src/lib/ffmpeg/swscale.pas b/Lua/src/lib/ffmpeg/swscale.pas
index 965659d9..595e16ba 100644
--- a/Lua/src/lib/ffmpeg/swscale.pas
+++ b/Lua/src/lib/ffmpeg/swscale.pas
@@ -25,6 +25,11 @@
  * Conversion of libswscale/swscale.h
  * revision 27592, Fri Sep 12 21:46:53 2008 UTC 
  *)
+{
+ * update to
+ * Max. version: 0.7.2, Sun Dec 6 22:20:00 2009 CET 
+ * MiSchi
+}
  
 unit swscale;
 
@@ -45,13 +50,14 @@ interface
 uses
   ctypes,
   avutil,
+  avcodec,
   UConfig;
 
 const
   (* Max. supported version by this header *)
   LIBSWSCALE_MAX_VERSION_MAJOR   = 0;
-  LIBSWSCALE_MAX_VERSION_MINOR   = 6;
-  LIBSWSCALE_MAX_VERSION_RELEASE = 1;
+  LIBSWSCALE_MAX_VERSION_MINOR   = 7;
+  LIBSWSCALE_MAX_VERSION_RELEASE = 2;
   LIBSWSCALE_MAX_VERSION = (LIBSWSCALE_MAX_VERSION_MAJOR * VERSION_MAJOR) +
                            (LIBSWSCALE_MAX_VERSION_MINOR * VERSION_MINOR) +
                            (LIBSWSCALE_MAX_VERSION_RELEASE * VERSION_RELEASE);
@@ -77,8 +83,22 @@ function swscale_version(): cuint;
   cdecl; external sw__scale;
 {$IFEND}
 
+{$IF LIBSWSCALE_VERSION >= 000007002} // 0.7.2
+(**
+ * Returns the libswscale build-time configuration.
+ *)
+function swscale_configuration(): PAnsiChar;
+  cdecl; external sw__scale;
+
+(**
+ * Returns the libswscale license.
+ *)
+function swscale_license(): PAnsiChar;
+  cdecl; external sw__scale;
+{$IFEND}
+
 const
-  {* values for the flags, the stuff on the command line is different *}
+  (* values for the flags, the stuff on the command line is different *)
   SWS_FAST_BILINEAR =    1;
   SWS_BILINEAR      =    2;
   SWS_BICUBIC       =    4;
@@ -98,10 +118,10 @@ const
 
   SWS_PRINT_INFO           = $1000;
 
-  //the following 3 flags are not completely implemented
-  //internal chrominace subsampling info
+  // the following 3 flags are not completely implemented
+  // internal chrominace subsampling info
   SWS_FULL_CHR_H_INT    = $2000;
-  //input subsampling info
+  // input subsampling info
   SWS_FULL_CHR_H_INP    = $4000;
   SWS_DIRECT_BGR        = $8000;
   SWS_ACCURATE_RND      = $40000;
@@ -123,15 +143,14 @@ const
   SWS_CS_SMPTE240M      = 7;
   SWS_CS_DEFAULT        = 5;
 
-
 type
 
   // when used for filters they must have an odd number of elements
   // coeffs cannot be shared between vectors
   PSwsVector = ^TSwsVector;
   TSwsVector = record
-    coeff: PCdouble;
-    length: cint;
+    coeff: PCdouble;    // pointer to the list of coefficients
+    length: cint;       // number of coefficients in the vector
   end;
 
   // vectors can be shared
@@ -148,63 +167,187 @@ type
     {internal structure}
   end;
 
-
+(**
+ * Frees the swscaler context swsContext.
+ * If swsContext is NULL, then does nothing.
+ *)
 procedure sws_freeContext(swsContext: PSwsContext);
   cdecl; external sw__scale;
 
+(**
+ * Allocates and returns a SwsContext. You need it to perform
+ * scaling/conversion operations using sws_scale().
+ *
+ * @param srcW the width of the source image
+ * @param srcH the height of the source image
+ * @param srcFormat the source image format
+ * @param dstW the width of the destination image
+ * @param dstH the height of the destination image
+ * @param dstFormat the destination image format
+ * @param flags specify which algorithm and options to use for rescaling
+ * @return a pointer to an allocated context, or NULL in case of error
+ *)
 function sws_getContext(srcW: cint; srcH: cint; srcFormat: TAVPixelFormat;
-              dstW: cint; dstH: cint; dstFormat: TAVPixelFormat; flags: cint;
-              srcFilter: PSwsFilter; dstFilter: PSwsFilter; param: PCdouble): PSwsContext;
+                        dstW: cint; dstH: cint; dstFormat: TAVPixelFormat;
+	                flags: cint; srcFilter: PSwsFilter;
+	                dstFilter: PSwsFilter; param: PCdouble): PSwsContext;
   cdecl; external sw__scale;
-function sws_scale(context: PSwsContext; src: PPCuint8Array; srcStride: PCintArray; srcSliceY: cint; srcSliceH: cint;
-              dst: PPCuint8Array; dstStride: PCintArray): cint;
+
+(**
+ * Scales the image slice in srcSlice and puts the resulting scaled
+ * slice in the image in dst. A slice is a sequence of consecutive
+ * rows in an image.
+ *
+ * Slices have to be provided in sequential order, either in
+ * top-bottom or bottom-top order. If slices are provided in
+ * non-sequential order the behavior of the function is undefined.
+ *
+ * @param context   the scaling context previously created with
+ *                  sws_getContext()
+ * @param srcSlice  the array containing the pointers to the planes of
+ *                  the source slice
+ * @param srcStride the array containing the strides for each plane of
+ *                  the source image
+ * @param srcSliceY the position in the source image of the slice to
+ *                  process, that is the number (counted starting from
+ *                  zero) in the image of the first row of the slice
+ * @param srcSliceH the height of the source slice, that is the number
+ *                  of rows in the slice
+ * @param dst       the array containing the pointers to the planes of
+ *                  the destination image
+ * @param dstStride the array containing the strides for each plane of
+ *                  the destination image
+ * @return          the height of the output slice
+ *)
+function sws_scale(context: PSwsContext; srcSlice: PPCuint8Array; srcStride: PCintArray;
+              srcSliceY: cint; srcSliceH: cint; dst: PPCuint8Array; dstStride: PCintArray): cint;
   cdecl; external sw__scale;
-function sws_scale_ordered(context: PSwsContext; src: PPCuint8Array; srcStride: PCintArray; srcSliceY: cint;
-              srcSliceH: cint; dst: PPCuint8Array; dstStride: PCintArray): cint;
+
+{$IF  LIBSWSCALE_VERSION_MAJOR < 1}
+// deprecated. Use sws_scale() instead.
+function sws_scale_ordered(context: PSwsContext; src: PPCuint8Array; srcStride: PCintArray;
+              srcSliceY: cint; srcSliceH: cint; dst: PPCuint8Array; dstStride: PCintArray): cint;
   cdecl; external sw__scale; deprecated;
+{$IFEND}
 
-function sws_setColorspaceDetails(c: PSwsContext; inv_table: PQuadCintArray; srcRange: cint; table: PQuadCintArray; dstRange: cint;
+(**
+ * @param inv_table the yuv2rgb coefficients, normally ff_yuv2rgb_coeffs[x]
+ * @param fullRange if 1 then the luma range is 0..255 if 0 it is 16..235
+ * @return -1 if not supported
+ *)
+function sws_setColorspaceDetails(c: PSwsContext; inv_table: PQuadCintArray; 
+              srcRange: cint; table: PQuadCintArray; dstRange: cint;
               brightness: cint; contrast: cint; saturation: cint): cint;
   cdecl; external sw__scale;
-function sws_getColorspaceDetails(c: PSwsContext; var inv_table: PQuadCintArray; var srcRange: cint; var table: PQuadCintArray; var dstRange: cint;
+
+(**
+ * @return -1 if not supported
+ *)
+function sws_getColorspaceDetails(c: PSwsContext; var inv_table: PQuadCintArray;
+              var srcRange: cint; var table: PQuadCintArray; var dstRange: cint;
               var brightness: cint; var contrast: cint; var saturation: cint): cint;
   cdecl; external sw__scale;
+
+(**
+ * Returns a normalized Gaussian curve used to filter stuff
+ * quality=3 is high quality, lower is lower quality.
+ *)
 function sws_getGaussianVec(variance: cdouble; quality: cdouble): PSwsVector;
   cdecl; external sw__scale;
+
+(**
+ * Allocates and returns a vector with length coefficients, all
+ * with the same value c.
+ *)
 function sws_getConstVec(c: cdouble; length: cint): PSwsVector;
   cdecl; external sw__scale;
+  
+(**
+ * Allocates and returns a vector with just one coefficient, with
+ * value 1.0.
+ *)
 function sws_getIdentityVec: PSwsVector;
   cdecl; external sw__scale;
+
+(**
+ * Scales all the coefficients of a by the scalar value.
+ *)
 procedure sws_scaleVec(a: PSwsVector; scalar: cdouble);
   cdecl; external sw__scale;
+
+(**
+ * Scales all the coefficients of a so that their sum equals height.
+ *)
 procedure sws_normalizeVec(a: PSwsVector; height: cdouble);
   cdecl; external sw__scale;
+
 procedure sws_convVec(a: PSwsVector; b: PSwsVector);
   cdecl; external sw__scale;
+
 procedure sws_addVec(a: PSwsVector; b: PSwsVector);
   cdecl; external sw__scale;
+
 procedure sws_subVec(a: PSwsVector; b: PSwsVector);
   cdecl; external sw__scale;
+
 procedure sws_shiftVec(a: PSwsVector; shift: cint);
   cdecl; external sw__scale;
+
+(**
+ * Allocates and returns a clone of the vector a, that is a vector
+ * with the same coefficients as a.
+ *)
 function sws_cloneVec(a: PSwsVector): PSwsVector;
   cdecl; external sw__scale;
 
+{$IF LIBSWSCALE_VERSION_MAJOR < 1}
+// deprecated Use sws_printVec2() instead.
+
 procedure sws_printVec(a: PSwsVector);
+  cdecl; external sw__scale; deprecated;
+{$IFEND}
+
+{$IF LIBSWSCALE_VERSION >= 000007000} // >= 0.7.0
+(**
+ * Prints with av_log() a textual representation of the vector a
+ * if log_level <= av_log_level.
+ *)
+procedure sws_printVec2(a:         PSwsVector;
+                        log_ctx:   PAVClass; // PAVClass is declared in avcodec.pas
+			log_level: cint);
   cdecl; external sw__scale;
+{$IFEND}
+
 procedure sws_freeVec(a: PSwsVector);
   cdecl; external sw__scale;
 
-function sws_getDefaultFilter(lumaGBlur: cfloat; chromaGBlur: cfloat; lumaSarpen: cfloat; chromaSharpen: cfloat; chromaHShift: cfloat;
-              chromaVShift: cfloat; verbose: cint): PSwsFilter;
+function sws_getDefaultFilter(lumaGBlur: cfloat; chromaGBlur: cfloat; 
+                              lumaSharpen: cfloat; chromaSharpen: cfloat;
+			      chromaHShift: cfloat; chromaVShift: cfloat;
+			      verbose: cint): PSwsFilter;
   cdecl; external sw__scale;
+
 procedure sws_freeFilter(filter: PSwsFilter);
   cdecl; external sw__scale;
 
+(**
+ * Checks if context can be reused, otherwise reallocates a new
+ * one.
+ * 
+ * If context is NULL, just calls sws_getContext() to get a new
+ * context. Otherwise, checks if the parameters are the ones already
+ * saved in context. If that is the case, returns the current
+ * context. Otherwise, frees context and gets a new context with
+ * the new parameters.
+ * 
+ * Be warned that srcFilter and dstFilter are not checked, they
+ * are assumed to remain the same.
+ *)
 function sws_getCachedContext(context: PSwsContext;
-              srcW: cint; srcH: cint; srcFormat: cint;
-              dstW: cint; dstH: cint; dstFormat: cint; flags: cint;
-              srcFilter: PSwsFilter; dstFilter: PSwsFilter; param: PCdouble): PSwsContext;
+              srcW: cint; srcH: cint; srcFormat: TAVPixelFormat;
+              dstW: cint; dstH: cint; dstFormat: TAVPixelFormat;
+	      flags: cint; srcFilter: PSwsFilter; 
+	      dstFilter: PSwsFilter; param: PCdouble): PSwsContext;
   cdecl; external sw__scale;
 
 implementation
diff --git a/Lua/src/lib/fft/UFFT.pas b/Lua/src/lib/fft/UFFT.pas
index 6b094c98..5a056a8c 100644
--- a/Lua/src/lib/fft/UFFT.pas
+++ b/Lua/src/lib/fft/UFFT.pas
@@ -47,7 +47,7 @@ unit UFFT;
 
 {$IFDEF FPC}
   {$MODE Delphi}
-  {$H+} // Use AnsiString
+  {$H+} // Use long strings
 {$ENDIF}
 
 interface
diff --git a/Lua/src/lib/freetype/demo/engine-test.bdsproj b/Lua/src/lib/freetype/demo/engine-test.bdsproj
index 9547f18f..e5b3e97d 100644
--- a/Lua/src/lib/freetype/demo/engine-test.bdsproj
+++ b/Lua/src/lib/freetype/demo/engine-test.bdsproj
@@ -27,13 +27,13 @@
 			<Compiler Name="I">1</Compiler>
 			<Compiler Name="J">0</Compiler>
 			<Compiler Name="K">0</Compiler>
-			<Compiler Name="L">1</Compiler>
-			<Compiler Name="M">0</Compiler>
-			<Compiler Name="N">1</Compiler>
-			<Compiler Name="O">0</Compiler>
-			<Compiler Name="P">1</Compiler>
-			<Compiler Name="Q">0</Compiler>
-			<Compiler Name="R">0</Compiler>
+			<Compiler Name="L">1</Compiler>
+			<Compiler Name="M">0</Compiler>
+			<Compiler Name="N">1</Compiler>
+			<Compiler Name="O">1</Compiler>
+			<Compiler Name="P">1</Compiler>
+			<Compiler Name="Q">0</Compiler>
+			<Compiler Name="R">0</Compiler>
 			<Compiler Name="S">0</Compiler>
 			<Compiler Name="T">0</Compiler>
 			<Compiler Name="U">0</Compiler>
diff --git a/Lua/src/lib/freetype/demo/engine-test.dpr b/Lua/src/lib/freetype/demo/engine-test.dpr
index 80177735..bbd7d890 100644
--- a/Lua/src/lib/freetype/demo/engine-test.dpr
+++ b/Lua/src/lib/freetype/demo/engine-test.dpr
@@ -27,7 +27,9 @@ uses
   ctypes       in '../../ctypes/ctypes.pas',
   {$ENDIF}
   FreeType     in '../freetype.pas',
-  UFont        in '../../../base/UFont.pas',
+  UFont        in 'UFont.pas',
+  //UFont        in '../../../base/UFont.pas',
+  UUnicodeUtils in '../../../base/UUnicodeUtils.pas',
   math,
   sysutils;
 
@@ -41,7 +43,7 @@ const
   //FONT_FILE = 'C:/Windows/Fonts/Arial.ttf';
   //FONT_FILE = 'C:/Windows/Fonts/SimSun.ttf';
   //FONT_FILE = 'eurostarregularextended.ttf';
-  FONT_FILE = 'FreeSans.ttf';
+  FONT_FILE = '../../../../game/fonts/FreeSans/FreeSans.ttf';
   
 var
   OurFont: TScalableFont;
@@ -129,11 +131,11 @@ begin
   // Really Nice Perspective Calculations
   glHint( GL_PERSPECTIVE_CORRECTION_HINT, GL_NICEST );
 
-  //OurFont := TFTScalableFont.Create(FONT_FILE, 64);
+  OurFont := TFTScalableFont.Create(FONT_FILE, 64, 0.03);
   //OurFont := TFTFont.Create(FONT_FILE, 128);
-  OurFont := TFTScalableOutlineFont.Create(FONT_FILE, 64, 0.05);
+  //OurFont := TFTScalableOutlineFont.Create(FONT_FILE, 64, 0.03);
   //OurFont.UseKerning := false;
-  TFTScalableOutlineFont(OurFont).SetOutlineColor(1, 0, 0);
+  //TFTScalableOutlineFont(OurFont).SetOutlineColor(1, 0, 0, 1);
   //OurFont := TOutlineFont.Create(FONT_FILE, 32, 2);
   //OurFont.LineSpacing := OurFont.LineSpacing * 0.5;
 
@@ -183,7 +185,7 @@ begin
   //OurFont.SetOutlineColor(0.5, 0.5, 0.5);
   //OurFont.ReflectionSpacing := -4;
   //OurFont.UseKerning := false;
-  OurFont.Height := 64;//cnt2;
+  OurFont.Height := 150;//cnt2;
   //OurFont.Reset;
   //OurFont.Aspect := 2;
 
@@ -191,7 +193,7 @@ begin
   bounds := OurFont.BBox(msg);
   //glRectf(bounds.Left, OurFont.Ascender, bounds.Right, OurFont.Ascender-OurFont.Height);
 
-  glColor3f(1, 1, 1);
+  glColor4f(1, 1, 1, 1);
   //OurFont.ReflectionSpacing := 0;
   OurFont.Print(msg);
 
diff --git a/Lua/src/lib/freetype/demo/engine-test.lpi b/Lua/src/lib/freetype/demo/engine-test.lpi
index 6cbfe1eb..45483a56 100644
--- a/Lua/src/lib/freetype/demo/engine-test.lpi
+++ b/Lua/src/lib/freetype/demo/engine-test.lpi
@@ -28,14 +28,14 @@
       </local>
     </RunParams>
     <Units Count="16">
-      <Unit0>
-        <Filename Value="engine-test.dpr"/>
-        <IsPartOfProject Value="True"/>
-        <CursorPos X="25" Y="135"/>
-        <TopLine Value="118"/>
-        <EditorIndex Value="0"/>
-        <UsageCount Value="72"/>
-        <Loaded Value="True"/>
+      <Unit0>
+        <Filename Value="engine-test.dpr"/>
+        <IsPartOfProject Value="True"/>
+        <CursorPos X="18" Y="25"/>
+        <TopLine Value="1"/>
+        <EditorIndex Value="0"/>
+        <UsageCount Value="72"/>
+        <Loaded Value="True"/>
       </Unit0>
       <Unit1>
         <Filename Value="JEDI-SDL\OpenGL\Pas\opengl12.pas"/>
@@ -139,13 +139,22 @@
         <UnitName Value="UFont"/>
         <CursorPos X="15" Y="1752"/>
         <TopLine Value="1734"/>
-        <UsageCount Value="10"/>
-      </Unit15>
-    </Units>
-    <JumpHistory Count="0" HistoryIndex="-1"/>
-  </ProjectOptions>
-  <CompilerOptions>
-    <Version Value="8"/>
+        <UsageCount Value="10"/>
+      </Unit15>
+    </Units>
+    <JumpHistory Count="2" HistoryIndex="1">
+      <Position1>
+        <Filename Value="engine-test.dpr"/>
+        <Caret Line="52" Column="10" TopLine="37"/>
+      </Position1>
+      <Position2>
+        <Filename Value="engine-test.dpr"/>
+        <Caret Line="1" Column="1" TopLine="1"/>
+      </Position2>
+    </JumpHistory>
+  </ProjectOptions>
+  <CompilerOptions>
+    <Version Value="8"/>
     <PathDelim Value="\"/>
     <SearchPaths>
       <IncludeFiles Value="..\..\JEDI-SDL\SDL\Pas\"/>
diff --git a/Lua/src/lib/freetype/freetype.pas b/Lua/src/lib/freetype/freetype.pas
index 6a9d2062..6aaa3b59 100644
--- a/Lua/src/lib/freetype/freetype.pas
+++ b/Lua/src/lib/freetype/freetype.pas
@@ -1,23 +1,42 @@
-//----------------------------------------------------------------------------
-// FreeType2 pascal header
-//----------------------------------------------------------------------------
-// Anti-Grain Geometry - Version 2.4 (Public License)
-// Copyright (C) 2002-2005 Maxim Shemanarev (http://www.antigrain.com)
-//
-// Anti-Grain Geometry - Version 2.4 Release Milano 3 (AggPas 2.4 RM3)
-// Pascal Port By: Milan Marusinec alias Milano
-//                 milan@marusinec.sk
-//                 http://www.aggpas.org
-// Copyright (c) 2005-2007
-//
-// Permission to copy, use, modify, sell and distribute this software
-// is granted provided this copyright notice appears in all copies.
-// This software is provided "as is" without express or implied
-// warranty, and with no claim as to its suitability for any purpose.
-//
-//----------------------------------------------------------------------------
-// Adapted by the UltraStar Deluxe Team
-//----------------------------------------------------------------------------
+(***************************************************************************)
+(*                                                                         *)
+(*  freetype.h                                                             *)
+(*                                                                         *)
+(*    FreeType high-level API and common types (specification only).       *)
+(*                                                                         *)
+(*  Copyright 1996-2001, 2002, 2003, 2004, 2005, 2006, 2007 by             *)
+(*  David Turner, Robert Wilhelm, and Werner Lemberg.                      *)
+(*                                                                         *)
+(*  This file is part of the FreeType project, and may only be used,       *)
+(*  modified, and distributed under the terms of the FreeType project      *)
+(*  license, LICENSE.TXT.  By continuing to use, modify, or distribute     *)
+(*  this file you indicate that you have read the license and              *)
+(*  understand and accept it fully.                                        *)
+(*                                                                         *)
+(***************************************************************************)
+
+(***************************************************************************)
+(* Initial Pascal port by                                                  *)
+(***************************************************************************)
+(* Anti-Grain Geometry - Version 2.4 (Public License)                      *)
+(* Copyright (C) 2002-2005 Maxim Shemanarev (http://www.antigrain.com)     *)
+(*                                                                         *)
+(* Anti-Grain Geometry - Version 2.4 Release Milano 3 (AggPas 2.4 RM3)     *)
+(* Pascal Port By: Milan Marusinec alias Milano                            *)
+(*                 milan@marusinec.sk                                      *)
+(*                 http://www.aggpas.org                                   *)
+(* Copyright (c) 2005-2007                                                 *)
+(*                                                                         *)
+(* Permission to copy, use, modify, sell and distribute this software      *)
+(* is granted provided this copyright notice appears in all copies.        *)
+(* This software is provided "as is" without express or implied            *)
+(* warranty, and with no claim as to its suitability for any purpose.      *)
+(*                                                                         *)
+(***************************************************************************)
+
+(***************************************************************************)
+(* Extended by the UltraStar Deluxe Team                                   *)
+(***************************************************************************)
 
 unit freetype;
 
@@ -36,7 +55,7 @@ uses
 
 const
 {$IF Defined(MSWINDOWS)}
-  ft_lib = 'libfreetype-6.dll';
+  ft_lib = 'freetype6.dll';
 {$ELSEIF Defined(DARWIN)}
   ft_lib = 'libfreetype.dylib';
   {$LINKLIB libfreetype}
@@ -45,32 +64,24 @@ const
 {$IFEND}
 
 type
-  FT_Byte    = cuchar;
-  FT_Short   = csshort;
-  FT_UShort  = cushort;
-  FT_Int     = csint;
-  FT_UInt    = cuint;
-  FT_Int16   = cint16;
-  FT_UInt16  = cuint16;
-  FT_Int32   = cint32;
-  FT_UInt32  = cuint32;
-  FT_Long    = cslong;
-  FT_ULong   = culong;
-
-  FT_Fixed   = cslong;
-  FT_Pos     = cslong;
-  FT_Error   = cint;
-  FT_F26Dot6 = cslong;
-  FT_String  = cchar;
-  FT_Bool    = cuchar;
-
-  PFT_Byte   = ^FT_Byte;
-  PFT_Short  = ^FT_Short;
-  PFT_String = ^FT_String;
-
-
-  TByteArray = array [0 .. (MaxInt div SizeOf(byte))-1] of byte;
-  PByteArray = ^TByteArray;
+  (*************************************************************************)
+  (*                                                                       *)
+  (* <Type>                                                                *)
+  (*    FT_Library                                                         *)
+  (*                                                                       *)
+  (* <Description>                                                         *)
+  (*    A handle to a FreeType library instance.  Each `library' is        *)
+  (*    completely independent from the others; it is the `root' of a set  *)
+  (*    of objects like fonts, faces, sizes, etc.                          *)
+  (*                                                                       *)
+  (*    It also embeds a memory manager (see @FT_Memory), as well as a     *)
+  (*    scan-line converter object (see @FT_Raster).                       *)
+  (*                                                                       *)
+  (* <Note>                                                                *)
+  (*    Library objects are normally created by @FT_Init_FreeType, and     *)
+  (*    destroyed with @FT_Done_FreeType.                                  *)
+  (*                                                                       *)
+  FT_Library = Pointer;
 
 
   (*************************************************************************)
@@ -290,54 +301,6 @@ const
   FT_ENCODING_WANSUNG:   FT_Encoding = ('w', 'a', 'n', 's');
   FT_ENCODING_JOHAB:     FT_Encoding = ('j', 'o', 'h', 'a');
 
-  (*************************************************************************)
-  (*                                                                       *)
-  (* <Enum>                                                                *)
-  (*    FT_Glyph_Format                                                    *)
-  (*                                                                       *)
-  (* <Description>                                                         *)
-  (*    An enumeration type used to describe the format of a given glyph   *)
-  (*    image.  Note that this version of FreeType only supports two image *)
-  (*    formats, even though future font drivers will be able to register  *)
-  (*    their own format.                                                  *)
-  (*                                                                       *)
-  (* <Values>                                                              *)
-  (*    FT_GLYPH_FORMAT_NONE ::                                            *)
-  (*      The value 0 is reserved and does describe a glyph format.        *)
-  (*                                                                       *)
-  (*    FT_GLYPH_FORMAT_COMPOSITE ::                                       *)
-  (*      The glyph image is a composite of several other images.  This    *)
-  (*      format is _only_ used with @FT_LOAD_NO_RECURSE, and is used to   *)
-  (*      report compound glyphs (like accented characters).               *)
-  (*                                                                       *)
-  (*    FT_GLYPH_FORMAT_BITMAP ::                                          *)
-  (*      The glyph image is a bitmap, and can be described as an          *)
-  (*      @FT_Bitmap.  You generally need to access the `bitmap' field of  *)
-  (*      the @FT_GlyphSlotRec structure to read it.                       *)
-  (*                                                                       *)
-  (*    FT_GLYPH_FORMAT_OUTLINE ::                                         *)
-  (*      The glyph image is a vertorial outline made of line segments     *)
-  (*      and Bezier arcs; it can be described as an @FT_Outline; you      *)
-  (*      generally want to access the `outline' field of the              *)
-  (*      @FT_GlyphSlotRec structure to read it.                           *)
-  (*                                                                       *)
-  (*    FT_GLYPH_FORMAT_PLOTTER ::                                         *)
-  (*      The glyph image is a vectorial path with no inside/outside       *)
-  (*      contours.  Some Type 1 fonts, like those in the Hershey family,  *)
-  (*      contain glyphs in this format.  These are described as           *)
-  (*      @FT_Outline, but FreeType isn't currently capable of rendering   *)
-  (*      them correctly.                                                  *)
-  (*                                                                       *)
-type
-  FT_Glyph_Format = array[0..3] of char;
-const
-  FT_GLYPH_FORMAT_NONE:      FT_Glyph_Format = (#0, #0, #0, #0 );
-
-  FT_GLYPH_FORMAT_COMPOSITE: FT_Glyph_Format = ('c', 'o', 'm', 'p' );
-  FT_GLYPH_FORMAT_BITMAP:    FT_Glyph_Format = ('b', 'i', 't', 's' );
-  FT_GLYPH_FORMAT_OUTLINE:   FT_Glyph_Format = ('o', 'u', 't', 'l' );
-  FT_GLYPH_FORMAT_PLOTTER:   FT_Glyph_Format = ('p', 'l', 'o', 't' );
-
 
   (*************************************************************************)
   (*                                                                       *)
@@ -358,7 +321,7 @@ const
 const
   FT_STYLE_FLAG_ITALIC = 1 shl 0;
   FT_STYLE_FLAG_BOLD   = 1 shl 1;
-  
+
 
  (***************************************************************************
   *
@@ -567,7 +530,7 @@ const
   (*   perform this pass.                                                  *)
   (*                                                                       *)
 type
-  FT_Render_Mode = FT_Int;
+  FT_Render_Mode = cint;
 const
   FT_RENDER_MODE_NORMAL = 0;
   FT_RENDER_MODE_LIGHT  = FT_RENDER_MODE_NORMAL + 1;
@@ -579,63 +542,34 @@ const
 
   (*************************************************************************)
   (*                                                                       *)
-  (* <Enum>                                                                *)
-  (*    FT_Pixel_Mode                                                      *)
+  (* <Type>                                                                *)
+  (*    FT_GlyphSlot                                                       *)
   (*                                                                       *)
   (* <Description>                                                         *)
-  (*    An enumeration type used to describe the format of pixels in a     *)
-  (*    given bitmap.  Note that additional formats may be added in the    *)
-  (*    future.                                                            *)
+  (*    A handle to a given `glyph slot'.  A slot is a container where it  *)
+  (*    is possible to load any one of the glyphs contained in its parent  *)
+  (*    face.                                                              *)
   (*                                                                       *)
-  (* <Values>                                                              *)
-  (*    FT_PIXEL_MODE_NONE ::                                              *)
-  (*      Value 0 is reserved.                                             *)
-  (*                                                                       *)
-  (*    FT_PIXEL_MODE_MONO ::                                              *)
-  (*      A monochrome bitmap, using 1 bit per pixel.  Note that pixels    *)
-  (*      are stored in most-significant order (MSB), which means that     *)
-  (*      the left-most pixel in a byte has value 128.                     *)
-  (*                                                                       *)
-  (*    FT_PIXEL_MODE_GRAY ::                                              *)
-  (*      An 8-bit bitmap, generally used to represent anti-aliased glyph  *)
-  (*      images.  Each pixel is stored in one byte.  Note that the number *)
-  (*      of value `gray' levels is stored in the `num_bytes' field of     *)
-  (*      the @FT_Bitmap structure (it generally is 256).                  *)
-  (*                                                                       *)
-  (*    FT_PIXEL_MODE_GRAY2 ::                                             *)
-  (*      A 2-bit/pixel bitmap, used to represent embedded anti-aliased    *)
-  (*      bitmaps in font files according to the OpenType specification.   *)
-  (*      We haven't found a single font using this format, however.       *)
-  (*                                                                       *)
-  (*    FT_PIXEL_MODE_GRAY4 ::                                             *)
-  (*      A 4-bit/pixel bitmap, used to represent embedded anti-aliased    *)
-  (*      bitmaps in font files according to the OpenType specification.   *)
-  (*      We haven't found a single font using this format, however.       *)
-  (*                                                                       *)
-  (*    FT_PIXEL_MODE_LCD ::                                               *)
-  (*      An 8-bit bitmap, used to represent RGB or BGR decimated glyph    *)
-  (*      images used for display on LCD displays; the bitmap is three     *)
-  (*      times wider than the original glyph image.  See also             *)
-  (*      @FT_RENDER_MODE_LCD.                                             *)
-  (*                                                                       *)
-  (*    FT_PIXEL_MODE_LCD_V ::                                             *)
-  (*      An 8-bit bitmap, used to represent RGB or BGR decimated glyph    *)
-  (*      images used for display on rotated LCD displays; the bitmap      *)
-  (*      is three times taller than the original glyph image.  See also   *)
-  (*      @FT_RENDER_MODE_LCD_V.                                           *)
+  (*    In other words, each time you call @FT_Load_Glyph or               *)
+  (*    @FT_Load_Char, the slot's content is erased by the new glyph data, *)
+  (*    i.e. the glyph's metrics, its image (bitmap or outline), and       *)
+  (*    other control information.                                         *)
+  (*                                                                       *)
+  (* <Also>                                                                *)
+  (*    @FT_GlyphSlotRec details the publicly accessible glyph fields.     *)
   (*                                                                       *)
 type
-  FT_Pixel_Mode = byte;
-const
-  FT_PIXEL_MODE_NONE    = 0;
-  FT_PIXEL_MODE_MONO    = FT_PIXEL_MODE_NONE  + 1;
-  FT_PIXEL_MODE_GRAY    = FT_PIXEL_MODE_MONO  + 1;
-  FT_PIXEL_MODE_GRAY2   = FT_PIXEL_MODE_GRAY  + 1;
-  FT_PIXEL_MODE_GRAY4   = FT_PIXEL_MODE_GRAY2 + 1;
-  FT_PIXEL_MODE_LCD     = FT_PIXEL_MODE_GRAY4 + 1;
-  FT_PIXEL_MODE_LCD_V   = FT_PIXEL_MODE_LCD   + 1;
+  FT_GlyphSlot = ^FT_GlyphSlotRec;
 
-  FT_PIXEL_MODE_MAX     = FT_PIXEL_MODE_LCD_V + 1; (* do not remove *)
+
+{$DEFINE TYPE_DECL}
+{$I ftconfig.inc}
+{$I fttypes.inc}
+{$I ftimage.inc}
+{$I ftglyph.inc}
+{$I ftstroke.inc}
+{$I ftoutln.inc} 
+{$UNDEF TYPE_DECL}
 
 
   (*************************************************************************)
@@ -674,7 +608,6 @@ const
   (*    vertAdvance ::                                                     *)
   (*      Advance height for vertical layout.                              *)
   (*                                                                       *)
-type
   FT_Glyph_Metrics = record
     width  ,
     height       : FT_Pos;
@@ -759,140 +692,6 @@ type
 
   (*************************************************************************)
   (*                                                                       *)
-  (* <Struct>                                                              *)
-  (*    FT_Vector                                                          *)
-  (*                                                                       *)
-  (* <Description>                                                         *)
-  (*    A simple structure used to store a 2D vector; coordinates are of   *)
-  (*    the FT_Pos type.                                                   *)
-  (*                                                                       *)
-  (* <Fields>                                                              *)
-  (*    x :: The horizontal coordinate.                                    *)
-  (*    y :: The vertical coordinate.                                      *)
-  (*                                                                       *)
-  PFT_Vector = ^FT_Vector;
-  FT_Vector = record
-    x ,
-    y : FT_Pos;
-  end;
-
-
-  (*************************************************************************)
-  (*                                                                       *)
-  (* <Struct>                                                              *)
-  (*    FT_Outline                                                         *)
-  (*                                                                       *)
-  (* <Description>                                                         *)
-  (*    This structure is used to describe an outline to the scan-line     *)
-  (*    converter.                                                         *)
-  (*                                                                       *)
-  (* <Fields>                                                              *)
-  (*    n_contours :: The number of contours in the outline.               *)
-  (*                                                                       *)
-  (*    n_points   :: The number of points in the outline.                 *)
-  (*                                                                       *)
-  (*    points     :: A pointer to an array of `n_points' FT_Vector        *)
-  (*                  elements, giving the outline's point coordinates.    *)
-  (*                                                                       *)
-  (*    tags       :: A pointer to an array of `n_points' chars, giving    *)
-  (*                  each outline point's type.  If bit 0 is unset, the   *)
-  (*                  point is `off' the curve, i.e. a Bezier control      *)
-  (*                  point, while it is `on' when set.                    *)
-  (*                                                                       *)
-  (*                  Bit 1 is meaningful for `off' points only.  If set,  *)
-  (*                  it indicates a third-order Bezier arc control point; *)
-  (*                  and a second-order control point if unset.           *)
-  (*                                                                       *)
-  (*    contours   :: An array of `n_contours' shorts, giving the end      *)
-  (*                  point of each contour within the outline.  For       *)
-  (*                  example, the first contour is defined by the points  *)
-  (*                  `0' to `contours[0]', the second one is defined by   *)
-  (*                  the points `contours[0]+1' to `contours[1]', etc.    *)
-  (*                                                                       *)
-  (*    flags      :: A set of bit flags used to characterize the outline  *)
-  (*                  and give hints to the scan-converter and hinter on   *)
-  (*                  how to convert/grid-fit it.  See FT_Outline_Flags.   *)
-  (*                                                                       *)
-  PFT_Outline = ^FT_Outline;
-  FT_Outline = record
-    n_contours : FT_Short;
-    n_points   : FT_Short;
-
-    points : PFT_Vector;
-    tags   : PChar;
-    contours : PFT_Short;
-
-    flags    : FT_Int;
-  end;
-
-
-  (*************************************************************************)
-  (*                                                                       *)
-  (* <Struct>                                                              *)
-  (*    FT_Bitmap                                                          *)
-  (*                                                                       *)
-  (* <Description>                                                         *)
-  (*    A structure used to describe a bitmap or pixmap to the raster.     *)
-  (*    Note that we now manage pixmaps of various depths through the      *)
-  (*    `pixel_mode' field.                                                *)
-  (*                                                                       *)
-  (* <Fields>                                                              *)
-  (*    rows         :: The number of bitmap rows.                         *)
-  (*                                                                       *)
-  (*    width        :: The number of pixels in bitmap row.                *)
-  (*                                                                       *)
-  (*    pitch        :: The pitch's absolute value is the number of bytes  *)
-  (*                    taken by one bitmap row, including padding.        *)
-  (*                    However, the pitch is positive when the bitmap has *)
-  (*                    a `down' flow, and negative when it has an `up'    *)
-  (*                    flow.  In all cases, the pitch is an offset to add *)
-  (*                    to a bitmap pointer in order to go down one row.   *)
-  (*                                                                       *)
-  (*    buffer       :: A typeless pointer to the bitmap buffer.  This     *)
-  (*                    value should be aligned on 32-bit boundaries in    *)
-  (*                    most cases.                                        *)
-  (*                                                                       *)
-  (*    num_grays    :: This field is only used with                       *)
-  (*                    `FT_PIXEL_MODE_GRAY'; it gives the number of gray  *)
-  (*                    levels used in the bitmap.                         *)
-  (*                                                                       *)
-  (*    pixel_mode   :: The pixel mode, i.e., how pixel bits are stored.   *)
-  (*                    See @FT_Pixel_Mode for possible values.            *)
-  (*                                                                       *)
-  (*    palette_mode :: This field is only used with paletted pixel modes; *)
-  (*                    it indicates how the palette is stored.            *)
-  (*                                                                       *)
-  (*    palette      :: A typeless pointer to the bitmap palette; only     *)
-  (*                    used for paletted pixel modes.                     *)
-  (*                                                                       *)
-  (* <Note>                                                                *)
-  (*   For now, the only pixel mode supported by FreeType are mono and     *)
-  (*   grays.  However, drivers might be added in the future to support    *)
-  (*   more `colorful' options.                                            *)
-  (*                                                                       *)
-  (*   When using pixel modes pal2, pal4 and pal8 with a void `palette'    *)
-  (*   field, a gray pixmap with respectively 4, 16, and 256 levels of     *)
-  (*   gray is assumed.  This, in order to be compatible with some         *)
-  (*   embedded bitmap formats defined in the TrueType specification.      *)
-  (*                                                                       *)
-  (*   Note that no font was found presenting such embedded bitmaps, so    *)
-  (*   this is currently completely unhandled by the library.              *)
-  (*                                                                       *)
-  PFT_Bitmap = ^FT_Bitmap;
-  FT_Bitmap = record
-    rows   ,
-    width  : FT_Int;
-    pitch  : FT_Int;
-    buffer : PByteArray;
-    num_grays    : FT_Short;
-    pixel_mode   ,
-    palette_mode : byte;
-    palette : pointer;
-  end;
-
-
-  (*************************************************************************)
-  (*                                                                       *)
   (* <Type>                                                                *)
   (*    FT_Face                                                            *)
   (*                                                                       *)
@@ -950,184 +749,11 @@ type
   PAFT_CharMap = ^FT_CharMap;
   AFT_CharMap = array[0..High(Word)] of FT_CharMap;
 
-  (*************************************************************************)
-  (*                                                                       *)
-  (* <Type>                                                                *)
-  (*    FT_Library                                                         *)
-  (*                                                                       *)
-  (* <Description>                                                         *)
-  (*    A handle to a FreeType library instance.  Each `library' is        *)
-  (*    completely independent from the others; it is the `root' of a set  *)
-  (*    of objects like fonts, faces, sizes, etc.                          *)
-  (*                                                                       *)
-  (*    It also embeds a memory manager (see @FT_Memory), as well as a     *)
-  (*    scan-line converter object (see @FT_Raster).                       *)
-  (*                                                                       *)
-  (* <Note>                                                                *)
-  (*    Library objects are normally created by @FT_Init_FreeType, and     *)
-  (*    destroyed with @FT_Done_FreeType.                                  *)
-  (*                                                                       *)
-  FT_Library = ^FT_LibraryRec;
-  FT_LibraryRec = record // internal
-  end;
 
-  (*************************************************************************)
-  (*                                                                       *)
-  (* <Section>                                                             *)
-  (*    glyph_management                                                   *)
-  (*                                                                       *)
-  (* <Title>                                                               *)
-  (*    Glyph Management                                                   *)
-  (*                                                                       *)
-  (* <Abstract>                                                            *)
-  (*    Generic interface to manage individual glyph data.                 *)
-  (*                                                                       *)
-  (* <Description>                                                         *)
-  (*    This section contains definitions used to manage glyph data        *)
-  (*    through generic FT_Glyph objects.  Each of them can contain a      *)
-  (*    bitmap, a vector outline, or even images in other formats.         *)
-  (*                                                                       *)
-  (*************************************************************************)
 
-  (* forward declaration to a private type *)
-  PFT_Glyph_Class = ^FT_Glyph_Class;
-  FT_Glyph_Class = record // internal
-  end;
 
-  (*************************************************************************)
-  (*                                                                       *)
-  (* <Type>                                                                *)
-  (*    FT_Glyph                                                           *)
-  (*                                                                       *)
-  (* <Description>                                                         *)
-  (*    Handle to an object used to model generic glyph images.  It is a   *)
-  (*    pointer to the @FT_GlyphRec structure and can contain a glyph      *)
-  (*    bitmap or pointer.                                                 *)
-  (*                                                                       *)
-  (* <Note>                                                                *)
-  (*    Glyph objects are not owned by the library.  You must thus release *)
-  (*    them manually (through @FT_Done_Glyph) _before_ calling            *)
-  (*    @FT_Done_FreeType.                                                 *)
-  (*                                                                       *)
-  FT_Glyph = ^FT_GlyphRec;
-
-  (*************************************************************************)
-  (*                                                                       *)
-  (* <Struct>                                                              *)
-  (*    FT_GlyphRec                                                        *)
-  (*                                                                       *)
-  (* <Description>                                                         *)
-  (*    The root glyph structure contains a given glyph image plus its     *)
-  (*    advance width in 16.16 fixed float format.                         *)
-  (*                                                                       *)
-  (* <Fields>                                                              *)
-  (*    library :: A handle to the FreeType library object.                *)
-  (*                                                                       *)
-  (*    clazz   :: A pointer to the glyph's class.  Private.               *)
-  (*                                                                       *)
-  (*    format  :: The format of the glyph's image.                        *)
-  (*                                                                       *)
-  (*    advance :: A 16.16 vector that gives the glyph's advance width.    *)
-  (*                                                                       *)
-  FT_GlyphRec = record
-    library_: FT_Library;
-    clazz:    PFT_Glyph_Class;
-    format:   FT_Glyph_Format;
-    advance:  FT_Vector;
-  end;
-
-
-  (*************************************************************************)
-  (*                                                                       *)
-  (* <Type>                                                                *)
-  (*    FT_BitmapGlyph                                                     *)
-  (*                                                                       *)
-  (* <Description>                                                         *)
-  (*    A handle to an object used to model a bitmap glyph image.  This is *)
-  (*    a sub-class of @FT_Glyph, and a pointer to @FT_BitmapGlyphRec.     *)
-  (*                                                                       *)
-  FT_BitmapGlyph = ^FT_BitmapGlyphRec;
-
-  (*************************************************************************)
-  (*                                                                       *)
-  (* <Struct>                                                              *)
-  (*    FT_BitmapGlyphRec                                                  *)
-  (*                                                                       *)
-  (* <Description>                                                         *)
-  (*    A structure used for bitmap glyph images.  This really is a        *)
-  (*    `sub-class' of `FT_GlyphRec'.                                      *)
-  (*                                                                       *)
-  (* <Fields>                                                              *)
-  (*    root   :: The root FT_Glyph fields.                                *)
-  (*                                                                       *)
-  (*    left   :: The left-side bearing, i.e., the horizontal distance     *)
-  (*              from the current pen position to the left border of the  *)
-  (*              glyph bitmap.                                            *)
-  (*                                                                       *)
-  (*    top    :: The top-side bearing, i.e., the vertical distance from   *)
-  (*              the current pen position to the top border of the glyph  *)
-  (*              bitmap.  This distance is positive for upwards-y!        *)
-  (*                                                                       *)
-  (*    bitmap :: A descriptor for the bitmap.                             *)
-  (*                                                                       *)
-  (* <Note>                                                                *)
-  (*    You can typecast FT_Glyph to FT_BitmapGlyph if you have            *)
-  (*    glyph->format == FT_GLYPH_FORMAT_BITMAP.  This lets you access     *)
-  (*    the bitmap's contents easily.                                      *)
-  (*                                                                       *)
-  (*    The corresponding pixel buffer is always owned by the BitmapGlyph  *)
-  (*    and is thus created and destroyed with it.                         *)
-  (*                                                                       *)
-  FT_BitmapGlyphRec = record
-    root:   FT_GlyphRec;
-    left:   FT_Int;
-    top:    FT_Int;
-    bitmap: FT_Bitmap;
-  end;
 
 
-  (*************************************************************************)
-  (*                                                                       *)
-  (* <Type>                                                                *)
-  (*    FT_OutlineGlyph                                                    *)
-  (*                                                                       *)
-  (* <Description>                                                         *)
-  (*    A handle to an object used to model an outline glyph image.  This  *)
-  (*    is a sub-class of @FT_Glyph, and a pointer to @FT_OutlineGlyphRec. *)
-  (*                                                                       *)
-  FT_OutlineGlyph = ^FT_OutlineGlyphRec;
-
-  (*************************************************************************)
-  (*                                                                       *)
-  (* <Struct>                                                              *)
-  (*    FT_OutlineGlyphRec                                                 *)
-  (*                                                                       *)
-  (* <Description>                                                         *)
-  (*    A structure used for outline (vectorial) glyph images.  This       *)
-  (*    really is a `sub-class' of `FT_GlyphRec'.                          *)
-  (*                                                                       *)
-  (* <Fields>                                                              *)
-  (*    root    :: The root FT_Glyph fields.                               *)
-  (*                                                                       *)
-  (*    outline :: A descriptor for the outline.                           *)
-  (*                                                                       *)
-  (* <Note>                                                                *)
-  (*    You can typecast FT_Glyph to FT_OutlineGlyph if you have           *)
-  (*    glyph->format == FT_GLYPH_FORMAT_OUTLINE.  This lets you access    *)
-  (*    the outline's content easily.                                      *)
-  (*                                                                       *)
-  (*    As the outline is extracted from a glyph slot, its coordinates are *)
-  (*    expressed normally in 26.6 pixels, unless the flag                 *)
-  (*    FT_LOAD_NO_SCALE was used in FT_Load_Glyph() or FT_Load_Char().    *)
-  (*                                                                       *)
-  (*    The outline's tables are always owned by the object and are        *)
-  (*    destroyed with it.                                                 *)
-  (*                                                                       *)
-  FT_OutlineGlyphRec = record
-    root:    FT_GlyphRec;
-    outline: FT_Outline;
-  end;
-
 
   (*************************************************************************)
   (*                                                                       *)
@@ -1149,101 +775,6 @@ type
 
   (*************************************************************************)
   (*                                                                       *)
-  (* <FuncType>                                                            *)
-  (*    FT_Generic_Finalizer                                               *)
-  (*                                                                       *)
-  (* <Description>                                                         *)
-  (*    Describes a function used to destroy the `client' data of any      *)
-  (*    FreeType object.  See the description of the FT_Generic type for   *)
-  (*    details of usage.                                                  *)
-  (*                                                                       *)
-  (* <Input>                                                               *)
-  (*    The address of the FreeType object which is under finalization.    *)
-  (*    Its client data is accessed through its `generic' field.           *)
-  (*                                                                       *)
-  FT_Generic_Finalizer = procedure(AnObject : pointer ); cdecl;
-
-  (*************************************************************************)
-  (*                                                                       *)
-  (* <Struct>                                                              *)
-  (*    FT_Generic                                                         *)
-  (*                                                                       *)
-  (* <Description>                                                         *)
-  (*    Client applications often need to associate their own data to a    *)
-  (*    variety of FreeType core objects.  For example, a text layout API  *)
-  (*    might want to associate a glyph cache to a given size object.      *)
-  (*                                                                       *)
-  (*    Most FreeType object contains a `generic' field, of type           *)
-  (*    FT_Generic, which usage is left to client applications and font    *)
-  (*    servers.                                                           *)
-  (*                                                                       *)
-  (*    It can be used to store a pointer to client-specific data, as well *)
-  (*    as the address of a `finalizer' function, which will be called by  *)
-  (*    FreeType when the object is destroyed (for example, the previous   *)
-  (*    client example would put the address of the glyph cache destructor *)
-  (*    in the `finalizer' field).                                         *)
-  (*                                                                       *)
-  (* <Fields>                                                              *)
-  (*    data      :: A typeless pointer to any client-specified data. This *)
-  (*                 field is completely ignored by the FreeType library.  *)
-  (*                                                                       *)
-  (*    finalizer :: A pointer to a `generic finalizer' function, which    *)
-  (*                 will be called when the object is destroyed.  If this *)
-  (*                 field is set to NULL, no code will be called.         *)
-  (*                                                                       *)
-  FT_Generic = record
-    data      : pointer;
-    finalizer : FT_Generic_Finalizer;
-  end;
-
-  (*************************************************************************)
-  (*                                                                       *)
-  (* <Struct>                                                              *)
-  (*    FT_BBox                                                            *)
-  (*                                                                       *)
-  (* <Description>                                                         *)
-  (*    A structure used to hold an outline's bounding box, i.e., the      *)
-  (*    coordinates of its extrema in the horizontal and vertical          *)
-  (*    directions.                                                        *)
-  (*                                                                       *)
-  (* <Fields>                                                              *)
-  (*    xMin :: The horizontal minimum (left-most).                        *)
-  (*                                                                       *)
-  (*    yMin :: The vertical minimum (bottom-most).                        *)
-  (*                                                                       *)
-  (*    xMax :: The horizontal maximum (right-most).                       *)
-  (*                                                                       *)
-  (*    yMax :: The vertical maximum (top-most).                           *)
-  (*                                                                       *)
-  PFT_BBox = ^FT_BBox;
-  FT_BBox = record
-    xMin, yMin : FT_Pos;
-    xMax, yMax : FT_Pos;
-  end;
-
-
-  (*************************************************************************)
-  (*                                                                       *)
-  (* <Type>                                                                *)
-  (*    FT_GlyphSlot                                                       *)
-  (*                                                                       *)
-  (* <Description>                                                         *)
-  (*    A handle to a given `glyph slot'.  A slot is a container where it  *)
-  (*    is possible to load any one of the glyphs contained in its parent  *)
-  (*    face.                                                              *)
-  (*                                                                       *)
-  (*    In other words, each time you call @FT_Load_Glyph or               *)
-  (*    @FT_Load_Char, the slot's content is erased by the new glyph data, *)
-  (*    i.e. the glyph's metrics, its image (bitmap or outline), and       *)
-  (*    other control information.                                         *)
-  (*                                                                       *)
-  (* <Also>                                                                *)
-  (*    @FT_GlyphSlotRec details the publicly accessible glyph fields.     *)
-  (*                                                                       *)
-  FT_GlyphSlot = ^FT_GlyphSlotRec;
-
-  (*************************************************************************)
-  (*                                                                       *)
   (* <Struct>                                                              *)
   (*    FT_GlyphSlotRec                                                    *)
   (*                                                                       *)
@@ -1432,7 +963,7 @@ type
     subglyphs     : FT_SubGlyph;
     
     control_data  : pointer;
-    control_len   : longint;
+    control_len   : clong;
 
     lsb_delta: FT_Pos;
     rsb_delta: FT_Pos;
@@ -1497,15 +1028,15 @@ type
   (*    computations.                                                      *)
   (*                                                                       *)
   FT_Size_Metrics = record
-    x_ppem  ,
-    y_ppem  : FT_UShort;
-    x_scale ,
-    y_scale : FT_Fixed;
-
-    ascender    ,
-    descender   : FT_Pos;
-    height      : FT_Pos;
-    max_advance : FT_Pos;
+    x_ppem,                   (* horizontal pixels per EM               *)
+    y_ppem:      FT_UShort;   (* vertical pixels per EM                 *)
+    x_scale,                  (* scaling values used to convert font    *)
+    y_scale:     FT_Fixed;    (* units to 26.6 fractional pixels        *)
+
+    ascender,                 (* ascender in 26.6 frac. pixels          *)
+    descender:   FT_Pos;      (* descender in 26.6 frac. pixels         *)
+    height:      FT_Pos;      (* text height in 26.6 frac. pixels       *)
+    max_advance: FT_Pos;      (* max horizontal advance, in 26.6 pixels *)
   end;
 
   (*************************************************************************)
@@ -1786,21 +1317,29 @@ type
     encoding_id : FT_UShort;
   end;
 
+
+{$I ftconfig.inc}
+{$I fttypes.inc}
+{$I ftimage.inc}
+{$I ftglyph.inc}
+{$I ftstroke.inc}
+{$I ftoutln.inc} 
+
+
 { GLOBAL PROCEDURES }
 
   (*************************************************************************)
   (*                                                                       *)
   (* @macro:                                                               *)
-  (*    FT_CURVE_TAG  ( flag )                                             *)
+  (*    FT_HAS_KERNING( face )                                             *)
   (*                                                                       *)
-  function  FT_CURVE_TAG(flag: byte): byte;
-
-const
-  FT_CURVE_TAG_ON    = 1;
-  FT_CURVE_TAG_CONIC = 0;
-  FT_CURVE_TAG_CUBIC = 2;
-
+  (* @description:                                                         *)
+  (*    A macro that returns true whenever a face object contains kerning  *)
+  (*    data that can be accessed with @FT_Get_Kerning.                    *)
+  (*                                                                       *)
+  function  FT_HAS_KERNING(face : FT_Face ) : cbool;
 
+  
   (*************************************************************************)
   (*                                                                       *)
   (* @macro:                                                               *)
@@ -1813,16 +1352,6 @@ const
   (*                                                                       *)
   function  FT_IS_SCALABLE(face : FT_Face ) : cbool;
 
-  (*************************************************************************)
-  (*                                                                       *)
-  (* @macro:                                                               *)
-  (*    FT_HAS_KERNING( face )                                             *)
-  (*                                                                       *)
-  (* @description:                                                         *)
-  (*    A macro that returns true whenever a face object contains kerning  *)
-  (*    data that can be accessed with @FT_Get_Kerning.                    *)
-  (*                                                                       *)
-  function  FT_HAS_KERNING(face : FT_Face ) : cbool;
 
   (*************************************************************************)
   (*                                                                       *)
@@ -2284,216 +1813,12 @@ const
             pixel_height : FT_UInt ) : FT_Error;
     cdecl; external ft_lib name 'FT_Set_Pixel_Sizes';
 
-  (*************************************************************************)
-  (*                                                                       *)
-  (* <Function>                                                            *)
-  (*    FT_Get_Glyph                                                       *)
-  (*                                                                       *)
-  (* <Description>                                                         *)
-  (*    A function used to extract a glyph image from a slot.              *)
-  (*                                                                       *)
-  (* <Input>                                                               *)
-  (*    slot   :: A handle to the source glyph slot.                       *)
-  (*                                                                       *)
-  (* <Output>                                                              *)
-  (*    aglyph :: A handle to the glyph object.                            *)
-  (*                                                                       *)
-  (* <Return>                                                              *)
-  (*    FreeType error code.  0 means success.                             *)
-  (*                                                                       *)
-  function FT_Get_Glyph(
-             slot:   FT_GlyphSlot;
-             out aglyph: FT_Glyph ): FT_Error;
-    cdecl; external ft_lib name 'FT_Get_Glyph';
-
-  (*************************************************************************)
-  (*                                                                       *)
-  (* <Enum>                                                                *)
-  (*    FT_Glyph_BBox_Mode                                                 *)
-  (*                                                                       *)
-  (* <Description>                                                         *)
-  (*    The mode how the values of @FT_Glyph_Get_CBox are returned.        *)
-  (*                                                                       *)
-  (* <Values>                                                              *)
-  (*    FT_GLYPH_BBOX_UNSCALED ::                                          *)
-  (*      Return unscaled font units.                                      *)
-  (*                                                                       *)
-  (*    FT_GLYPH_BBOX_SUBPIXELS ::                                         *)
-  (*      Return unfitted 26.6 coordinates.                                *)
-  (*                                                                       *)
-  (*    FT_GLYPH_BBOX_GRIDFIT ::                                           *)
-  (*      Return grid-fitted 26.6 coordinates.                             *)
-  (*                                                                       *)
-  (*    FT_GLYPH_BBOX_TRUNCATE ::                                          *)
-  (*      Return coordinates in integer pixels.                            *)
-  (*                                                                       *)
-  (*    FT_GLYPH_BBOX_PIXELS ::                                            *)
-  (*      Return grid-fitted pixel coordinates.                            *)
-  (*                                                                       *)
-type
-  FT_Glyph_BBox_Mode = FT_UInt;
 const
-  FT_GLYPH_BBOX_UNSCALED  = 0;
-  FT_GLYPH_BBOX_SUBPIXELS = 0;
-  FT_GLYPH_BBOX_GRIDFIT   = 1;
-  FT_GLYPH_BBOX_TRUNCATE  = 2;
-  FT_GLYPH_BBOX_PIXELS    = 3;
-
-  (*************************************************************************)
-  (*                                                                       *)
-  (* <Function>                                                            *)
-  (*    FT_Glyph_Get_CBox                                                  *)
-  (*                                                                       *)
-  (* <Description>                                                         *)
-  (*    Return a glyph's `control box'.  The control box encloses all the  *)
-  (*    outline's points, including B�zier control points.  Though it      *)
-  (*    coincides with the exact bounding box for most glyphs, it can be   *)
-  (*    slightly larger in some situations (like when rotating an outline  *)
-  (*    which contains B�zier outside arcs).                               *)
-  (*                                                                       *)
-  (*    Computing the control box is very fast, while getting the bounding *)
-  (*    box can take much more time as it needs to walk over all segments  *)
-  (*    and arcs in the outline.  To get the latter, you can use the       *)
-  (*    `ftbbox' component which is dedicated to this single task.         *)
-  (*                                                                       *)
-  (* <Input>                                                               *)
-  (*    glyph :: A handle to the source glyph object.                      *)
-  (*                                                                       *)
-  (*    mode  :: The mode which indicates how to interpret the returned    *)
-  (*             bounding box values.                                      *)
-  (*                                                                       *)
-  (* <Output>                                                              *)
-  (*    acbox :: The glyph coordinate bounding box.  Coordinates are       *)
-  (*             expressed in 1/64th of pixels if it is grid-fitted.       *)
-  (*                                                                       *)
-  (* <Note>                                                                *)
-  (*    Coordinates are relative to the glyph origin, using the Y-upwards  *)
-  (*    convention.                                                        *)
-  (*                                                                       *)
-  (*    If the glyph has been loaded with @FT_LOAD_NO_SCALE, `bbox_mode'   *)
-  (*    must be set to @FT_GLYPH_BBOX_UNSCALED to get unscaled font        *)
-  (*    units in 26.6 pixel format.  The value @FT_GLYPH_BBOX_SUBPIXELS    *)
-  (*    is another name for this constant.                                 *)
-  (*                                                                       *)
-  (*    Note that the maximum coordinates are exclusive, which means that  *)
-  (*    one can compute the width and height of the glyph image (be it in  *)
-  (*    integer or 26.6 pixels) as:                                        *)
-  (*                                                                       *)
-  (*    {                                                                  *)
-  (*      width  = bbox.xMax - bbox.xMin;                                  *)
-  (*      height = bbox.yMax - bbox.yMin;                                  *)
-  (*    }                                                                  *)
-  (*                                                                       *)
-  (*    Note also that for 26.6 coordinates, if `bbox_mode' is set to      *)
-  (*    @FT_GLYPH_BBOX_GRIDFIT, the coordinates will also be grid-fitted,  *)
-  (*    which corresponds to:                                              *)
-  (*                                                                       *)
-  (*    {                                                                  *)
-  (*      bbox.xMin = FLOOR(bbox.xMin);                                    *)
-  (*      bbox.yMin = FLOOR(bbox.yMin);                                    *)
-  (*      bbox.xMax = CEILING(bbox.xMax);                                  *)
-  (*      bbox.yMax = CEILING(bbox.yMax);                                  *)
-  (*    }                                                                  *)
-  (*                                                                       *)
-  (*    To get the bbox in pixel coordinates, set `bbox_mode' to           *)
-  (*    @FT_GLYPH_BBOX_TRUNCATE.                                           *)
-  (*                                                                       *)
-  (*    To get the bbox in grid-fitted pixel coordinates, set `bbox_mode'  *)
-  (*    to @FT_GLYPH_BBOX_PIXELS.                                          *)
-  (*                                                                       *)
-  procedure FT_Glyph_Get_CBox( glyph: FT_Glyph;
-                     bbox_mode: FT_UInt;
-                     out acbox: FT_BBox );
-    cdecl; external ft_lib name 'FT_Glyph_Get_CBox';
-
-  (*************************************************************************)
-  (*                                                                       *)
-  (* <Function>                                                            *)
-  (*    FT_Glyph_To_Bitmap                                                 *)
-  (*                                                                       *)
-  (* <Description>                                                         *)
-  (*    Converts a given glyph object to a bitmap glyph object.            *)
-  (*                                                                       *)
-  (* <InOut>                                                               *)
-  (*    the_glyph   :: A pointer to a handle to the target glyph.          *)
-  (*                                                                       *)
-  (* <Input>                                                               *)
-  (*    render_mode :: An enumeration that describe how the data is        *)
-  (*                   rendered.                                           *)
-  (*                                                                       *)
-  (*    origin      :: A pointer to a vector used to translate the glyph   *)
-  (*                   image before rendering.  Can be 0 (if no            *)
-  (*                   translation).  The origin is expressed in           *)
-  (*                   26.6 pixels.                                        *)
-  (*                                                                       *)
-  (*    destroy     :: A boolean that indicates that the original glyph    *)
-  (*                   image should be destroyed by this function.  It is  *)
-  (*                   never destroyed in case of error.                   *)
-  (*                                                                       *)
-  (* <Return>                                                              *)
-  (*    FreeType error code.  0 means success.                             *)
-  (*                                                                       *)
-  (* <Note>                                                                *)
-  (*    The glyph image is translated with the `origin' vector before      *)
-  (*    rendering.                                                         *)
-  (*                                                                       *)
-  (*    The first parameter is a pointer to a FT_Glyph handle, that will   *)
-  (*    be replaced by this function.  Typically, you would use (omitting  *)
-  (*    error handling):                                                   *)
-  (*                                                                       *)
-  (*                                                                       *)
-  (*      {                                                                *)
-  (*        FT_Glyph        glyph;                                         *)
-  (*        FT_BitmapGlyph  glyph_bitmap;                                  *)
-  (*                                                                       *)
-  (*                                                                       *)
-  (*        // load glyph                                                  *)
-  (*        error = FT_Load_Char( face, glyph_index, FT_LOAD_DEFAUT );     *)
-  (*                                                                       *)
-  (*        // extract glyph image                                         *)
-  (*        error = FT_Get_Glyph( face->glyph, &glyph );                   *)
-  (*                                                                       *)
-  (*        // convert to a bitmap (default render mode + destroy old)     *)
-  (*        if ( glyph->format != FT_GLYPH_FORMAT_BITMAP )                 *)
-  (*        {                                                              *)
-  (*          error = FT_Glyph_To_Bitmap( &glyph, FT_RENDER_MODE_DEFAULT,  *)
-  (*                                      0, 1 );                          *)
-  (*          if ( error ) // glyph unchanged                              *)
-  (*            ...                                                        *)
-  (*        }                                                              *)
-  (*                                                                       *)
-  (*        // access bitmap content by typecasting                        *)
-  (*        glyph_bitmap = (FT_BitmapGlyph)glyph;                          *)
-  (*                                                                       *)
-  (*        // do funny stuff with it, like blitting/drawing               *)
-  (*        ...                                                            *)
-  (*                                                                       *)
-  (*        // discard glyph image (bitmap or not)                         *)
-  (*        FT_Done_Glyph( glyph );                                        *)
-  (*      }                                                                *)
-  (*                                                                       *)
-  (*                                                                       *)
-  (*    This function does nothing if the glyph format isn't scalable.     *)
-  (*                                                                       *)
-  function FT_Glyph_To_Bitmap(var the_glyph: FT_Glyph;
-                      render_mode: FT_Render_Mode;
-                      origin:      PFT_Vector;
-                      destroy:     FT_Bool ): FT_Error;
-    cdecl; external ft_lib name 'FT_Glyph_To_Bitmap';
+  FT_ANGLE_PI  = 180 shl 16;
+  FT_ANGLE_2PI = FT_ANGLE_PI * 2;
+  FT_ANGLE_PI2 = FT_ANGLE_PI div 2;
+  FT_ANGLE_PI4 = FT_ANGLE_PI div 4;
 
-  (*************************************************************************)
-  (*                                                                       *)
-  (* <Function>                                                            *)
-  (*    FT_Done_Glyph                                                      *)
-  (*                                                                       *)
-  (* <Description>                                                         *)
-  (*    Destroys a given glyph.                                            *)
-  (*                                                                       *)
-  (* <Input>                                                               *)
-  (*    glyph :: A handle to the target glyph object.                      *)
-  (*                                                                       *)
-  procedure FT_Done_Glyph( glyph: FT_Glyph );
-    cdecl; external ft_lib name 'FT_Done_Glyph';
 
 implementation
 
@@ -2504,17 +1829,17 @@ begin
   result := flag and 3;
 end;
 
-{ FT_IS_SCALABLE }
-function FT_IS_SCALABLE(face : FT_Face ) : cbool;
-begin
-  result := cbool(face.face_flags and FT_FACE_FLAG_SCALABLE );
-end;
-
 { FT_HAS_KERNING }
 function FT_HAS_KERNING(face : FT_Face ) : cbool;
 begin
   result := cbool(face.face_flags and FT_FACE_FLAG_KERNING );
 end;
 
+{ FT_IS_SCALABLE }
+function FT_IS_SCALABLE(face : FT_Face ) : cbool;
+begin
+  result := cbool(face.face_flags and FT_FACE_FLAG_SCALABLE );
+end;
+
 end.
 
diff --git a/Lua/src/lib/freetype/ftconfig.inc b/Lua/src/lib/freetype/ftconfig.inc
new file mode 100644
index 00000000..100fb2e0
--- /dev/null
+++ b/Lua/src/lib/freetype/ftconfig.inc
@@ -0,0 +1,35 @@
+(***************************************************************************)
+(*                                                                         *)
+(*  ftconfig.h                                                             *)
+(*                                                                         *)
+(*    ANSI-specific configuration file (specification only).               *)
+(*                                                                         *)
+(*  Copyright 1996-2001, 2002, 2003, 2004, 2006, 2007 by                   *)
+(*  David Turner, Robert Wilhelm, and Werner Lemberg.                      *)
+(*                                                                         *)
+(*  This file is part of the FreeType project, and may only be used,       *)
+(*  modified, and distributed under the terms of the FreeType project      *)
+(*  license, LICENSE.TXT.  By continuing to use, modify, or distribute     *)
+(*  this file you indicate that you have read the license and              *)
+(*  understand and accept it fully.                                        *)
+(*                                                                         *)
+(***************************************************************************)
+(***************************************************************************)
+(* Pascal port by the UltraStar Deluxe Team                                *)
+(***************************************************************************)
+
+{$IFDEF TYPE_DECL}
+
+  (*************************************************************************)
+  (*                                                                       *)
+  (* IntN types                                                            *)
+  (*                                                                       *)
+  (*   Used to guarantee the size of some specific integers.               *)
+  (*                                                                       *)
+  FT_Int16   = cint16;
+  FT_UInt16  = cuint16;
+  FT_Int32   = cint32;
+  FT_UInt32  = cuint32;
+
+{$ENDIF TYPE_DECL}
+
diff --git a/Lua/src/lib/freetype/ftglyph.inc b/Lua/src/lib/freetype/ftglyph.inc
new file mode 100644
index 00000000..0d4acc99
--- /dev/null
+++ b/Lua/src/lib/freetype/ftglyph.inc
@@ -0,0 +1,435 @@
+(***************************************************************************)
+(*                                                                         *)
+(*  ftglyph.h                                                              *)
+(*                                                                         *)
+(*    FreeType convenience functions to handle glyphs (specification).     *)
+(*                                                                         *)
+(*  Copyright 1996-2001, 2002, 2003, 2006 by                               *)
+(*  David Turner, Robert Wilhelm, and Werner Lemberg.                      *)
+(*                                                                         *)
+(*  This file is part of the FreeType project, and may only be used,       *)
+(*  modified, and distributed under the terms of the FreeType project      *)
+(*  license, LICENSE.TXT.  By continuing to use, modify, or distribute     *)
+(*  this file you indicate that you have read the license and              *)
+(*  understand and accept it fully.                                        *)
+(*                                                                         *)
+(***************************************************************************)
+(***************************************************************************)
+(* Pascal port by the UltraStar Deluxe Team                                *)
+(***************************************************************************)
+
+
+  (*************************************************************************)
+  (*                                                                       *)
+  (* This file contains the definition of several convenience functions    *)
+  (* that can be used by client applications to easily retrieve glyph      *)
+  (* bitmaps and outlines from a given face.                               *)
+  (*                                                                       *)
+  (* These functions should be optional if you are writing a font server   *)
+  (* or text layout engine on top of FreeType.  However, they are pretty   *)
+  (* handy for many other simple uses of the library.                      *)
+  (*                                                                       *)
+  (*************************************************************************)
+
+  (*************************************************************************)
+  (*                                                                       *)
+  (* <Section>                                                             *)
+  (*    glyph_management                                                   *)
+  (*                                                                       *)
+  (* <Title>                                                               *)
+  (*    Glyph Management                                                   *)
+  (*                                                                       *)
+  (* <Abstract>                                                            *)
+  (*    Generic interface to manage individual glyph data.                 *)
+  (*                                                                       *)
+  (* <Description>                                                         *)
+  (*    This section contains definitions used to manage glyph data        *)
+  (*    through generic FT_Glyph objects.  Each of them can contain a      *)
+  (*    bitmap, a vector outline, or even images in other formats.         *)
+  (*                                                                       *)
+  (*************************************************************************)
+
+{$IFDEF TYPE_DECL}
+  
+  (* forward declaration to a private type *)
+  PFT_Glyph_Class = Pointer;
+
+  
+  (*************************************************************************)
+  (*                                                                       *)
+  (* <Type>                                                                *)
+  (*    FT_Glyph                                                           *)
+  (*                                                                       *)
+  (* <Description>                                                         *)
+  (*    Handle to an object used to model generic glyph images.  It is a   *)
+  (*    pointer to the @FT_GlyphRec structure and can contain a glyph      *)
+  (*    bitmap or pointer.                                                 *)
+  (*                                                                       *)
+  (* <Note>                                                                *)
+  (*    Glyph objects are not owned by the library.  You must thus release *)
+  (*    them manually (through @FT_Done_Glyph) _before_ calling            *)
+  (*    @FT_Done_FreeType.                                                 *)
+  (*                                                                       *)
+  FT_Glyph = ^FT_GlyphRec;
+  
+  (*************************************************************************)
+  (*                                                                       *)
+  (* <Struct>                                                              *)
+  (*    FT_GlyphRec                                                        *)
+  (*                                                                       *)
+  (* <Description>                                                         *)
+  (*    The root glyph structure contains a given glyph image plus its     *)
+  (*    advance width in 16.16 fixed float format.                         *)
+  (*                                                                       *)
+  (* <Fields>                                                              *)
+  (*    library :: A handle to the FreeType library object.                *)
+  (*                                                                       *)
+  (*    clazz   :: A pointer to the glyph's class.  Private.               *)
+  (*                                                                       *)
+  (*    format  :: The format of the glyph's image.                        *)
+  (*                                                                       *)
+  (*    advance :: A 16.16 vector that gives the glyph's advance width.    *)
+  (*                                                                       *)
+  FT_GlyphRec = record
+    library_: FT_Library;
+    clazz:    PFT_Glyph_Class;
+    format:   FT_Glyph_Format;
+    advance:  FT_Vector;
+  end;
+
+
+  (*************************************************************************)
+  (*                                                                       *)
+  (* <Type>                                                                *)
+  (*    FT_BitmapGlyph                                                     *)
+  (*                                                                       *)
+  (* <Description>                                                         *)
+  (*    A handle to an object used to model a bitmap glyph image.  This is *)
+  (*    a sub-class of @FT_Glyph, and a pointer to @FT_BitmapGlyphRec.     *)
+  (*                                                                       *)
+  FT_BitmapGlyph = ^FT_BitmapGlyphRec;
+
+  (*************************************************************************)
+  (*                                                                       *)
+  (* <Struct>                                                              *)
+  (*    FT_BitmapGlyphRec                                                  *)
+  (*                                                                       *)
+  (* <Description>                                                         *)
+  (*    A structure used for bitmap glyph images.  This really is a        *)
+  (*    `sub-class' of `FT_GlyphRec'.                                      *)
+  (*                                                                       *)
+  (* <Fields>                                                              *)
+  (*    root   :: The root FT_Glyph fields.                                *)
+  (*                                                                       *)
+  (*    left   :: The left-side bearing, i.e., the horizontal distance     *)
+  (*              from the current pen position to the left border of the  *)
+  (*              glyph bitmap.                                            *)
+  (*                                                                       *)
+  (*    top    :: The top-side bearing, i.e., the vertical distance from   *)
+  (*              the current pen position to the top border of the glyph  *)
+  (*              bitmap.  This distance is positive for upwards-y!        *)
+  (*                                                                       *)
+  (*    bitmap :: A descriptor for the bitmap.                             *)
+  (*                                                                       *)
+  (* <Note>                                                                *)
+  (*    You can typecast FT_Glyph to FT_BitmapGlyph if you have            *)
+  (*    glyph->format == FT_GLYPH_FORMAT_BITMAP.  This lets you access     *)
+  (*    the bitmap's contents easily.                                      *)
+  (*                                                                       *)
+  (*    The corresponding pixel buffer is always owned by the BitmapGlyph  *)
+  (*    and is thus created and destroyed with it.                         *)
+  (*                                                                       *)
+  FT_BitmapGlyphRec = record
+    root:   FT_GlyphRec;
+    left:   FT_Int;
+    top:    FT_Int;
+    bitmap: FT_Bitmap;
+  end;
+
+
+  (*************************************************************************)
+  (*                                                                       *)
+  (* <Type>                                                                *)
+  (*    FT_OutlineGlyph                                                    *)
+  (*                                                                       *)
+  (* <Description>                                                         *)
+  (*    A handle to an object used to model an outline glyph image.  This  *)
+  (*    is a sub-class of @FT_Glyph, and a pointer to @FT_OutlineGlyphRec. *)
+  (*                                                                       *)
+  FT_OutlineGlyph = ^FT_OutlineGlyphRec;
+
+
+  (*************************************************************************)
+  (*                                                                       *)
+  (* <Struct>                                                              *)
+  (*    FT_OutlineGlyphRec                                                 *)
+  (*                                                                       *)
+  (* <Description>                                                         *)
+  (*    A structure used for outline (vectorial) glyph images.  This       *)
+  (*    really is a `sub-class' of `FT_GlyphRec'.                          *)
+  (*                                                                       *)
+  (* <Fields>                                                              *)
+  (*    root    :: The root FT_Glyph fields.                               *)
+  (*                                                                       *)
+  (*    outline :: A descriptor for the outline.                           *)
+  (*                                                                       *)
+  (* <Note>                                                                *)
+  (*    You can typecast FT_Glyph to FT_OutlineGlyph if you have           *)
+  (*    glyph->format == FT_GLYPH_FORMAT_OUTLINE.  This lets you access    *)
+  (*    the outline's content easily.                                      *)
+  (*                                                                       *)
+  (*    As the outline is extracted from a glyph slot, its coordinates are *)
+  (*    expressed normally in 26.6 pixels, unless the flag                 *)
+  (*    FT_LOAD_NO_SCALE was used in FT_Load_Glyph() or FT_Load_Char().    *)
+  (*                                                                       *)
+  (*    The outline's tables are always owned by the object and are        *)
+  (*    destroyed with it.                                                 *)
+  (*                                                                       *)
+  FT_OutlineGlyphRec = record
+    root:    FT_GlyphRec;
+    outline: FT_Outline;
+  end;
+
+{$ELSE TYPE_DECL}
+
+  (*************************************************************************)
+  (*                                                                       *)
+  (* <Function>                                                            *)
+  (*    FT_Get_Glyph                                                       *)
+  (*                                                                       *)
+  (* <Description>                                                         *)
+  (*    A function used to extract a glyph image from a slot.              *)
+  (*                                                                       *)
+  (* <Input>                                                               *)
+  (*    slot   :: A handle to the source glyph slot.                       *)
+  (*                                                                       *)
+  (* <Output>                                                              *)
+  (*    aglyph :: A handle to the glyph object.                            *)
+  (*                                                                       *)
+  (* <Return>                                                              *)
+  (*    FreeType error code.  0 means success.                             *)
+  (*                                                                       *)
+  function FT_Get_Glyph(
+             slot:   FT_GlyphSlot;
+             out aglyph: FT_Glyph ): FT_Error;
+    cdecl; external ft_lib name 'FT_Get_Glyph';
+
+  (*************************************************************************)
+  (*                                                                       *)
+  (* <Function>                                                            *)
+  (*    FT_Glyph_Copy                                                      *)
+  (*                                                                       *)
+  (* <Description>                                                         *)
+  (*    A function used to copy a glyph image.  Note that the created      *)
+  (*    @FT_Glyph object must be released with @FT_Done_Glyph.             *)
+  (*                                                                       *)
+  (* <Input>                                                               *)
+  (*    source :: A handle to the source glyph object.                     *)
+  (*                                                                       *)
+  (* <Output>                                                              *)
+  (*    target :: A handle to the target glyph object.  0~in case of       *)
+  (*              error.                                                   *)
+  (*                                                                       *)
+  (* <Return>                                                              *)
+  (*    FreeType error code.  0~means success.                             *)
+  (*                                                                       *)
+  function FT_Glyph_Copy(source: FT_Glyph;
+                 var target: FT_Glyph ): FT_Error;
+    cdecl; external ft_lib name 'FT_Glyph_Copy';
+
+{$ENDIF TYPE_DECL}
+{$IFDEF TYPE_DECL}
+
+  (*************************************************************************)
+  (*                                                                       *)
+  (* <Enum>                                                                *)
+  (*    FT_Glyph_BBox_Mode                                                 *)
+  (*                                                                       *)
+  (* <Description>                                                         *)
+  (*    The mode how the values of @FT_Glyph_Get_CBox are returned.        *)
+  (*                                                                       *)
+  (* <Values>                                                              *)
+  (*    FT_GLYPH_BBOX_UNSCALED ::                                          *)
+  (*      Return unscaled font units.                                      *)
+  (*                                                                       *)
+  (*    FT_GLYPH_BBOX_SUBPIXELS ::                                         *)
+  (*      Return unfitted 26.6 coordinates.                                *)
+  (*                                                                       *)
+  (*    FT_GLYPH_BBOX_GRIDFIT ::                                           *)
+  (*      Return grid-fitted 26.6 coordinates.                             *)
+  (*                                                                       *)
+  (*    FT_GLYPH_BBOX_TRUNCATE ::                                          *)
+  (*      Return coordinates in integer pixels.                            *)
+  (*                                                                       *)
+  (*    FT_GLYPH_BBOX_PIXELS ::                                            *)
+  (*      Return grid-fitted pixel coordinates.                            *)
+  (*                                                                       *)
+  FT_Glyph_BBox_Mode = cint;
+{$ELSE TYPE_DECL}
+const
+  FT_GLYPH_BBOX_UNSCALED  = 0;
+  FT_GLYPH_BBOX_SUBPIXELS = 0;
+  FT_GLYPH_BBOX_GRIDFIT   = 1;
+  FT_GLYPH_BBOX_TRUNCATE  = 2;
+  FT_GLYPH_BBOX_PIXELS    = 3;
+
+
+  (*************************************************************************)
+  (*                                                                       *)
+  (* <Function>                                                            *)
+  (*    FT_Glyph_Get_CBox                                                  *)
+  (*                                                                       *)
+  (* <Description>                                                         *)
+  (*    Return a glyph's `control box'.  The control box encloses all the  *)
+  (*    outline's points, including B�zier control points.  Though it      *)
+  (*    coincides with the exact bounding box for most glyphs, it can be   *)
+  (*    slightly larger in some situations (like when rotating an outline  *)
+  (*    which contains B�zier outside arcs).                               *)
+  (*                                                                       *)
+  (*    Computing the control box is very fast, while getting the bounding *)
+  (*    box can take much more time as it needs to walk over all segments  *)
+  (*    and arcs in the outline.  To get the latter, you can use the       *)
+  (*    `ftbbox' component which is dedicated to this single task.         *)
+  (*                                                                       *)
+  (* <Input>                                                               *)
+  (*    glyph :: A handle to the source glyph object.                      *)
+  (*                                                                       *)
+  (*    mode  :: The mode which indicates how to interpret the returned    *)
+  (*             bounding box values.                                      *)
+  (*                                                                       *)
+  (* <Output>                                                              *)
+  (*    acbox :: The glyph coordinate bounding box.  Coordinates are       *)
+  (*             expressed in 1/64th of pixels if it is grid-fitted.       *)
+  (*                                                                       *)
+  (* <Note>                                                                *)
+  (*    Coordinates are relative to the glyph origin, using the Y-upwards  *)
+  (*    convention.                                                        *)
+  (*                                                                       *)
+  (*    If the glyph has been loaded with @FT_LOAD_NO_SCALE, `bbox_mode'   *)
+  (*    must be set to @FT_GLYPH_BBOX_UNSCALED to get unscaled font        *)
+  (*    units in 26.6 pixel format.  The value @FT_GLYPH_BBOX_SUBPIXELS    *)
+  (*    is another name for this constant.                                 *)
+  (*                                                                       *)
+  (*    Note that the maximum coordinates are exclusive, which means that  *)
+  (*    one can compute the width and height of the glyph image (be it in  *)
+  (*    integer or 26.6 pixels) as:                                        *)
+  (*                                                                       *)
+  (*    {                                                                  *)
+  (*      width  = bbox.xMax - bbox.xMin;                                  *)
+  (*      height = bbox.yMax - bbox.yMin;                                  *)
+  (*    }                                                                  *)
+  (*                                                                       *)
+  (*    Note also that for 26.6 coordinates, if `bbox_mode' is set to      *)
+  (*    @FT_GLYPH_BBOX_GRIDFIT, the coordinates will also be grid-fitted,  *)
+  (*    which corresponds to:                                              *)
+  (*                                                                       *)
+  (*    {                                                                  *)
+  (*      bbox.xMin = FLOOR(bbox.xMin);                                    *)
+  (*      bbox.yMin = FLOOR(bbox.yMin);                                    *)
+  (*      bbox.xMax = CEILING(bbox.xMax);                                  *)
+  (*      bbox.yMax = CEILING(bbox.yMax);                                  *)
+  (*    }                                                                  *)
+  (*                                                                       *)
+  (*    To get the bbox in pixel coordinates, set `bbox_mode' to           *)
+  (*    @FT_GLYPH_BBOX_TRUNCATE.                                           *)
+  (*                                                                       *)
+  (*    To get the bbox in grid-fitted pixel coordinates, set `bbox_mode'  *)
+  (*    to @FT_GLYPH_BBOX_PIXELS.                                          *)
+  (*                                                                       *)
+  procedure FT_Glyph_Get_CBox( glyph: FT_Glyph;
+                     bbox_mode: FT_UInt;
+                     out acbox: FT_BBox );
+    cdecl; external ft_lib name 'FT_Glyph_Get_CBox';
+
+
+  (*************************************************************************)
+  (*                                                                       *)
+  (* <Function>                                                            *)
+  (*    FT_Glyph_To_Bitmap                                                 *)
+  (*                                                                       *)
+  (* <Description>                                                         *)
+  (*    Converts a given glyph object to a bitmap glyph object.            *)
+  (*                                                                       *)
+  (* <InOut>                                                               *)
+  (*    the_glyph   :: A pointer to a handle to the target glyph.          *)
+  (*                                                                       *)
+  (* <Input>                                                               *)
+  (*    render_mode :: An enumeration that describe how the data is        *)
+  (*                   rendered.                                           *)
+  (*                                                                       *)
+  (*    origin      :: A pointer to a vector used to translate the glyph   *)
+  (*                   image before rendering.  Can be 0 (if no            *)
+  (*                   translation).  The origin is expressed in           *)
+  (*                   26.6 pixels.                                        *)
+  (*                                                                       *)
+  (*    destroy     :: A boolean that indicates that the original glyph    *)
+  (*                   image should be destroyed by this function.  It is  *)
+  (*                   never destroyed in case of error.                   *)
+  (*                                                                       *)
+  (* <Return>                                                              *)
+  (*    FreeType error code.  0 means success.                             *)
+  (*                                                                       *)
+  (* <Note>                                                                *)
+  (*    The glyph image is translated with the `origin' vector before      *)
+  (*    rendering.                                                         *)
+  (*                                                                       *)
+  (*    The first parameter is a pointer to a FT_Glyph handle, that will   *)
+  (*    be replaced by this function.  Typically, you would use (omitting  *)
+  (*    error handling):                                                   *)
+  (*                                                                       *)
+  (*                                                                       *)
+  (*      {                                                                *)
+  (*        FT_Glyph        glyph;                                         *)
+  (*        FT_BitmapGlyph  glyph_bitmap;                                  *)
+  (*                                                                       *)
+  (*                                                                       *)
+  (*        // load glyph                                                  *)
+  (*        error = FT_Load_Char( face, glyph_index, FT_LOAD_DEFAUT );     *)
+  (*                                                                       *)
+  (*        // extract glyph image                                         *)
+  (*        error = FT_Get_Glyph( face->glyph, &glyph );                   *)
+  (*                                                                       *)
+  (*        // convert to a bitmap (default render mode + destroy old)     *)
+  (*        if ( glyph->format != FT_GLYPH_FORMAT_BITMAP )                 *)
+  (*        {                                                              *)
+  (*          error = FT_Glyph_To_Bitmap( &glyph, FT_RENDER_MODE_DEFAULT,  *)
+  (*                                      0, 1 );                          *)
+  (*          if ( error ) // glyph unchanged                              *)
+  (*            ...                                                        *)
+  (*        }                                                              *)
+  (*                                                                       *)
+  (*        // access bitmap content by typecasting                        *)
+  (*        glyph_bitmap = (FT_BitmapGlyph)glyph;                          *)
+  (*                                                                       *)
+  (*        // do funny stuff with it, like blitting/drawing               *)
+  (*        ...                                                            *)
+  (*                                                                       *)
+  (*        // discard glyph image (bitmap or not)                         *)
+  (*        FT_Done_Glyph( glyph );                                        *)
+  (*      }                                                                *)
+  (*                                                                       *)
+  (*                                                                       *)
+  (*    This function does nothing if the glyph format isn't scalable.     *)
+  (*                                                                       *)
+  function FT_Glyph_To_Bitmap(var the_glyph: FT_Glyph;
+                      render_mode: FT_Render_Mode;
+                      origin:      PFT_Vector;
+                      destroy:     FT_Bool ): FT_Error;
+    cdecl; external ft_lib name 'FT_Glyph_To_Bitmap';
+
+    
+  (*************************************************************************)
+  (*                                                                       *)
+  (* <Function>                                                            *)
+  (*    FT_Done_Glyph                                                      *)
+  (*                                                                       *)
+  (* <Description>                                                         *)
+  (*    Destroys a given glyph.                                            *)
+  (*                                                                       *)
+  (* <Input>                                                               *)
+  (*    glyph :: A handle to the target glyph object.                      *)
+  (*                                                                       *)
+  procedure FT_Done_Glyph( glyph: FT_Glyph );
+    cdecl; external ft_lib name 'FT_Done_Glyph';
+
+{$ENDIF TYPE_DECL}
diff --git a/Lua/src/lib/freetype/ftimage.inc b/Lua/src/lib/freetype/ftimage.inc
new file mode 100644
index 00000000..9255c422
--- /dev/null
+++ b/Lua/src/lib/freetype/ftimage.inc
@@ -0,0 +1,803 @@
+(***************************************************************************)
+(*                                                                         *)
+(*  ftimage.h                                                              *)
+(*                                                                         *)
+(*    FreeType glyph image formats and default raster interface            *)
+(*    (specification).                                                     *)
+(*                                                                         *)
+(*  Copyright 1996-2001, 2002, 2003, 2004, 2005, 2006, 2007 by             *)
+(*  David Turner, Robert Wilhelm, and Werner Lemberg.                      *)
+(*                                                                         *)
+(*  This file is part of the FreeType project, and may only be used,       *)
+(*  modified, and distributed under the terms of the FreeType project      *)
+(*  license, LICENSE.TXT.  By continuing to use, modify, or distribute     *)
+(*  this file you indicate that you have read the license and              *)
+(*  understand and accept it fully.                                        *)
+(*                                                                         *)
+(***************************************************************************)
+(***************************************************************************)
+(* Pascal port by the UltraStar Deluxe Team                                *)
+(***************************************************************************)
+
+  (*************************************************************************)
+  (*                                                                       *)
+  (* Note: A `raster' is simply a scan-line converter, used to render      *)
+  (*       FT_Outlines into FT_Bitmaps.                                    *)
+  (*                                                                       *)
+  (*************************************************************************)
+
+{$IFDEF TYPE_DECL}
+  
+  (*************************************************************************)
+  (*                                                                       *)
+  (* <Type>                                                                *)
+  (*    FT_Pos                                                             *)
+  (*                                                                       *)
+  (* <Description>                                                         *)
+  (*    The type FT_Pos is a 32-bit integer used to store vectorial        *)
+  (*    coordinates.  Depending on the context, these can represent        *)
+  (*    distances in integer font units, or 16,16, or 26.6 fixed float     *)
+  (*    pixel coordinates.                                                 *)
+  (*                                                                       *)
+  FT_Pos     = cslong;
+
+
+  (*************************************************************************)
+  (*                                                                       *)
+  (* <Struct>                                                              *)
+  (*    FT_Vector                                                          *)
+  (*                                                                       *)
+  (* <Description>                                                         *)
+  (*    A simple structure used to store a 2D vector; coordinates are of   *)
+  (*    the FT_Pos type.                                                   *)
+  (*                                                                       *)
+  (* <Fields>                                                              *)
+  (*    x :: The horizontal coordinate.                                    *)
+  (*    y :: The vertical coordinate.                                      *)
+  (*                                                                       *)
+  PFT_Vector = ^FT_Vector;
+  FT_Vector = record
+    x ,
+    y : FT_Pos;
+  end;
+
+  PFT_VectorArray = ^FT_VectorArray;
+  FT_VectorArray = array[0 .. (MaxInt div SizeOf(FT_Vector))-1] of FT_Vector;
+
+  (*************************************************************************)
+  (*                                                                       *)
+  (* <Struct>                                                              *)
+  (*    FT_BBox                                                            *)
+  (*                                                                       *)
+  (* <Description>                                                         *)
+  (*    A structure used to hold an outline's bounding box, i.e., the      *)
+  (*    coordinates of its extrema in the horizontal and vertical          *)
+  (*    directions.                                                        *)
+  (*                                                                       *)
+  (* <Fields>                                                              *)
+  (*    xMin :: The horizontal minimum (left-most).                        *)
+  (*                                                                       *)
+  (*    yMin :: The vertical minimum (bottom-most).                        *)
+  (*                                                                       *)
+  (*    xMax :: The horizontal maximum (right-most).                       *)
+  (*                                                                       *)
+  (*    yMax :: The vertical maximum (top-most).                           *)
+  (*                                                                       *)
+  PFT_BBox = ^FT_BBox;
+  FT_BBox = record
+    xMin, yMin : FT_Pos;
+    xMax, yMax : FT_Pos;
+  end;
+
+
+  (*************************************************************************)
+  (*                                                                       *)
+  (* <Enum>                                                                *)
+  (*    FT_Pixel_Mode                                                      *)
+  (*                                                                       *)
+  (* <Description>                                                         *)
+  (*    An enumeration type used to describe the format of pixels in a     *)
+  (*    given bitmap.  Note that additional formats may be added in the    *)
+  (*    future.                                                            *)
+  (*                                                                       *)
+  (* <Values>                                                              *)
+  (*    FT_PIXEL_MODE_NONE ::                                              *)
+  (*      Value 0 is reserved.                                             *)
+  (*                                                                       *)
+  (*    FT_PIXEL_MODE_MONO ::                                              *)
+  (*      A monochrome bitmap, using 1 bit per pixel.  Note that pixels    *)
+  (*      are stored in most-significant order (MSB), which means that     *)
+  (*      the left-most pixel in a byte has value 128.                     *)
+  (*                                                                       *)
+  (*    FT_PIXEL_MODE_GRAY ::                                              *)
+  (*      An 8-bit bitmap, generally used to represent anti-aliased glyph  *)
+  (*      images.  Each pixel is stored in one byte.  Note that the number *)
+  (*      of value `gray' levels is stored in the `num_bytes' field of     *)
+  (*      the @FT_Bitmap structure (it generally is 256).                  *)
+  (*                                                                       *)
+  (*    FT_PIXEL_MODE_GRAY2 ::                                             *)
+  (*      A 2-bit/pixel bitmap, used to represent embedded anti-aliased    *)
+  (*      bitmaps in font files according to the OpenType specification.   *)
+  (*      We haven't found a single font using this format, however.       *)
+  (*                                                                       *)
+  (*    FT_PIXEL_MODE_GRAY4 ::                                             *)
+  (*      A 4-bit/pixel bitmap, used to represent embedded anti-aliased    *)
+  (*      bitmaps in font files according to the OpenType specification.   *)
+  (*      We haven't found a single font using this format, however.       *)
+  (*                                                                       *)
+  (*    FT_PIXEL_MODE_LCD ::                                               *)
+  (*      An 8-bit bitmap, used to represent RGB or BGR decimated glyph    *)
+  (*      images used for display on LCD displays; the bitmap is three     *)
+  (*      times wider than the original glyph image.  See also             *)
+  (*      @FT_RENDER_MODE_LCD.                                             *)
+  (*                                                                       *)
+  (*    FT_PIXEL_MODE_LCD_V ::                                             *)
+  (*      An 8-bit bitmap, used to represent RGB or BGR decimated glyph    *)
+  (*      images used for display on rotated LCD displays; the bitmap      *)
+  (*      is three times taller than the original glyph image.  See also   *)
+  (*      @FT_RENDER_MODE_LCD_V.                                           *)
+  (*                                                                       *)
+  FT_Pixel_Mode = cint;
+{$ELSE TYPE_DECL}
+const
+  FT_PIXEL_MODE_NONE    = 0;
+  FT_PIXEL_MODE_MONO    = FT_PIXEL_MODE_NONE  + 1;
+  FT_PIXEL_MODE_GRAY    = FT_PIXEL_MODE_MONO  + 1;
+  FT_PIXEL_MODE_GRAY2   = FT_PIXEL_MODE_GRAY  + 1;
+  FT_PIXEL_MODE_GRAY4   = FT_PIXEL_MODE_GRAY2 + 1;
+  FT_PIXEL_MODE_LCD     = FT_PIXEL_MODE_GRAY4 + 1;
+  FT_PIXEL_MODE_LCD_V   = FT_PIXEL_MODE_LCD   + 1;
+
+  FT_PIXEL_MODE_MAX     = FT_PIXEL_MODE_LCD_V + 1; (* do not remove *)
+{$ENDIF TYPE_DECL}
+{$IFDEF TYPE_DECL}
+
+  (*************************************************************************)
+  (*                                                                       *)
+  (* <Struct>                                                              *)
+  (*    FT_Bitmap                                                          *)
+  (*                                                                       *)
+  (* <Description>                                                         *)
+  (*    A structure used to describe a bitmap or pixmap to the raster.     *)
+  (*    Note that we now manage pixmaps of various depths through the      *)
+  (*    `pixel_mode' field.                                                *)
+  (*                                                                       *)
+  (* <Fields>                                                              *)
+  (*    rows         :: The number of bitmap rows.                         *)
+  (*                                                                       *)
+  (*    width        :: The number of pixels in bitmap row.                *)
+  (*                                                                       *)
+  (*    pitch        :: The pitch's absolute value is the number of bytes  *)
+  (*                    taken by one bitmap row, including padding.        *)
+  (*                    However, the pitch is positive when the bitmap has *)
+  (*                    a `down' flow, and negative when it has an `up'    *)
+  (*                    flow.  In all cases, the pitch is an offset to add *)
+  (*                    to a bitmap pointer in order to go down one row.   *)
+  (*                                                                       *)
+  (*    buffer       :: A typeless pointer to the bitmap buffer.  This     *)
+  (*                    value should be aligned on 32-bit boundaries in    *)
+  (*                    most cases.                                        *)
+  (*                                                                       *)
+  (*    num_grays    :: This field is only used with                       *)
+  (*                    `FT_PIXEL_MODE_GRAY'; it gives the number of gray  *)
+  (*                    levels used in the bitmap.                         *)
+  (*                                                                       *)
+  (*    pixel_mode   :: The pixel mode, i.e., how pixel bits are stored.   *)
+  (*                    See @FT_Pixel_Mode for possible values.            *)
+  (*                                                                       *)
+  (*    palette_mode :: This field is only used with paletted pixel modes; *)
+  (*                    it indicates how the palette is stored.            *)
+  (*                                                                       *)
+  (*    palette      :: A typeless pointer to the bitmap palette; only     *)
+  (*                    used for paletted pixel modes.                     *)
+  (*                                                                       *)
+  (* <Note>                                                                *)
+  (*   For now, the only pixel mode supported by FreeType are mono and     *)
+  (*   grays.  However, drivers might be added in the future to support    *)
+  (*   more `colorful' options.                                            *)
+  (*                                                                       *)
+  (*   When using pixel modes pal2, pal4 and pal8 with a void `palette'    *)
+  (*   field, a gray pixmap with respectively 4, 16, and 256 levels of     *)
+  (*   gray is assumed.  This, in order to be compatible with some         *)
+  (*   embedded bitmap formats defined in the TrueType specification.      *)
+  (*                                                                       *)
+  (*   Note that no font was found presenting such embedded bitmaps, so    *)
+  (*   this is currently completely unhandled by the library.              *)
+  (*                                                                       *)
+  PFT_Bitmap = ^FT_Bitmap;
+  FT_Bitmap = record
+    rows:         FT_Int;
+    width:        FT_Int;
+    pitch:        FT_Int;
+    buffer:       PByteArray;
+    num_grays:    FT_Short;
+    pixel_mode:   byte;
+    palette_mode: byte;
+    palette:      pointer;
+  end;
+
+
+  (*************************************************************************)
+  (*                                                                       *)
+  (* <Section>                                                             *)
+  (*    outline_processing                                                 *)
+  (*                                                                       *)
+  (*************************************************************************)
+
+
+  (*************************************************************************)
+  (*                                                                       *)
+  (* <Struct>                                                              *)
+  (*    FT_Outline                                                         *)
+  (*                                                                       *)
+  (* <Description>                                                         *)
+  (*    This structure is used to describe an outline to the scan-line     *)
+  (*    converter.                                                         *)
+  (*                                                                       *)
+  (* <Fields>                                                              *)
+  (*    n_contours :: The number of contours in the outline.               *)
+  (*                                                                       *)
+  (*    n_points   :: The number of points in the outline.                 *)
+  (*                                                                       *)
+  (*    points     :: A pointer to an array of `n_points' FT_Vector        *)
+  (*                  elements, giving the outline's point coordinates.    *)
+  (*                                                                       *)
+  (*    tags       :: A pointer to an array of `n_points' chars, giving    *)
+  (*                  each outline point's type.  If bit 0 is unset, the   *)
+  (*                  point is `off' the curve, i.e. a Bezier control      *)
+  (*                  point, while it is `on' when set.                    *)
+  (*                                                                       *)
+  (*                  Bit 1 is meaningful for `off' points only.  If set,  *)
+  (*                  it indicates a third-order Bezier arc control point; *)
+  (*                  and a second-order control point if unset.           *)
+  (*                                                                       *)
+  (*    contours   :: An array of `n_contours' shorts, giving the end      *)
+  (*                  point of each contour within the outline.  For       *)
+  (*                  example, the first contour is defined by the points  *)
+  (*                  `0' to `contours[0]', the second one is defined by   *)
+  (*                  the points `contours[0]+1' to `contours[1]', etc.    *)
+  (*                                                                       *)
+  (*    flags      :: A set of bit flags used to characterize the outline  *)
+  (*                  and give hints to the scan-converter and hinter on   *)
+  (*                  how to convert/grid-fit it.  See FT_Outline_Flags.   *)
+  (*                                                                       *)
+  PFT_Outline = ^FT_Outline;
+  FT_Outline = record
+    n_contours: FT_Short;        (* number of contours in glyph        *)
+    n_points:   FT_Short;        (* number of points in the glyph      *)
+
+    points:     PFT_VectorArray; (* the outline's points               *)
+    tags:       PByteArray;      (* the points flags                   *)
+    contours:   PFT_ShortArray;  (* the contour end points             *)
+
+    flags:      FT_Int;          (* outline masks                      *)
+  end;
+
+{$ELSE TYPE_DECL}
+
+  (*************************************************************************)
+  (*                                                                       *)
+  (* @macro:                                                               *)
+  (*    FT_CURVE_TAG  ( flag )                                             *)
+  (*                                                                       *)
+  function  FT_CURVE_TAG(flag: byte): byte;
+
+const
+  FT_CURVE_TAG_ON    = 1;
+  FT_CURVE_TAG_CONIC = 0;
+  FT_CURVE_TAG_CUBIC = 2;
+
+  FT_CURVE_TAG_TOUCH_X   =   8;  // reserved for the TrueType hinter
+  FT_CURVE_TAG_TOUCH_Y   =  16;  // reserved for the TrueType hinter
+
+  FT_CURVE_TAG_TOUCH_BOTH  = ( FT_CURVE_TAG_TOUCH_X or
+                               FT_CURVE_TAG_TOUCH_Y );
+{$ENDIF TYPE_DECL}
+{$IFDEF TYPE_DECL}
+
+  (*************************************************************************)
+  (*                                                                       *)
+  (* <FuncType>                                                            *)
+  (*    FT_Outline_MoveToFunc                                              *)
+  (*                                                                       *)
+  (* <Description>                                                         *)
+  (*    A function pointer type used to describe the signature of a `move  *)
+  (*    to' function during outline walking/decomposition.                 *)
+  (*                                                                       *)
+  (*    A `move to' is emitted to start a new contour in an outline.       *)
+  (*                                                                       *)
+  (* <Input>                                                               *)
+  (*    to   :: A pointer to the target point of the `move to'.            *)
+  (*                                                                       *)
+  (*    user :: A typeless pointer which is passed from the caller of the  *)
+  (*            decomposition function.                                    *)
+  (*                                                                       *)
+  (* <Return>                                                              *)
+  (*    Error code.  0 means success.                                      *)
+  (*                                                                       *)
+  FT_Outline_MoveToFunc = function(to_: {const} PFT_Vector;
+                                   user: Pointer): cint; cdecl;
+
+
+  (*************************************************************************)
+  (*                                                                       *)
+  (* <FuncType>                                                            *)
+  (*    FT_Outline_LineToFunc                                              *)
+  (*                                                                       *)
+  (* <Description>                                                         *)
+  (*    A function pointer type used to describe the signature of a `line  *)
+  (*    to' function during outline walking/decomposition.                 *)
+  (*                                                                       *)
+  (*    A `line to' is emitted to indicate a segment in the outline.       *)
+  (*                                                                       *)
+  (* <Input>                                                               *)
+  (*    to   :: A pointer to the target point of the `line to'.            *)
+  (*                                                                       *)
+  (*    user :: A typeless pointer which is passed from the caller of the  *)
+  (*            decomposition function.                                    *)
+  (*                                                                       *)
+  (* <Return>                                                              *)
+  (*    Error code.  0 means success.                                      *)
+  (*                                                                       *)
+  FT_Outline_LineToFunc = function(to_: {const} PFT_Vector;
+                                   user: Pointer): cint; cdecl;
+
+
+  (*************************************************************************)
+  (*                                                                       *)
+  (* <FuncType>                                                            *)
+  (*    FT_Outline_ConicToFunc                                             *)
+  (*                                                                       *)
+  (* <Description>                                                         *)
+  (*    A function pointer type use to describe the signature of a `conic  *)
+  (*    to' function during outline walking/decomposition.                 *)
+  (*                                                                       *)
+  (*    A `conic to' is emitted to indicate a second-order B�zier arc in   *)
+  (*    the outline.                                                       *)
+  (*                                                                       *)
+  (* <Input>                                                               *)
+  (*    control :: An intermediate control point between the last position *)
+  (*               and the new target in `to'.                             *)
+  (*                                                                       *)
+  (*    to      :: A pointer to the target end point of the conic arc.     *)
+  (*                                                                       *)
+  (*    user    :: A typeless pointer which is passed from the caller of   *)
+  (*               the decomposition function.                             *)
+  (*                                                                       *)
+  (* <Return>                                                              *)
+  (*    Error code.  0 means success.                                      *)
+  (*                                                                       *)
+  FT_Outline_ConicToFunc = function(control: {const} PFT_Vector;
+                             to_:  {const} PFT_Vector;
+                             user: Pointer): cint; cdecl;
+
+
+  (*************************************************************************)
+  (*                                                                       *)
+  (* <FuncType>                                                            *)
+  (*    FT_Outline_CubicToFunc                                             *)
+  (*                                                                       *)
+  (* <Description>                                                         *)
+  (*    A function pointer type used to describe the signature of a `cubic *)
+  (*    to' function during outline walking/decomposition.                 *)
+  (*                                                                       *)
+  (*    A `cubic to' is emitted to indicate a third-order B�zier arc.      *)
+  (*                                                                       *)
+  (* <Input>                                                               *)
+  (*    control1 :: A pointer to the first B�zier control point.           *)
+  (*                                                                       *)
+  (*    control2 :: A pointer to the second B�zier control point.          *)
+  (*                                                                       *)
+  (*    to       :: A pointer to the target end point.                     *)
+  (*                                                                       *)
+  (*    user     :: A typeless pointer which is passed from the caller of  *)
+  (*                the decomposition function.                            *)
+  (*                                                                       *)
+  (* <Return>                                                              *)
+  (*    Error code.  0 means success.                                      *)
+  (*                                                                       *)
+  FT_Outline_CubicToFunc = function( control1: {const} PFT_Vector;
+                             control2: {const} PFT_Vector;
+                             to_:      {const} PFT_Vector;
+                             user:     Pointer ): cint; cdecl;
+
+
+  (*************************************************************************)
+  (*                                                                       *)
+  (* <Struct>                                                              *)
+  (*    FT_Outline_Funcs                                                   *)
+  (*                                                                       *)
+  (* <Description>                                                         *)
+  (*    A structure to hold various function pointers used during outline  *)
+  (*    decomposition in order to emit segments, conic, and cubic B�ziers, *)
+  (*    as well as `move to' and `close to' operations.                    *)
+  (*                                                                       *)
+  (* <Fields>                                                              *)
+  (*    move_to  :: The `move to' emitter.                                 *)
+  (*                                                                       *)
+  (*    line_to  :: The segment emitter.                                   *)
+  (*                                                                       *)
+  (*    conic_to :: The second-order B�zier arc emitter.                   *)
+  (*                                                                       *)
+  (*    cubic_to :: The third-order B�zier arc emitter.                    *)
+  (*                                                                       *)
+  (*    shift    :: The shift that is applied to coordinates before they   *)
+  (*                are sent to the emitter.                               *)
+  (*                                                                       *)
+  (*    delta    :: The delta that is applied to coordinates before they   *)
+  (*                are sent to the emitter, but after the shift.          *)
+  (*                                                                       *)
+  (* <Note>                                                                *)
+  (*    The point coordinates sent to the emitters are the transformed     *)
+  (*    version of the original coordinates (this is important for high    *)
+  (*    accuracy during scan-conversion).  The transformation is simple:   *)
+  (*                                                                       *)
+  (*    {                                                                  *)
+  (*      x' = (x << shift) - delta                                        *)
+  (*      y' = (x << shift) - delta                                        *)
+  (*    }                                                                  *)
+  (*                                                                       *)
+  (*    Set the value of `shift' and `delta' to 0 to get the original      *)
+  (*    point coordinates.                                                 *)
+  (*                                                                       *)
+  PFT_Outline_Funcs = ^FT_Outline_Funcs;
+  FT_Outline_Funcs = record
+    move_to:  FT_Outline_MoveToFunc;
+    line_to:  FT_Outline_LineToFunc;
+    conic_to: FT_Outline_ConicToFunc;
+    cubic_to: FT_Outline_CubicToFunc;
+
+    shift:    cint;
+    delta:    FT_Pos;
+  end;
+
+
+  (*************************************************************************)
+  (*                                                                       *)
+  (* <Enum>                                                                *)
+  (*    FT_Glyph_Format                                                    *)
+  (*                                                                       *)
+  (* <Description>                                                         *)
+  (*    An enumeration type used to describe the format of a given glyph   *)
+  (*    image.  Note that this version of FreeType only supports two image *)
+  (*    formats, even though future font drivers will be able to register  *)
+  (*    their own format.                                                  *)
+  (*                                                                       *)
+  (* <Values>                                                              *)
+  (*    FT_GLYPH_FORMAT_NONE ::                                            *)
+  (*      The value 0 is reserved and does describe a glyph format.        *)
+  (*                                                                       *)
+  (*    FT_GLYPH_FORMAT_COMPOSITE ::                                       *)
+  (*      The glyph image is a composite of several other images.  This    *)
+  (*      format is _only_ used with @FT_LOAD_NO_RECURSE, and is used to   *)
+  (*      report compound glyphs (like accented characters).               *)
+  (*                                                                       *)
+  (*    FT_GLYPH_FORMAT_BITMAP ::                                          *)
+  (*      The glyph image is a bitmap, and can be described as an          *)
+  (*      @FT_Bitmap.  You generally need to access the `bitmap' field of  *)
+  (*      the @FT_GlyphSlotRec structure to read it.                       *)
+  (*                                                                       *)
+  (*    FT_GLYPH_FORMAT_OUTLINE ::                                         *)
+  (*      The glyph image is a vertorial outline made of line segments     *)
+  (*      and Bezier arcs; it can be described as an @FT_Outline; you      *)
+  (*      generally want to access the `outline' field of the              *)
+  (*      @FT_GlyphSlotRec structure to read it.                           *)
+  (*                                                                       *)
+  (*    FT_GLYPH_FORMAT_PLOTTER ::                                         *)
+  (*      The glyph image is a vectorial path with no inside/outside       *)
+  (*      contours.  Some Type 1 fonts, like those in the Hershey family,  *)
+  (*      contain glyphs in this format.  These are described as           *)
+  (*      @FT_Outline, but FreeType isn't currently capable of rendering   *)
+  (*      them correctly.                                                  *)
+  (*                                                                       *)
+  FT_Glyph_Format = array[0..3] of char;
+{$ELSE TYPE_DECL}
+const
+  FT_GLYPH_FORMAT_NONE:      FT_Glyph_Format = (#0, #0, #0, #0 );
+
+  FT_GLYPH_FORMAT_COMPOSITE: FT_Glyph_Format = ('c', 'o', 'm', 'p' );
+  FT_GLYPH_FORMAT_BITMAP:    FT_Glyph_Format = ('b', 'i', 't', 's' );
+  FT_GLYPH_FORMAT_OUTLINE:   FT_Glyph_Format = ('o', 'u', 't', 'l' );
+  FT_GLYPH_FORMAT_PLOTTER:   FT_Glyph_Format = ('p', 'l', 'o', 't' );
+
+{$ENDIF TYPE_DECL}
+
+  (*************************************************************************)
+  (*************************************************************************)
+  (*************************************************************************)
+  (*****                                                               *****)
+  (*****            R A S T E R   D E F I N I T I O N S                *****)
+  (*****                                                               *****)
+  (*************************************************************************)
+  (*************************************************************************)
+  (*************************************************************************)
+
+
+  (*************************************************************************)
+  (*                                                                       *)
+  (* A raster is a scan converter, in charge of rendering an outline into  *)
+  (* a a bitmap.  This section contains the public API for rasters.        *)
+  (*                                                                       *)
+  (* Note that in FreeType 2, all rasters are now encapsulated within      *)
+  (* specific modules called `renderers'.  See `freetype/ftrender.h' for   *)
+  (* more details on renderers.                                            *)
+  (*                                                                       *)
+  (*************************************************************************)
+
+
+  (*************************************************************************)
+  (*                                                                       *)
+  (* <Section>                                                             *)
+  (*    raster                                                             *)
+  (*                                                                       *)
+  (* <Title>                                                               *)
+  (*    Scanline Converter                                                 *)
+  (*                                                                       *)
+  (* <Abstract>                                                            *)
+  (*    How vectorial outlines are converted into bitmaps and pixmaps.     *)
+  (*                                                                       *)
+  (* <Description>                                                         *)
+  (*    This section contains technical definitions.                       *)
+  (*                                                                       *)
+  (*************************************************************************)
+
+{$IFDEF TYPE_DECL}
+
+  (*************************************************************************)
+  (*                                                                       *)
+  (* <Type>                                                                *)
+  (*    FT_Raster                                                          *)
+  (*                                                                       *)
+  (* <Description>                                                         *)
+  (*    A handle (pointer) to a raster object.  Each object can be used    *)
+  (*    independently to convert an outline into a bitmap or pixmap.       *)
+  (*                                                                       *)
+  FT_Raster = Pointer;
+
+
+  (*************************************************************************)
+  (*                                                                       *)
+  (* <Struct>                                                              *)
+  (*    FT_Span                                                            *)
+  (*                                                                       *)
+  (* <Description>                                                         *)
+  (*    A structure used to model a single span of gray (or black) pixels  *)
+  (*    when rendering a monochrome or anti-aliased bitmap.                *)
+  (*                                                                       *)
+  (* <Fields>                                                              *)
+  (*    x        :: The span's horizontal start position.                  *)
+  (*                                                                       *)
+  (*    len      :: The span's length in pixels.                           *)
+  (*                                                                       *)
+  (*    coverage :: The span color/coverage, ranging from 0 (background)   *)
+  (*                to 255 (foreground).  Only used for anti-aliased       *)
+  (*                rendering.                                             *)
+  (*                                                                       *)
+  (* <Note>                                                                *)
+  (*    This structure is used by the span drawing callback type named     *)
+  (*    @FT_SpanFunc which takes the y-coordinate of the span as a         *)
+  (*    a parameter.                                                       *)
+  (*                                                                       *)
+  (*    The coverage value is always between 0 and 255.                    *)
+  (*                                                                       *)
+  PFT_Span = ^FT_Span;
+  FT_Span = record
+    x:         cshort;
+    len:       cushort;
+    coverage:  cuchar;
+  end;
+
+
+  (*************************************************************************)
+  (*                                                                       *)
+  (* <FuncType>                                                            *)
+  (*    FT_SpanFunc                                                        *)
+  (*                                                                       *)
+  (* <Description>                                                         *)
+  (*    A function used as a call-back by the anti-aliased renderer in     *)
+  (*    order to let client applications draw themselves the gray pixel    *)
+  (*    spans on each scan line.                                           *)
+  (*                                                                       *)
+  (* <Input>                                                               *)
+  (*    y     :: The scanline's y-coordinate.                              *)
+  (*                                                                       *)
+  (*    count :: The number of spans to draw on this scanline.             *)
+  (*                                                                       *)
+  (*    spans :: A table of `count' spans to draw on the scanline.         *)
+  (*                                                                       *)
+  (*    user  :: User-supplied data that is passed to the callback.        *)
+  (*                                                                       *)
+  (* <Note>                                                                *)
+  (*    This callback allows client applications to directly render the    *)
+  (*    gray spans of the anti-aliased bitmap to any kind of surfaces.     *)
+  (*                                                                       *)
+  (*    This can be used to write anti-aliased outlines directly to a      *)
+  (*    given background bitmap, and even perform translucency.            *)
+  (*                                                                       *)
+  (*    Note that the `count' field cannot be greater than a fixed value   *)
+  (*    defined by the `FT_MAX_GRAY_SPANS' configuration macro in          *)
+  (*    `ftoption.h'.  By default, this value is set to 32, which means    *)
+  (*    that if there are more than 32 spans on a given scanline, the      *)
+  (*    callback is called several times with the same `y' parameter in    *)
+  (*    order to draw all callbacks.                                       *)
+  (*                                                                       *)
+  (*    Otherwise, the callback is only called once per scan-line, and     *)
+  (*    only for those scanlines that do have `gray' pixels on them.       *)
+  (*                                                                       *)
+  FT_SpanFunc = procedure(y:      cint;
+                  count:          cint;
+                  spans:          {const} PFT_Span;
+                  user:           Pointer ); cdecl;
+
+
+  (*************************************************************************)
+  (*                                                                       *)
+  (* <FuncType>                                                            *)
+  (*    FT_Raster_BitTest_Func                                             *)
+  (*                                                                       *)
+  (* <Description>                                                         *)
+  (*    THIS TYPE IS DEPRECATED.  DO NOT USE IT.                           *)
+  (*                                                                       *)
+  (*    A function used as a call-back by the monochrome scan-converter    *)
+  (*    to test whether a given target pixel is already set to the drawing *)
+  (*    `color'.  These tests are crucial to implement drop-out control    *)
+  (*    per-se the TrueType spec.                                          *)
+  (*                                                                       *)
+  (* <Input>                                                               *)
+  (*    y     :: The pixel's y-coordinate.                                 *)
+  (*                                                                       *)
+  (*    x     :: The pixel's x-coordinate.                                 *)
+  (*                                                                       *)
+  (*    user  :: User-supplied data that is passed to the callback.        *)
+  (*                                                                       *)
+  (* <Return>                                                              *)
+  (*   1 if the pixel is `set', 0 otherwise.                               *)
+  (*                                                                       *)
+  FT_Raster_BitTest_Func = function(y: cint;
+                             x:    cint;
+                             user: Pointer): cint; cdecl;
+
+
+  (*************************************************************************)
+  (*                                                                       *)
+  (* <FuncType>                                                            *)
+  (*    FT_Raster_BitSet_Func                                              *)
+  (*                                                                       *)
+  (* <Description>                                                         *)
+  (*    THIS TYPE IS DEPRECATED.  DO NOT USE IT.                           *)
+  (*                                                                       *)
+  (*    A function used as a call-back by the monochrome scan-converter    *)
+  (*    to set an individual target pixel.  This is crucial to implement   *)
+  (*    drop-out control according to the TrueType specification.          *)
+  (*                                                                       *)
+  (* <Input>                                                               *)
+  (*    y     :: The pixel's y-coordinate.                                 *)
+  (*                                                                       *)
+  (*    x     :: The pixel's x-coordinate.                                 *)
+  (*                                                                       *)
+  (*    user  :: User-supplied data that is passed to the callback.        *)
+  (*                                                                       *)
+  (* <Return>                                                              *)
+  (*    1 if the pixel is `set', 0 otherwise.                              *)
+  (*                                                                       *)
+  FT_Raster_BitSet_Func = procedure(y: cint;
+                            x:    cint;
+                            user: Pointer ); cdecl;
+
+
+  (*************************************************************************)
+  (*                                                                       *)
+  (* <Enum>                                                                *)
+  (*    FT_RASTER_FLAG_XXX                                                 *)
+  (*                                                                       *)
+  (* <Description>                                                         *)
+  (*    A list of bit flag constants as used in the `flags' field of a     *)
+  (*    @FT_Raster_Params structure.                                       *)
+  (*                                                                       *)
+  (* <Values>                                                              *)
+  (*    FT_RASTER_FLAG_DEFAULT :: This value is 0.                         *)
+  (*                                                                       *)
+  (*    FT_RASTER_FLAG_AA      :: This flag is set to indicate that an     *)
+  (*                              anti-aliased glyph image should be       *)
+  (*                              generated.  Otherwise, it will be        *)
+  (*                              monochrome (1-bit).                      *)
+  (*                                                                       *)
+  (*    FT_RASTER_FLAG_DIRECT  :: This flag is set to indicate direct      *)
+  (*                              rendering.  In this mode, client         *)
+  (*                              applications must provide their own span *)
+  (*                              callback.  This lets them directly       *)
+  (*                              draw or compose over an existing bitmap. *)
+  (*                              If this bit is not set, the target       *)
+  (*                              pixmap's buffer _must_ be zeroed before  *)
+  (*                              rendering.                               *)
+  (*                                                                       *)
+  (*                              Note that for now, direct rendering is   *)
+  (*                              only possible with anti-aliased glyphs.  *)
+  (*                                                                       *)
+  (*    FT_RASTER_FLAG_CLIP    :: This flag is only used in direct         *)
+  (*                              rendering mode.  If set, the output will *)
+  (*                              be clipped to a box specified in the     *)
+  (*                              `clip_box' field of the                  *)
+  (*                              @FT_Raster_Params structure.             *)
+  (*                                                                       *)
+  (*                              Note that by default, the glyph bitmap   *)
+  (*                              is clipped to the target pixmap, except  *)
+  (*                              in direct rendering mode where all spans *)
+  (*                              are generated if no clipping box is set. *)
+  (*                                                                       *)
+{$ELSE TYPE_DECL}
+const
+  FT_RASTER_FLAG_DEFAULT  = $0;
+  FT_RASTER_FLAG_AA       = $1;
+  FT_RASTER_FLAG_DIRECT   = $2;
+  FT_RASTER_FLAG_CLIP     = $4;
+
+{$ENDIF TYPE_DECL}
+{$IFDEF TYPE_DECL}
+
+  (*************************************************************************)
+  (*                                                                       *)
+  (* <Struct>                                                              *)
+  (*    FT_Raster_Params                                                   *)
+  (*                                                                       *)
+  (* <Description>                                                         *)
+  (*    A structure to hold the arguments used by a raster's render        *)
+  (*    function.                                                          *)
+  (*                                                                       *)
+  (* <Fields>                                                              *)
+  (*    target      :: The target bitmap.                                  *)
+  (*                                                                       *)
+  (*    source      :: A pointer to the source glyph image (e.g., an       *)
+  (*                   @FT_Outline).                                       *)
+  (*                                                                       *)
+  (*    flags       :: The rendering flags.                                *)
+  (*                                                                       *)
+  (*    gray_spans  :: The gray span drawing callback.                     *)
+  (*                                                                       *)
+  (*    black_spans :: The black span drawing callback.                    *)
+  (*                                                                       *)
+  (*    bit_test    :: The bit test callback.  UNIMPLEMENTED!              *)
+  (*                                                                       *)
+  (*    bit_set     :: The bit set callback.  UNIMPLEMENTED!               *)
+  (*                                                                       *)
+  (*    user        :: User-supplied data that is passed to each drawing   *)
+  (*                   callback.                                           *)
+  (*                                                                       *)
+  (*    clip_box    :: An optional clipping box.  It is only used in       *)
+  (*                   direct rendering mode.  Note that coordinates here  *)
+  (*                   should be expressed in _integer_ pixels (and not in *)
+  (*                   26.6 fixed-point units).                            *)
+  (*                                                                       *)
+  (* <Note>                                                                *)
+  (*    An anti-aliased glyph bitmap is drawn if the @FT_RASTER_FLAG_AA    *)
+  (*    bit flag is set in the `flags' field, otherwise a monochrome       *)
+  (*    bitmap is generated.                                               *)
+  (*                                                                       *)
+  (*    If the @FT_RASTER_FLAG_DIRECT bit flag is set in `flags', the      *)
+  (*    raster will call the `gray_spans' callback to draw gray pixel      *)
+  (*    spans, in the case of an aa glyph bitmap, it will call             *)
+  (*    `black_spans', and `bit_test' and `bit_set' in the case of a       *)
+  (*    monochrome bitmap.  This allows direct composition over a          *)
+  (*    pre-existing bitmap through user-provided callbacks to perform the *)
+  (*    span drawing/composition.                                          *)
+  (*                                                                       *)
+  (*    Note that the `bit_test' and `bit_set' callbacks are required when *)
+  (*    rendering a monochrome bitmap, as they are crucial to implement    *)
+  (*    correct drop-out control as defined in the TrueType specification. *)
+  (*                                                                       *)
+  PFT_Raster_Params = ^FT_Raster_Params;
+  FT_Raster_Params = record
+    target:        {const} PFT_Bitmap;
+    source:        {const} Pointer;
+    flags:         cint;
+    gray_spans:    FT_SpanFunc;
+    black_spans:   FT_SpanFunc;
+    bit_test:      FT_Raster_BitTest_Func;     (* doesn't work! *)
+    bit_set:       FT_Raster_BitSet_Func;      (* doesn't work! *)
+    user:          Pointer;
+    clip_box:      FT_BBox;
+  end;
+
+{$ENDIF TYPE_DECL}
+
+
diff --git a/Lua/src/lib/freetype/ftoutln.inc b/Lua/src/lib/freetype/ftoutln.inc
new file mode 100644
index 00000000..997c6cb3
--- /dev/null
+++ b/Lua/src/lib/freetype/ftoutln.inc
@@ -0,0 +1,497 @@
+(***************************************************************************)
+(*                                                                         *)
+(*  ftoutln.h                                                              *)
+(*                                                                         *)
+(*    Support for the FT_Outline type used to store glyph shapes of        *)
+(*    most scalable font formats (specification).                          *)
+(*                                                                         *)
+(*  Copyright 1996-2001, 2002, 2003, 2005, 2006, 2007 by                   *)
+(*  David Turner, Robert Wilhelm, and Werner Lemberg.                      *)
+(*                                                                         *)
+(*  This file is part of the FreeType project, and may only be used,       *)
+(*  modified, and distributed under the terms of the FreeType project      *)
+(*  license, LICENSE.TXT.  By continuing to use, modify, or distribute     *)
+(*  this file you indicate that you have read the license and              *)
+(*  understand and accept it fully.                                        *)
+(*                                                                         *)
+(***************************************************************************)
+(***************************************************************************)
+(* Pascal port by the UltraStar Deluxe Team                                *)
+(***************************************************************************)
+
+
+  (*************************************************************************)
+  (*                                                                       *)
+  (* <Section>                                                             *)
+  (*    outline_processing                                                 *)
+  (*                                                                       *)
+  (* <Title>                                                               *)
+  (*    Outline Processing                                                 *)
+  (*                                                                       *)
+  (* <Abstract>                                                            *)
+  (*    Functions to create, transform, and render vectorial glyph images. *)
+  (*                                                                       *)
+  (* <Description>                                                         *)
+  (*    This section contains routines used to create and destroy scalable *)
+  (*    glyph images known as `outlines'.  These can also be measured,     *)
+  (*    transformed, and converted into bitmaps and pixmaps.               *)
+  (*                                                                       *)
+  (* <Order>                                                               *)
+  (*    FT_Outline                                                         *)
+  (*    FT_OUTLINE_FLAGS                                                   *)
+  (*    FT_Outline_New                                                     *)
+  (*    FT_Outline_Done                                                    *)
+  (*    FT_Outline_Copy                                                    *)
+  (*    FT_Outline_Translate                                               *)
+  (*    FT_Outline_Transform                                               *)
+  (*    FT_Outline_Embolden                                                *)
+  (*    FT_Outline_Reverse                                                 *)
+  (*    FT_Outline_Check                                                   *)
+  (*                                                                       *)
+  (*    FT_Outline_Get_CBox                                                *)
+  (*    FT_Outline_Get_BBox                                                *)
+  (*                                                                       *)
+  (*    FT_Outline_Get_Bitmap                                              *)
+  (*    FT_Outline_Render                                                  *)
+  (*                                                                       *)
+  (*    FT_Outline_Decompose                                               *)
+  (*    FT_Outline_Funcs                                                   *)
+  (*    FT_Outline_MoveTo_Func                                             *)
+  (*    FT_Outline_LineTo_Func                                             *)
+  (*    FT_Outline_ConicTo_Func                                            *)
+  (*    FT_Outline_CubicTo_Func                                            *)
+  (*                                                                       *)
+  (*************************************************************************)
+
+{$IFNDEF TYPE_DECL}
+
+  (*************************************************************************)
+  (*                                                                       *)
+  (* <Function>                                                            *)
+  (*    FT_Outline_Decompose                                               *)
+  (*                                                                       *)
+  (* <Description>                                                         *)
+  (*    Walks over an outline's structure to decompose it into individual  *)
+  (*    segments and Bézier arcs.  This function is also able to emit      *)
+  (*    `move to' and `close to' operations to indicate the start and end  *)
+  (*    of new contours in the outline.                                    *)
+  (*                                                                       *)
+  (* <Input>                                                               *)
+  (*    outline        :: A pointer to the source target.                  *)
+  (*                                                                       *)
+  (*    func_interface :: A table of `emitters', i.e,. function pointers   *)
+  (*                      called during decomposition to indicate path     *)
+  (*                      operations.                                      *)
+  (*                                                                       *)
+  (* <InOut>                                                               *)
+  (*    user           :: A typeless pointer which is passed to each       *)
+  (*                      emitter during the decomposition.  It can be     *)
+  (*                      used to store the state during the               *)
+  (*                      decomposition.                                   *)
+  (*                                                                       *)
+  (* <Return>                                                              *)
+  (*    FreeType error code.  0 means success.                             *)
+  (*                                                                       *)
+  function FT_Outline_Decompose(
+                        outline:        PFT_Outline;
+                        func_interface: {const} PFT_Outline_Funcs;
+                        user:           Pointer): FT_Error;
+    cdecl; external ft_lib name 'FT_Outline_Decompose';
+
+    
+  (*************************************************************************)
+  (*                                                                       *)
+  (* <Function>                                                            *)
+  (*    FT_Outline_New                                                     *)
+  (*                                                                       *)
+  (* <Description>                                                         *)
+  (*    Creates a new outline of a given size.                             *)
+  (*                                                                       *)
+  (* <Input>                                                               *)
+  (*    library     :: A handle to the library object from where the       *)
+  (*                   outline is allocated.  Note however that the new    *)
+  (*                   outline will *not* necessarily be *freed*, when     *)
+  (*                   destroying the library, by @FT_Done_FreeType.       *)
+  (*                                                                       *)
+  (*    numPoints   :: The maximal number of points within the outline.    *)
+  (*                                                                       *)
+  (*    numContours :: The maximal number of contours within the outline.  *)
+  (*                                                                       *)
+  (* <Output>                                                              *)
+  (*    anoutline   :: A handle to the new outline.  NULL in case of       *)
+  (*                   error.                                              *)
+  (*                                                                       *)
+  (* <Return>                                                              *)
+  (*    FreeType error code.  0 means success.                             *)
+  (*                                                                       *)
+  (* <Note>                                                                *)
+  (*    The reason why this function takes a `library' parameter is simply *)
+  (*    to use the library's memory allocator.                             *)
+  (*                                                                       *)
+  function FT_Outline_New(
+                  library_:    FT_Library;
+                  numPoints:   FT_UInt;
+                  numContours: FT_Int;
+                  anoutline:   PFT_Outline): FT_Error;
+    cdecl; external ft_lib name 'FT_Outline_New';
+
+                  
+  (*************************************************************************)
+  (*                                                                       *)
+  (* <Function>                                                            *)
+  (*    FT_Outline_Done                                                    *)
+  (*                                                                       *)
+  (* <Description>                                                         *)
+  (*    Destroys an outline created with @FT_Outline_New.                  *)
+  (*                                                                       *)
+  (* <Input>                                                               *)
+  (*    library :: A handle of the library object used to allocate the     *)
+  (*               outline.                                                *)
+  (*                                                                       *)
+  (*    outline :: A pointer to the outline object to be discarded.        *)
+  (*                                                                       *)
+  (* <Return>                                                              *)
+  (*    FreeType error code.  0 means success.                             *)
+  (*                                                                       *)
+  (* <Note>                                                                *)
+  (*    If the outline's `owner' field is not set, only the outline        *)
+  (*    descriptor will be released.                                       *)
+  (*                                                                       *)
+  (*    The reason why this function takes an `library' parameter is       *)
+  (*    simply to use ft_mem_free().                                       *)
+  (*                                                                       *)
+  function FT_Outline_Done(library_: FT_Library;
+                           outline:  PFT_Outline): FT_Error;
+    cdecl; external ft_lib name 'FT_Outline_Done';
+
+
+  (*************************************************************************)
+  (*                                                                       *)
+  (* <Function>                                                            *)
+  (*    FT_Outline_Check                                                   *)
+  (*                                                                       *)
+  (* <Description>                                                         *)
+  (*    Check the contents of an outline descriptor.                       *)
+  (*                                                                       *)
+  (* <Input>                                                               *)
+  (*    outline :: A handle to a source outline.                           *)
+  (*                                                                       *)
+  (* <Return>                                                              *)
+  (*    FreeType error code.  0 means success.                             *)
+  (*                                                                       *)
+  function FT_Outline_Check( outline: PFT_Outline ): FT_Error;
+    cdecl; external ft_lib name 'FT_Outline_Check';
+
+
+  (*************************************************************************)
+  (*                                                                       *)
+  (* <Function>                                                            *)
+  (*    FT_Outline_Get_CBox                                                *)
+  (*                                                                       *)
+  (* <Description>                                                         *)
+  (*    Returns an outline's `control box'.  The control box encloses all  *)
+  (*    the outline's points, including Bézier control points.  Though it  *)
+  (*    coincides with the exact bounding box for most glyphs, it can be   *)
+  (*    slightly larger in some situations (like when rotating an outline  *)
+  (*    which contains Bézier outside arcs).                               *)
+  (*                                                                       *)
+  (*    Computing the control box is very fast, while getting the bounding *)
+  (*    box can take much more time as it needs to walk over all segments  *)
+  (*    and arcs in the outline.  To get the latter, you can use the       *)
+  (*    `ftbbox' component which is dedicated to this single task.         *)
+  (*                                                                       *)
+  (* <Input>                                                               *)
+  (*    outline :: A pointer to the source outline descriptor.             *)
+  (*                                                                       *)
+  (* <Output>                                                              *)
+  (*    acbox   :: The outline's control box.                              *)
+  (*                                                                       *)
+  procedure FT_Outline_Get_CBox(
+                       outline: {const} PFT_Outline;
+                       acbox: PFT_BBox);
+    cdecl; external ft_lib name 'FT_Outline_Get_CBox';
+
+
+  (*************************************************************************)
+  (*                                                                       *)
+  (* <Function>                                                            *)
+  (*    FT_Outline_Translate                                               *)
+  (*                                                                       *)
+  (* <Description>                                                         *)
+  (*    Applies a simple translation to the points of an outline.          *)
+  (*                                                                       *)
+  (* <InOut>                                                               *)
+  (*    outline :: A pointer to the target outline descriptor.             *)
+  (*                                                                       *)
+  (* <Input>                                                               *)
+  (*    xOffset :: The horizontal offset.                                  *)
+  (*                                                                       *)
+  (*    yOffset :: The vertical offset.                                    *)
+  (*                                                                       *)
+  procedure FT_Outline_Translate(
+                        outline: {const} PFT_Outline;
+                        xOffset: FT_Pos;
+                        yOffset: FT_Pos);
+    cdecl; external ft_lib name 'FT_Outline_Translate';
+
+
+  (*************************************************************************)
+  (*                                                                       *)
+  (* <Function>                                                            *)
+  (*    FT_Outline_Copy                                                    *)
+  (*                                                                       *)
+  (* <Description>                                                         *)
+  (*    Copies an outline into another one.  Both objects must have the    *)
+  (*    same sizes (number of points & number of contours) when this       *)
+  (*    function is called.                                                *)
+  (*                                                                       *)
+  (* <Input>                                                               *)
+  (*    source :: A handle to the source outline.                          *)
+  (*                                                                       *)
+  (* <Output>                                                              *)
+  (*    target :: A handle to the target outline.                          *)
+  (*                                                                       *)
+  (* <Return>                                                              *)
+  (*    FreeType error code.  0 means success.                             *)
+  (*                                                                       *)
+  function FT_Outline_Copy(
+                   source: {const} PFT_Outline;
+                   target: PFT_Outline): FT_Error;
+    cdecl; external ft_lib name 'FT_Outline_Copy';
+
+
+  (*************************************************************************)
+  (*                                                                       *)
+  (* <Function>                                                            *)
+  (*    FT_Outline_Transform                                               *)
+  (*                                                                       *)
+  (* <Description>                                                         *)
+  (*    Applies a simple 2x2 matrix to all of an outline's points.  Useful *)
+  (*    for applying rotations, slanting, flipping, etc.                   *)
+  (*                                                                       *)
+  (* <InOut>                                                               *)
+  (*    outline :: A pointer to the target outline descriptor.             *)
+  (*                                                                       *)
+  (* <Input>                                                               *)
+  (*    matrix  :: A pointer to the transformation matrix.                 *)
+  (*                                                                       *)
+  (* <Note>                                                                *)
+  (*    You can use @FT_Outline_Translate if you need to translate the     *)
+  (*    outline's points.                                                  *)
+  (*                                                                       *)
+  procedure FT_Outline_Transform(
+                        outline: {const} PFT_Outline;
+                        matrix:  {const} PFT_Matrix);
+    cdecl; external ft_lib name 'FT_Outline_Transform';
+
+
+  (*************************************************************************)
+  (*                                                                       *)
+  (* <Function>                                                            *)
+  (*    FT_Outline_Embolden                                                *)
+  (*                                                                       *)
+  (* <Description>                                                         *)
+  (*    Emboldens an outline.  The new outline will be at most 4 times     *)
+  (*    `strength' pixels wider and higher.  You may think of the left and *)
+  (*    bottom borders as unchanged.                                       *)
+  (*                                                                       *)
+  (*    Negative `strength' values to reduce the outline thickness are     *)
+  (*    possible also.                                                     *)
+  (*                                                                       *)
+  (* <InOut>                                                               *)
+  (*    outline  :: A handle to the target outline.                        *)
+  (*                                                                       *)
+  (* <Input>                                                               *)
+  (*    strength :: How strong the glyph is emboldened.  Expressed in      *)
+  (*                26.6 pixel format.                                     *)
+  (*                                                                       *)
+  (* <Return>                                                              *)
+  (*    FreeType error code.  0 means success.                             *)
+  (*                                                                       *)
+  (* <Note>                                                                *)
+  (*    The used algorithm to increase or decrease the thickness of the    *)
+  (*    glyph doesn't change the number of points; this means that certain *)
+  (*    situations like acute angles or intersections are sometimes        *)
+  (*    handled incorrectly.                                               *)
+  (*                                                                       *)
+  (*    Example call:                                                      *)
+  (*                                                                       *)
+  (*    {                                                                  *)
+  (*      FT_Load_Glyph( face, index, FT_LOAD_DEFAULT );                   *)
+  (*      if ( face->slot->format == FT_GLYPH_FORMAT_OUTLINE )             *)
+  (*        FT_Outline_Embolden( &face->slot->outline, strength );         *)
+  (*    }                                                                  *)
+  (*                                                                       *)
+  function FT_Outline_Embolden(
+                       outline:  PFT_Outline;
+                       strength: FT_Pos): FT_Error;
+    cdecl; external ft_lib name 'FT_Outline_Embolden';
+
+
+  (*************************************************************************)
+  (*                                                                       *)
+  (* <Function>                                                            *)
+  (*    FT_Outline_Reverse                                                 *)
+  (*                                                                       *)
+  (* <Description>                                                         *)
+  (*    Reverses the drawing direction of an outline.  This is used to     *)
+  (*    ensure consistent fill conventions for mirrored glyphs.            *)
+  (*                                                                       *)
+  (* <InOut>                                                               *)
+  (*    outline :: A pointer to the target outline descriptor.             *)
+  (*                                                                       *)
+  (* <Note>                                                                *)
+  (*    This functions toggles the bit flag @FT_OUTLINE_REVERSE_FILL in    *)
+  (*    the outline's `flags' field.                                       *)
+  (*                                                                       *)
+  (*    It shouldn't be used by a normal client application, unless it     *)
+  (*    knows what it is doing.                                            *)
+  (*                                                                       *)
+  procedure FT_Outline_Reverse( outline: PFT_Outline );
+    cdecl; external ft_lib name 'FT_Outline_Reverse';
+
+
+  (*************************************************************************)
+  (*                                                                       *)
+  (* <Function>                                                            *)
+  (*    FT_Outline_Get_Bitmap                                              *)
+  (*                                                                       *)
+  (* <Description>                                                         *)
+  (*    Renders an outline within a bitmap.  The outline's image is simply *)
+  (*    OR-ed to the target bitmap.                                        *)
+  (*                                                                       *)
+  (* <Input>                                                               *)
+  (*    library :: A handle to a FreeType library object.                  *)
+  (*                                                                       *)
+  (*    outline :: A pointer to the source outline descriptor.             *)
+  (*                                                                       *)
+  (* <InOut>                                                               *)
+  (*    abitmap :: A pointer to the target bitmap descriptor.              *)
+  (*                                                                       *)
+  (* <Return>                                                              *)
+  (*    FreeType error code.  0 means success.                             *)
+  (*                                                                       *)
+  (* <Note>                                                                *)
+  (*    This function does NOT CREATE the bitmap, it only renders an       *)
+  (*    outline image within the one you pass to it!                       *)
+  (*                                                                       *)
+  (*    It will use the raster corresponding to the default glyph format.  *)
+  (*                                                                       *)
+  function FT_Outline_Get_Bitmap(
+                         library_: FT_Library;
+                         outline:  PFT_Outline;
+                         abitmap:  {const} PFT_Bitmap): FT_Error;
+    cdecl; external ft_lib name 'FT_Outline_Get_Bitmap';
+
+
+  (*************************************************************************)
+  (*                                                                       *)
+  (* <Function>                                                            *)
+  (*    FT_Outline_Render                                                  *)
+  (*                                                                       *)
+  (* <Description>                                                         *)
+  (*    Renders an outline within a bitmap using the current scan-convert. *)
+  (*    This functions uses an @FT_Raster_Params structure as an argument, *)
+  (*    allowing advanced features like direct composition, translucency,  *)
+  (*    etc.                                                               *)
+  (*                                                                       *)
+  (* <Input>                                                               *)
+  (*    library :: A handle to a FreeType library object.                  *)
+  (*                                                                       *)
+  (*    outline :: A pointer to the source outline descriptor.             *)
+  (*                                                                       *)
+  (* <InOut>                                                               *)
+  (*    params  :: A pointer to an @FT_Raster_Params structure used to     *)
+  (*               describe the rendering operation.                       *)
+  (*                                                                       *)
+  (* <Return>                                                              *)
+  (*    FreeType error code.  0 means success.                             *)
+  (*                                                                       *)
+  (* <Note>                                                                *)
+  (*    You should know what you are doing and how @FT_Raster_Params works *)
+  (*    to use this function.                                              *)
+  (*                                                                       *)
+  (*    The field `params.source' will be set to `outline' before the scan *)
+  (*    converter is called, which means that the value you give to it is  *)
+  (*    actually ignored.                                                  *)
+  (*                                                                       *)
+  function FT_Outline_Render(
+                     library_: FT_Library;
+                     outline: PFT_Outline;
+                     params:  PFT_Raster_Params): FT_Error;
+    cdecl; external ft_lib name 'FT_Outline_Render';
+
+{$ENDIF TYPE_DECL}
+
+ (**************************************************************************
+  *
+  * @enum:
+  *   FT_Orientation
+  *
+  * @description:
+  *   A list of values used to describe an outline's contour orientation.
+  *
+  *   The TrueType and Postscript specifications use different conventions
+  *   to determine whether outline contours should be filled or unfilled.
+  *
+  * @values:
+  *   FT_ORIENTATION_TRUETYPE ::
+  *     According to the TrueType specification, clockwise contours must
+  *     be filled, and counter-clockwise ones must be unfilled.
+  *
+  *   FT_ORIENTATION_POSTSCRIPT ::
+  *     According to the Postscript specification, counter-clockwise contours
+  *     must be filled, and clockwise ones must be unfilled.
+  *
+  *   FT_ORIENTATION_FILL_RIGHT ::
+  *     This is identical to @FT_ORIENTATION_TRUETYPE, but is used to
+  *     remember that in TrueType, everything that is to the right of
+  *     the drawing direction of a contour must be filled.
+  *
+  *   FT_ORIENTATION_FILL_LEFT ::
+  *     This is identical to @FT_ORIENTATION_POSTSCRIPT, but is used to
+  *     remember that in Postscript, everything that is to the left of
+  *     the drawing direction of a contour must be filled.
+  *
+  *   FT_ORIENTATION_NONE ::
+  *     The orientation cannot be determined.  That is, different parts of
+  *     the glyph have different orientation.
+  *
+  *)
+{$IFDEF TYPE_DECL}
+  FT_Orientation = cint;
+{$ELSE TYPE_DECL}
+const
+  FT_ORIENTATION_TRUETYPE   = 0;
+  FT_ORIENTATION_POSTSCRIPT = 1;
+  FT_ORIENTATION_FILL_RIGHT = FT_ORIENTATION_TRUETYPE;
+  FT_ORIENTATION_FILL_LEFT  = FT_ORIENTATION_POSTSCRIPT;
+  FT_ORIENTATION_NONE       = FT_ORIENTATION_FILL_LEFT+1;
+
+ (**************************************************************************
+  *
+  * @function:
+  *   FT_Outline_Get_Orientation
+  *
+  * @description:
+  *   This function analyzes a glyph outline and tries to compute its
+  *   fill orientation (see @FT_Orientation).  This is done by computing
+  *   the direction of each global horizontal and/or vertical extrema
+  *   within the outline.
+  *
+  *   Note that this will return @FT_ORIENTATION_TRUETYPE for empty
+  *   outlines.
+  *
+  * @input:
+  *   outline ::
+  *     A handle to the source outline.
+  *
+  * @return:
+  *   The orientation.
+  *
+  *)
+  function FT_Outline_Get_Orientation( outline: PFT_Outline ): FT_Orientation;
+    cdecl; external ft_lib name 'FT_Outline_Get_Orientation';
+
+{$ENDIF TYPE_DECL}
+  
diff --git a/Lua/src/lib/freetype/ftstroke.inc b/Lua/src/lib/freetype/ftstroke.inc
new file mode 100644
index 00000000..bf8a00ae
--- /dev/null
+++ b/Lua/src/lib/freetype/ftstroke.inc
@@ -0,0 +1,711 @@
+{***************************************************************************}
+{*                                                                         *}
+{*  ftstroke.h                                                             *}
+{*                                                                         *}
+{*    FreeType path stroker (specification).                               *}
+{*                                                                         *}
+{*  Copyright 2002, 2003, 2004, 2005, 2006 by                              *}
+{*  David Turner, Robert Wilhelm, and Werner Lemberg.                      *}
+{*                                                                         *}
+{*  This file is part of the FreeType project, and may only be used,       *}
+{*  modified, and distributed under the terms of the FreeType project      *}
+{*  license, LICENSE.TXT.  By continuing to use, modify, or distribute     *}
+{*  this file you indicate that you have read the license and              *}
+{*  understand and accept it fully.                                        *}
+{*                                                                         *}
+{***************************************************************************}
+(***************************************************************************)
+(* Pascal port by the UltraStar Deluxe Team                                *)
+(***************************************************************************)
+
+ {************************************************************************
+  *
+  * @section:
+  *    glyph_stroker
+  *
+  * @title:
+  *    Glyph Stroker
+  *
+  * @abstract:
+  *    Generating bordered and stroked glyphs.
+  *
+  * @description:
+  *    This component generates stroked outlines of a given vectorial
+  *    glyph.  It also allows you to retrieve the `outside' and/or the
+  *    `inside' borders of the stroke.
+  *
+  *    This can be useful to generate `bordered' glyph, i.e., glyphs
+  *    displayed with a coloured (and anti-aliased) border around their
+  *    shape.
+  *}
+
+{$IFDEF TYPE_DECL}
+
+ {**************************************************************
+  *
+  * @type:
+  *   FT_Stroker
+  *
+  * @description:
+  *   Opaque handler to a path stroker object.
+  *}
+   FT_Stroker = Pointer;
+
+
+  {**************************************************************
+   *
+   * @enum:
+   *   FT_Stroker_LineJoin
+   *
+   * @description:
+   *   These values determine how two joining lines are rendered
+   *   in a stroker.
+   *
+   * @values:
+   *   FT_STROKER_LINEJOIN_ROUND ::
+   *     Used to render rounded line joins.  Circular arcs are used
+   *     to join two lines smoothly.
+   *
+   *   FT_STROKER_LINEJOIN_BEVEL ::
+   *     Used to render beveled line joins; i.e., the two joining lines
+   *     are extended until they intersect.
+   *
+   *   FT_STROKER_LINEJOIN_MITER ::
+   *     Same as beveled rendering, except that an additional line
+   *     break is added if the angle between the two joining lines
+   *     is too closed (this is useful to avoid unpleasant spikes
+   *     in beveled rendering).
+   *}
+    FT_Stroker_LineJoin = cint;
+{$ELSE TYPE_DECL}
+const
+    FT_STROKER_LINEJOIN_ROUND = 0;
+    FT_STROKER_LINEJOIN_BEVEL = 1;
+    FT_STROKER_LINEJOIN_MITER = 2;
+
+{$ENDIF TYPE_DECL}
+{$IFDEF TYPE_DECL}
+
+  {**************************************************************
+   *
+   * @enum:
+   *   FT_Stroker_LineCap
+   *
+   * @description:
+   *   These values determine how the end of opened sub-paths are
+   *   rendered in a stroke.
+   *
+   * @values:
+   *   FT_STROKER_LINECAP_BUTT ::
+   *     The end of lines is rendered as a full stop on the last
+   *     point itself.
+   *
+   *   FT_STROKER_LINECAP_ROUND ::
+   *     The end of lines is rendered as a half-circle around the
+   *     last point.
+   *
+   *   FT_STROKER_LINECAP_SQUARE ::
+   *     The end of lines is rendered as a square around the
+   *     last point.
+   *}
+    FT_Stroker_LineCap = cint;
+{$ELSE TYPE_DECL}
+const
+    FT_STROKER_LINECAP_BUTT   = 0;
+    FT_STROKER_LINECAP_ROUND  = 1;
+    FT_STROKER_LINECAP_SQUARE = 2;
+
+{$ENDIF TYPE_DECL}
+{$IFDEF TYPE_DECL}
+
+  {**************************************************************
+   *
+   * @enum:
+   *   FT_StrokerBorder
+   *
+   * @description:
+   *   These values are used to select a given stroke border
+   *   in @FT_Stroker_GetBorderCounts and @FT_Stroker_ExportBorder.
+   *
+   * @values:
+   *   FT_STROKER_BORDER_LEFT ::
+   *     Select the left border, relative to the drawing direction.
+   *
+   *   FT_STROKER_BORDER_RIGHT ::
+   *     Select the right border, relative to the drawing direction.
+   *
+   * @note:
+   *   Applications are generally interested in the `inside' and `outside'
+   *   borders.  However, there is no direct mapping between these and the
+   *   `left' and `right' ones, since this really depends on the glyph's
+   *   drawing orientation, which varies between font formats.
+   *
+   *   You can however use @FT_Outline_GetInsideBorder and
+   *   @FT_Outline_GetOutsideBorder to get these.
+   *}
+    FT_StrokerBorder = cint;
+{$ELSE TYPE_DECL}
+const
+    FT_STROKER_BORDER_LEFT  = 0;
+    FT_STROKER_BORDER_RIGHT = 1;
+
+
+  {**************************************************************
+   *
+   * @function:
+   *   FT_Outline_GetInsideBorder
+   *
+   * @description:
+   *   Retrieve the @FT_StrokerBorder value corresponding to the
+   *   `inside' borders of a given outline.
+   *
+   * @input:
+   *   outline ::
+   *     The source outline handle.
+   *
+   * @return:
+   *   The border index.  @FT_STROKER_BORDER_LEFT for empty or invalid
+   *   outlines.
+   *}
+  function FT_Outline_GetInsideBorder( outline: PFT_Outline ): FT_StrokerBorder;
+    cdecl; external ft_lib name 'FT_Outline_GetInsideBorder';
+
+
+  {**************************************************************
+   *
+   * @function:
+   *   FT_Outline_GetOutsideBorder
+   *
+   * @description:
+   *   Retrieve the @FT_StrokerBorder value corresponding to the
+   *   `outside' borders of a given outline.
+   *
+   * @input:
+   *   outline ::
+   *     The source outline handle.
+   *
+   * @return:
+   *   The border index.  @FT_STROKER_BORDER_LEFT for empty or invalid
+   *   outlines.
+   *}
+  function FT_Outline_GetOutsideBorder( outline: PFT_Outline ): FT_StrokerBorder;
+    cdecl; external ft_lib name 'FT_Outline_GetOutsideBorder';
+
+
+  {**************************************************************
+   *
+   * @function:
+   *   FT_Stroker_New
+   *
+   * @description:
+   *   Create a new stroker object.
+   *
+   * @input:
+   *   library ::
+   *     FreeType library handle.
+   *
+   * @output:
+   *   astroker ::
+   *     A new stroker object handle.  NULL in case of error.
+   *
+   * @return:
+   *    FreeType error code.  0 means success.
+   *}
+  function FT_Stroker_New(
+                  library_: FT_Library;
+                  out astroker: FT_Stroker ): FT_Error;
+    cdecl; external ft_lib name 'FT_Stroker_New';
+
+
+  {**************************************************************
+   *
+   * @function:
+   *   FT_Stroker_Set
+   *
+   * @description:
+   *   Reset a stroker object's attributes.
+   *
+   * @input:
+   *   stroker ::
+   *     The target stroker handle.
+   *
+   *   radius ::
+   *     The border radius.
+   *
+   *   line_cap ::
+   *     The line cap style.
+   *
+   *   line_join ::
+   *     The line join style.
+   *
+   *   miter_limit ::
+   *     The miter limit for the FT_STROKER_LINEJOIN_MITER style,
+   *     expressed as 16.16 fixed point value.
+   *
+   * @note:
+   *   The radius is expressed in the same units that the outline
+   *   coordinates.
+   *}
+  procedure FT_Stroker_Set(
+                  stroker:     FT_Stroker;
+                  radius:      FT_Fixed;
+                  line_cap:    FT_Stroker_LineCap;
+                  line_join:   FT_Stroker_LineJoin;
+                  miter_limit: FT_Fixed );
+    cdecl; external ft_lib name 'FT_Stroker_Set';
+
+
+  {**************************************************************
+   *
+   * @function:
+   *   FT_Stroker_Rewind
+   *
+   * @description:
+   *   Reset a stroker object without changing its attributes.
+   *   You should call this function before beginning a new
+   *   series of calls to @FT_Stroker_BeginSubPath or
+   *   @FT_Stroker_EndSubPath.
+   *
+   * @input:
+   *   stroker ::
+   *     The target stroker handle.
+   *}
+  procedure FT_Stroker_Rewind( stroker: FT_Stroker );
+    cdecl; external ft_lib name 'FT_Stroker_Rewind';
+
+
+  {**************************************************************
+   *
+   * @function:
+   *   FT_Stroker_ParseOutline
+   *
+   * @description:
+   *   A convenience function used to parse a whole outline with
+   *   the stroker.  The resulting outline(s) can be retrieved
+   *   later by functions like @FT_Stroker_GetCounts and @FT_Stroker_Export.
+   *
+   * @input:
+   *   stroker ::
+   *     The target stroker handle.
+   *
+   *   outline ::
+   *     The source outline.
+   *
+   *   opened ::
+   *     A boolean.  If 1, the outline is treated as an open path instead
+   *     of a closed one.
+   *
+   * @return:
+   *   FreeType error code.  0 means success.
+   *
+   * @note:
+   *   If `opened' is 0 (the default), the outline is treated as a closed
+   *   path, and the stroker will generate two distinct `border' outlines.
+   *
+   *   If `opened' is 1, the outline is processed as an open path, and the
+   *   stroker will generate a single `stroke' outline.
+   *
+   *   This function calls @FT_Stroker_Rewind automatically.
+   *}
+  function FT_Stroker_ParseOutline(
+                           stroker: FT_Stroker;
+                           outline: PFT_Outline;
+                           opened:  FT_Bool): FT_Error;
+    cdecl; external ft_lib name 'FT_Stroker_ParseOutline';
+
+
+  {**************************************************************
+   *
+   * @function:
+   *   FT_Stroker_BeginSubPath
+   *
+   * @description:
+   *   Start a new sub-path in the stroker.
+   *
+   * @input:
+   *   stroker ::
+   *     The target stroker handle.
+   *
+   *   to ::
+   *     A pointer to the start vector.
+   *
+   *   open ::
+   *     A boolean.  If 1, the sub-path is treated as an open one.
+   *
+   * @return:
+   *   FreeType error code.  0 means success.
+   *
+   * @note:
+   *   This function is useful when you need to stroke a path that is
+   *   not stored as an @FT_Outline object.
+   *}
+  function FT_Stroker_BeginSubPath(
+                           stroker: FT_Stroker;
+                           to_:     PFT_Vector;
+                           open:    FT_Bool ): FT_Error;
+    cdecl; external ft_lib name 'FT_Stroker_BeginSubPath';
+
+
+  {**************************************************************
+   *
+   * @function:
+   *   FT_Stroker_EndSubPath
+   *
+   * @description:
+   *   Close the current sub-path in the stroker.
+   *
+   * @input:
+   *   stroker ::
+   *     The target stroker handle.
+   *
+   * @return:
+   *   FreeType error code.  0 means success.
+   *
+   * @note:
+   *   You should call this function after @FT_Stroker_BeginSubPath.
+   *   If the subpath was not `opened', this function will `draw' a
+   *   single line segment to the start position when needed.
+   *}
+  function FT_Stroker_EndSubPath( stroker: FT_Stroker ): FT_Error;
+    cdecl; external ft_lib name 'FT_Stroker_EndSubPath';
+
+
+  {**************************************************************
+   *
+   * @function:
+   *   FT_Stroker_LineTo
+   *
+   * @description:
+   *   `Draw' a single line segment in the stroker's current sub-path,
+   *   from the last position.
+   *
+   * @input:
+   *   stroker ::
+   *     The target stroker handle.
+   *
+   *   to ::
+   *     A pointer to the destination point.
+   *
+   * @return:
+   *   FreeType error code.  0 means success.
+   *
+   * @note:
+   *   You should call this function between @FT_Stroker_BeginSubPath and
+   *   @FT_Stroker_EndSubPath.
+   *}
+  function FT_Stroker_LineTo(
+                     stroker: FT_Stroker;
+                     to_:     PFT_Vector ): FT_Error;
+    cdecl; external ft_lib name 'FT_Stroker_LineTo';
+
+
+  {**************************************************************
+   *
+   * @function:
+   *   FT_Stroker_ConicTo
+   *
+   * @description:
+   *   `Draw' a single quadratic Bézier in the stroker's current sub-path,
+   *   from the last position.
+   *
+   * @input:
+   *   stroker ::
+   *     The target stroker handle.
+   *
+   *   control ::
+   *     A pointer to a Bézier control point.
+   *
+   *   to ::
+   *     A pointer to the destination point.
+   *
+   * @return:
+   *   FreeType error code.  0 means success.
+   *
+   * @note:
+   *   You should call this function between @FT_Stroker_BeginSubPath and
+   *   @FT_Stroker_EndSubPath.
+   *}
+  function FT_Stroker_ConicTo(
+                      stroker: FT_Stroker;
+                      control: PFT_Vector;
+                      to_:     PFT_Vector ): FT_Error;
+    cdecl; external ft_lib name 'FT_Stroker_ConicTo';
+
+
+  {**************************************************************
+   *
+   * @function:
+   *   FT_Stroker_CubicTo
+   *
+   * @description:
+   *   `Draw' a single cubic Bézier in the stroker's current sub-path,
+   *   from the last position.
+   *
+   * @input:
+   *   stroker ::
+   *     The target stroker handle.
+   *
+   *   control1 ::
+   *     A pointer to the first Bézier control point.
+   *
+   *   control2 ::
+   *     A pointer to second Bézier control point.
+   *
+   *   to ::
+   *     A pointer to the destination point.
+   *
+   * @return:
+   *   FreeType error code.  0 means success.
+   *
+   * @note:
+   *   You should call this function between @FT_Stroker_BeginSubPath and
+   *   @FT_Stroker_EndSubPath.
+   *}
+  function FT_Stroker_CubicTo(
+                      stroker:  FT_Stroker;
+                      control1: PFT_Vector;
+                      control2: PFT_Vector;
+                      to_:      PFT_Vector ): FT_Error;
+    cdecl; external ft_lib name 'FT_Stroker_CubicTo';
+
+
+  {**************************************************************
+   *
+   * @function:
+   *   FT_Stroker_GetBorderCounts
+   *
+   * @description:
+   *   Call this function once you have finished parsing your paths
+   *   with the stroker.  It will return the number of points and
+   *   contours necessary to export one of the `border' or `stroke'
+   *   outlines generated by the stroker.
+   *
+   * @input:
+   *   stroker ::
+   *     The target stroker handle.
+   *
+   *   border ::
+   *     The border index.
+   *
+   * @output:
+   *   anum_points ::
+   *     The number of points.
+   *
+   *   anum_contours ::
+   *     The number of contours.
+   *
+   * @return:
+   *   FreeType error code.  0 means success.
+   *
+   * @note:
+   *   When an outline, or a sub-path, is `closed', the stroker generates
+   *   two independent `border' outlines, named `left' and `right'.
+   *
+   *   When the outline, or a sub-path, is `opened', the stroker merges
+   *   the `border' outlines with caps.  The `left' border receives all
+   *   points, while the `right' border becomes empty.
+   *
+   *   Use the function @FT_Stroker_GetCounts instead if you want to
+   *   retrieve the counts associated to both borders.
+   *}
+  function FT_Stroker_GetBorderCounts(
+                              stroker:           FT_Stroker;
+                              border:            FT_StrokerBorder;
+                              out anum_points:   FT_UInt;
+                              out anum_contours: FT_UInt ): FT_Error;
+    cdecl; external ft_lib name 'FT_Stroker_GetBorderCounts';
+
+
+  {**************************************************************
+   *
+   * @function:
+   *   FT_Stroker_ExportBorder
+   *
+   * @description:
+   *   Call this function after @FT_Stroker_GetBorderCounts to
+   *   export the corresponding border to your own @FT_Outline
+   *   structure.
+   *
+   *   Note that this function will append the border points and
+   *   contours to your outline, but will not try to resize its
+   *   arrays.
+   *
+   * @input:
+   *   stroker ::
+   *     The target stroker handle.
+   *
+   *   border ::
+   *     The border index.
+   *
+   *   outline ::
+   *     The target outline handle.
+   *
+   * @note:
+   *   Always call this function after @FT_Stroker_GetBorderCounts to
+   *   get sure that there is enough room in your @FT_Outline object to
+   *   receive all new data.
+   *
+   *   When an outline, or a sub-path, is `closed', the stroker generates
+   *   two independent `border' outlines, named `left' and `right'
+   *
+   *   When the outline, or a sub-path, is `opened', the stroker merges
+   *   the `border' outlines with caps. The `left' border receives all
+   *   points, while the `right' border becomes empty.
+   *
+   *   Use the function @FT_Stroker_Export instead if you want to
+   *   retrieve all borders at once.
+   *}
+  procedure FT_Stroker_ExportBorder(
+                           stroker: FT_Stroker;
+                           border:  FT_StrokerBorder;
+                           outline: PFT_Outline );
+    cdecl; external ft_lib name 'FT_Stroker_ExportBorder';
+
+
+  {**************************************************************
+   *
+   * @function:
+   *   FT_Stroker_GetCounts
+   *
+   * @description:
+   *   Call this function once you have finished parsing your paths
+   *   with the stroker.  It returns the number of points and
+   *   contours necessary to export all points/borders from the stroked
+   *   outline/path.
+   *
+   * @input:
+   *   stroker ::
+   *     The target stroker handle.
+   *
+   * @output:
+   *   anum_points ::
+   *     The number of points.
+   *
+   *   anum_contours ::
+   *     The number of contours.
+   *
+   * @return:
+   *   FreeType error code.  0 means success.
+   *}
+  function FT_Stroker_GetCounts(
+                        stroker:           FT_Stroker;
+                        out anum_points:   FT_UInt;
+                        out anum_contours: FT_UInt ): FT_Error;
+     cdecl; external ft_lib name 'FT_Stroker_GetCounts';
+
+
+  {**************************************************************
+   *
+   * @function:
+   *   FT_Stroker_Export
+   *
+   * @description:
+   *   Call this function after @FT_Stroker_GetBorderCounts to
+   *   export the all borders to your own @FT_Outline structure.
+   *
+   *   Note that this function will append the border points and
+   *   contours to your outline, but will not try to resize its
+   *   arrays.
+   *
+   * @input:
+   *   stroker ::
+   *     The target stroker handle.
+   *
+   *   outline ::
+   *     The target outline handle.
+   *}
+  procedure FT_Stroker_Export(
+                     stroker: FT_Stroker;
+                     outline: PFT_Outline );
+     cdecl; external ft_lib name 'FT_Stroker_Export';
+
+
+  {**************************************************************
+   *
+   * @function:
+   *   FT_Stroker_Done
+   *
+   * @description:
+   *   Destroy a stroker object.
+   *
+   * @input:
+   *   stroker ::
+   *     A stroker handle.  Can be NULL.
+   *}
+  procedure FT_Stroker_Done( stroker: FT_Stroker );
+     cdecl; external ft_lib name 'FT_Stroker_Done';
+
+
+  {**************************************************************
+   *
+   * @function:
+   *   FT_Glyph_Stroke
+   *
+   * @description:
+   *   Stroke a given outline glyph object with a given stroker.
+   *
+   * @inout:
+   *   pglyph ::
+   *     Source glyph handle on input, new glyph handle on output.
+   *
+   * @input:
+   *   stroker ::
+   *     A stroker handle.
+   *
+   *   destroy ::
+   *     A Boolean.  If 1, the source glyph object is destroyed
+   *     on success.
+   *
+   * @return:
+   *    FreeType error code.  0 means success.
+   *
+   * @note:
+   *   The source glyph is untouched in case of error.
+   *}
+  function FT_Glyph_Stroke(
+                   var glyph: FT_Glyph;
+                   stroker: FT_Stroker;
+                   destroy: FT_Bool ): FT_Error;
+     cdecl; external ft_lib name 'FT_Glyph_Stroke';
+
+
+  {**************************************************************
+   *
+   * @function:
+   *   FT_Glyph_StrokeBorder
+   *
+   * @description:
+   *   Stroke a given outline glyph object with a given stroker, but
+   *   only return either its inside or outside border.
+   *
+   * @inout:
+   *   pglyph ::
+   *     Source glyph handle on input, new glyph handle on output.
+   *
+   * @input:
+   *   stroker ::
+   *     A stroker handle.
+   *
+   *   inside ::
+   *     A Boolean.  If 1, return the inside border, otherwise
+   *     the outside border.
+   *
+   *   destroy ::
+   *     A Boolean.  If 1, the source glyph object is destroyed
+   *     on success.
+   *
+   * @return:
+   *    FreeType error code.  0 means success.
+   *
+   * @note:
+   *   The source glyph is untouched in case of error.
+   *}
+  function FT_Glyph_StrokeBorder(
+                         var glyph: FT_Glyph;
+                         stroker:   FT_Stroker;
+                         inside:    FT_Bool;
+                         destroy:   FT_Bool ): FT_Error;
+     cdecl; external ft_lib name 'FT_Glyph_StrokeBorder';
+
+{$ENDIF TYPE_DECL}
+
diff --git a/Lua/src/lib/freetype/fttypes.inc b/Lua/src/lib/freetype/fttypes.inc
new file mode 100644
index 00000000..a64432e6
--- /dev/null
+++ b/Lua/src/lib/freetype/fttypes.inc
@@ -0,0 +1,311 @@
+(***************************************************************************)
+(*                                                                         *)
+(*  fttypes.h                                                              *)
+(*                                                                         *)
+(*    FreeType simple types definitions (specification only).              *)
+(*                                                                         *)
+(*  Copyright 1996-2001, 2002, 2004, 2006, 2007 by                         *)
+(*  David Turner, Robert Wilhelm, and Werner Lemberg.                      *)
+(*                                                                         *)
+(*  This file is part of the FreeType project, and may only be used,       *)
+(*  modified, and distributed under the terms of the FreeType project      *)
+(*  license, LICENSE.TXT.  By continuing to use, modify, or distribute     *)
+(*  this file you indicate that you have read the license and              *)
+(*  understand and accept it fully.                                        *)
+(*                                                                         *)
+(***************************************************************************)
+(***************************************************************************)
+(* Pascal port by the UltraStar Deluxe Team                                *)
+(***************************************************************************)
+
+  (*************************************************************************)
+  (*                                                                       *)
+  (* <Section>                                                             *)
+  (*    basic_types                                                        *)
+  (*                                                                       *)
+  (* <Title>                                                               *)
+  (*    Basic Data Types                                                   *)
+  (*                                                                       *)
+  (* <Abstract>                                                            *)
+  (*    The basic data types defined by the library.                       *)
+  (*                                                                       *)
+  (* <Description>                                                         *)
+  (*    This section contains the basic data types defined by FreeType 2,  *)
+  (*    ranging from simple scalar types to bitmap descriptors.  More      *)
+  (*    font-specific structures are defined in a different section.       *)
+  (*                                                                       *)
+  (* <Order>                                                               *)
+  (*    FT_Byte                                                            *)
+  (*    FT_Bytes                                                           *)
+  (*    FT_Char                                                            *)
+  (*    FT_Int                                                             *)
+  (*    FT_UInt                                                            *)
+  (*    FT_Short                                                           *)
+  (*    FT_UShort                                                          *)
+  (*    FT_Long                                                            *)
+  (*    FT_ULong                                                           *)
+  (*    FT_Bool                                                            *)
+  (*    FT_Offset                                                          *)
+  (*    FT_PtrDist                                                         *)
+  (*    FT_String                                                          *)
+  (*    FT_Tag                                                             *)
+  (*    FT_Error                                                           *)
+  (*    FT_Fixed                                                           *)
+  (*    FT_Pointer                                                         *)
+  (*    FT_Pos                                                             *)
+  (*    FT_Vector                                                          *)
+  (*    FT_BBox                                                            *)
+  (*    FT_Matrix                                                          *)
+  (*    FT_FWord                                                           *)
+  (*    FT_UFWord                                                          *)
+  (*    FT_F2Dot14                                                         *)
+  (*    FT_UnitVector                                                      *)
+  (*    FT_F26Dot6                                                         *)
+  (*                                                                       *)
+  (*                                                                       *)
+  (*    FT_Generic                                                         *)
+  (*    FT_Generic_Finalizer                                               *)
+  (*                                                                       *)
+  (*    FT_Bitmap                                                          *)
+  (*    FT_Pixel_Mode                                                      *)
+  (*    FT_Palette_Mode                                                    *)
+  (*    FT_Glyph_Format                                                    *)
+  (*    FT_IMAGE_TAG                                                       *)
+  (*                                                                       *)
+  (*************************************************************************)
+
+{$IFDEF TYPE_DECL}
+
+  (*************************************************************************)
+  (*                                                                       *)
+  (* <Type>                                                                *)
+  (*    FT_Bool                                                            *)
+  (*                                                                       *)
+  (* <Description>                                                         *)
+  (*    A typedef of unsigned char, used for simple booleans.  As usual,   *)
+  (*    values 1 and 0 represent true and false, respectively.             *)
+  (*                                                                       *)
+  FT_Bool    = cuchar;
+{$ENDIF TYPE_DECL}
+{$IFNDEF TYPE_DECL}
+const
+  FT_FALSE = 0;
+  FT_TRUE  = 1;
+{$ENDIF !TYPE_DECL}
+{$IFDEF TYPE_DECL}
+
+  (*************************************************************************)
+  (*                                                                       *)
+  (* <Type>                                                                *)
+  (*    FT_Byte                                                            *)
+  (*                                                                       *)
+  (* <Description>                                                         *)
+  (*    A simple typedef for the _unsigned_ char type.                     *)
+  (*                                                                       *)
+  FT_Byte    = cuchar;
+  PFT_Byte   = ^FT_Byte;
+
+
+  (*************************************************************************)
+  (*                                                                       *)
+  (* <Type>                                                                *)
+  (*    FT_String                                                          *)
+  (*                                                                       *)
+  (* <Description>                                                         *)
+  (*    A simple typedef for the char type, usually used for strings.      *)
+  (*                                                                       *)
+  FT_String  = cchar;
+  PFT_String = ^FT_String;
+
+  
+  (*************************************************************************)
+  (*                                                                       *)
+  (* <Type>                                                                *)
+  (*    FT_Short                                                           *)
+  (*                                                                       *)
+  (* <Description>                                                         *)
+  (*    A typedef for signed short.                                        *)
+  (*                                                                       *)
+  FT_Short   = csshort;
+  PFT_Short  = ^FT_Short;
+
+  PFT_ShortArray = ^FT_ShortArray;
+  FT_ShortArray = array[0 .. (MaxInt div SizeOf(FT_Short))-1] of FT_Short;
+
+  (*************************************************************************)
+  (*                                                                       *)
+  (* <Type>                                                                *)
+  (*    FT_UShort                                                          *)
+  (*                                                                       *)
+  (* <Description>                                                         *)
+  (*    A typedef for unsigned short.                                      *)
+  (*                                                                       *)
+  FT_UShort  = cushort;
+
+
+  (*************************************************************************)
+  (*                                                                       *)
+  (* <Type>                                                                *)
+  (*    FT_Int                                                             *)
+  (*                                                                       *)
+  (* <Description>                                                         *)
+  (*    A typedef for the int type.                                        *)
+  (*                                                                       *)
+  FT_Int     = csint;
+
+
+  (*************************************************************************)
+  (*                                                                       *)
+  (* <Type>                                                                *)
+  (*    FT_UInt                                                            *)
+  (*                                                                       *)
+  (* <Description>                                                         *)
+  (*    A typedef for the unsigned int type.                               *)
+  (*                                                                       *)
+  FT_UInt    = cuint;
+
+
+  (*************************************************************************)
+  (*                                                                       *)
+  (* <Type>                                                                *)
+  (*    FT_Long                                                            *)
+  (*                                                                       *)
+  (* <Description>                                                         *)
+  (*    A typedef for signed long.                                         *)
+  (*                                                                       *)
+  FT_Long    = cslong;
+
+
+  (*************************************************************************)
+  (*                                                                       *)
+  (* <Type>                                                                *)
+  (*    FT_ULong                                                           *)
+  (*                                                                       *)
+  (* <Description>                                                         *)
+  (*    A typedef for unsigned long.                                       *)
+  (*                                                                       *)
+  FT_ULong   = culong;
+
+
+  (*************************************************************************)
+  (*                                                                       *)
+  (* <Type>                                                                *)
+  (*    FT_F26Dot6                                                         *)
+  (*                                                                       *)
+  (* <Description>                                                         *)
+  (*    A signed 26.6 fixed float type used for vectorial pixel            *)
+  (*    coordinates.                                                       *)
+  (*                                                                       *)
+  FT_F26Dot6 = cslong;
+
+
+  (*************************************************************************)
+  (*                                                                       *)
+  (* <Type>                                                                *)
+  (*    FT_Fixed                                                           *)
+  (*                                                                       *)
+  (* <Description>                                                         *)
+  (*    This type is used to store 16.16 fixed float values, like scaling  *)
+  (*    values or matrix coefficients.                                     *)
+  (*                                                                       *)
+  FT_Fixed   = cslong;
+
+
+  (*************************************************************************)
+  (*                                                                       *)
+  (* <Type>                                                                *)
+  (*    FT_Error                                                           *)
+  (*                                                                       *)
+  (* <Description>                                                         *)
+  (*    The FreeType error code type.  A value of 0 is always interpreted  *)
+  (*    as a successful operation.                                         *)
+  (*                                                                       *)
+  FT_Error   = cint;
+
+
+  (*************************************************************************)
+  (*                                                                       *)
+  (* <Struct>                                                              *)
+  (*    FT_Matrix                                                          *)
+  (*                                                                       *)
+  (* <Description>                                                         *)
+  (*    A simple structure used to store a 2x2 matrix.  Coefficients are   *)
+  (*    in 16.16 fixed float format.  The computation performed is:        *)
+  (*                                                                       *)
+  (*       {                                                               *)
+  (*          x' = x*xx + y*xy                                             *)
+  (*          y' = x*yx + y*yy                                             *)
+  (*       }                                                               *)
+  (*                                                                       *)
+  (* <Fields>                                                              *)
+  (*    xx :: Matrix coefficient.                                          *)
+  (*                                                                       *)
+  (*    xy :: Matrix coefficient.                                          *)
+  (*                                                                       *)
+  (*    yx :: Matrix coefficient.                                          *)
+  (*                                                                       *)
+  (*    yy :: Matrix coefficient.                                          *)
+  (*                                                                       *)
+  PFT_Matrix = ^FT_Matrix;
+  FT_Matrix = record
+    xx, xy: FT_Fixed;
+    yx, yy: FT_Fixed;
+  end;
+
+  
+  (*************************************************************************)
+  (*                                                                       *)
+  (* <FuncType>                                                            *)
+  (*    FT_Generic_Finalizer                                               *)
+  (*                                                                       *)
+  (* <Description>                                                         *)
+  (*    Describes a function used to destroy the `client' data of any      *)
+  (*    FreeType object.  See the description of the FT_Generic type for   *)
+  (*    details of usage.                                                  *)
+  (*                                                                       *)
+  (* <Input>                                                               *)
+  (*    The address of the FreeType object which is under finalization.    *)
+  (*    Its client data is accessed through its `generic' field.           *)
+  (*                                                                       *)
+  FT_Generic_Finalizer = procedure(AnObject : pointer ); cdecl;
+
+
+  (*************************************************************************)
+  (*                                                                       *)
+  (* <Struct>                                                              *)
+  (*    FT_Generic                                                         *)
+  (*                                                                       *)
+  (* <Description>                                                         *)
+  (*    Client applications often need to associate their own data to a    *)
+  (*    variety of FreeType core objects.  For example, a text layout API  *)
+  (*    might want to associate a glyph cache to a given size object.      *)
+  (*                                                                       *)
+  (*    Most FreeType object contains a `generic' field, of type           *)
+  (*    FT_Generic, which usage is left to client applications and font    *)
+  (*    servers.                                                           *)
+  (*                                                                       *)
+  (*    It can be used to store a pointer to client-specific data, as well *)
+  (*    as the address of a `finalizer' function, which will be called by  *)
+  (*    FreeType when the object is destroyed (for example, the previous   *)
+  (*    client example would put the address of the glyph cache destructor *)
+  (*    in the `finalizer' field).                                         *)
+  (*                                                                       *)
+  (* <Fields>                                                              *)
+  (*    data      :: A typeless pointer to any client-specified data. This *)
+  (*                 field is completely ignored by the FreeType library.  *)
+  (*                                                                       *)
+  (*    finalizer :: A pointer to a `generic finalizer' function, which    *)
+  (*                 will be called when the object is destroyed.  If this *)
+  (*                 field is set to NULL, no code will be called.         *)
+  (*                                                                       *)
+  FT_Generic = record
+    data:      pointer;
+    finalizer: FT_Generic_Finalizer;
+  end;
+
+
+  TByteArray = array [0 .. (MaxInt div SizeOf(byte))-1] of byte;
+  PByteArray = ^TByteArray;
+
+{$ENDIF TYPE_DECL}
+
diff --git a/Lua/src/lib/lib-info.txt b/Lua/src/lib/lib-info.txt
index 59502c7a..0a184568 100644
--- a/Lua/src/lib/lib-info.txt
+++ b/Lua/src/lib/lib-info.txt
@@ -1,60 +1,60 @@
-bass:
-http://www.un4seen.com/ (2.4.2.1)
-- FPC Mac OS X compatibility fixes
-
-fft:
-translation of audacity's FFT.cpp by hennymcc (maybe replace this with FFTW?)
-
-ffmpeg:
-- http://www.iversenit.dk/dev/ffmpeg-headers/: 2006-10
-- several bugs were fixed
-- many IFDEFS were added to the header to support multiple versions of ffmpeg (starting with end of 2006) and not only one specific version. This is necessary as we cannot control which version is used on linux. We could ship the ffmpeg lib with USDX and link statically but a stripped down ffmpeg is 15MB in size and takes 5 minutes to compile (so static linkage is not a good option).
-- the headers were updated to reflect the changes in the ffmpeg C-headers (http://svn.mplayerhq.hu/ffmpeg/trunk/ and http://svn.mplayerhq.hu/mplayer/trunk/libswscale/)
-
-freeimage:
-- inserted by eddie. Some compatibility fixes for platforms different than mac os x.
-- not used anymore
-
-freetype:
-- based on the AggPas (http://aggpas.org/) headers
-- just a minimal header that contains only some of the freetype functions and types. Some functions and structures/constants/types needed for USDX were added.
-- some comments added
-
-jedi-sdl:
-JEDI-SDL v1.0 Final RC 2 (http://jedi-sdl.pascalgamedevelopment.com/)
-- 64bit compatibility patch (http://sourceforge.net/tracker/index.php?func=detail&aid=1902924&group_id=43805&atid=437446)
-- some Mac OS X patches from freepascal trunk
-- some additional patched (see *.patch)
-
-midi:
-taken from http://www.torry.net/authorsmore.php?id=1615 (TMidiPlayer)
-- FPC (Win32) compatibility fixes
-- Win32 only. Maybe use some timidity stuff under linux.
-
-libpng:
-autocreated H2Pas file taken from freepascal trunk
-- bug fixes (especially H2Pas related stuff like wrong file types)
-- delphi compatibility
-- comments added
-
-portaudio:
-translation of the (patched) audacity C headers by hennymcc.
-See http://audacity.cvs.sourceforge.net/viewvc/audacity/lib-src/portaudio-v19/include/?sortdir=down
-
-portmixer:
-translation of the (patched) audacity C headers by hennymcc.
-- Unlike portaudio portmixer is part of audacity and there is no linux package for it. If we want to use it for linux, we have to link it statically. Unfortunately it requires a patched version of portaudio (which is part of audacity and statically linked to) so we have to statically link portaudio too :(.
-
-projectM:
-translation of the original C++ headers and C-wrapper by hennymcc
-
-samplerate:
-translation of the original C headers by profoX/hennymcc
-
-sqlite:
-taken from http://www.itwriting.com/blog/a-simple-delphi-wrapper-for-sqlite-3
-- slightly patched: see *.patch files for what has been patched (e.g. Binding)
-
-zlib:
-taken from freepascal (slightly patched)
+bass:
+http://www.un4seen.com/ (2.4.2.1)
+- FPC Mac OS X compatibility fixes
+
+fft:
+translation of audacity's FFT.cpp by hennymcc (maybe replace this with FFTW?)
+
+ffmpeg:
+- http://www.iversenit.dk/dev/ffmpeg-headers/: 2006-10
+- several bugs were fixed
+- many IFDEFS were added to the header to support multiple versions of ffmpeg (starting with end of 2006) and not only one specific version. This is necessary as we cannot control which version is used on linux. We could ship the ffmpeg lib with USDX and link statically but a stripped down ffmpeg is 15MB in size and takes 5 minutes to compile (so static linkage is not a good option).
+- the headers were updated to reflect the changes in the ffmpeg C-headers (http://svn.mplayerhq.hu/ffmpeg/trunk/ and http://svn.mplayerhq.hu/mplayer/trunk/libswscale/)
+
+freeimage:
+- inserted by eddie. Some compatibility fixes for platforms different than mac os x.
+- not used anymore
+
+freetype:
+- based on the AggPas (http://aggpas.org/) headers
+- just a minimal header that contains only some of the freetype functions and types. Some functions and structures/constants/types needed for USDX were added.
+- some comments added
+
+jedi-sdl:
+JEDI-SDL v1.0 Final RC 2 (http://jedi-sdl.pascalgamedevelopment.com/)
+- 64bit compatibility patch (http://sourceforge.net/tracker/index.php?func=detail&aid=1902924&group_id=43805&atid=437446)
+- some Mac OS X patches from freepascal trunk
+- some additional patched (see *.patch)
+
+midi:
+taken from http://www.torry.net/authorsmore.php?id=1615 (TMidiPlayer)
+- FPC (Win32) compatibility fixes
+- Win32 only. Maybe use some timidity stuff under linux.
+
+libpng:
+autocreated H2Pas file taken from freepascal trunk
+- bug fixes (especially H2Pas related stuff like wrong file types)
+- delphi compatibility
+- comments added
+
+portaudio:
+translation of the (patched) audacity C headers by hennymcc.
+See http://audacity.cvs.sourceforge.net/viewvc/audacity/lib-src/portaudio-v19/include/?sortdir=down
+
+portmixer:
+translation of the (patched) audacity C headers by hennymcc.
+- Unlike portaudio portmixer is part of audacity and there is no linux package for it. If we want to use it for linux, we have to link it statically. Unfortunately it requires a patched version of portaudio (which is part of audacity and statically linked to) so we have to statically link portaudio too :(.
+
+projectM:
+translation of the original C++ headers and C-wrapper by hennymcc
+
+samplerate:
+translation of the original C headers by profoX/hennymcc
+
+sqlite:
+taken from http://www.itwriting.com/blog/a-simple-delphi-wrapper-for-sqlite-3
+- slightly patched: see *.patch files for what has been patched (e.g. Binding)
+
+zlib:
+taken from freepascal (slightly patched)
 - delphi compatibility
 \ No newline at end of file
diff --git a/Lua/src/lib/midi/CIRCBUF.PAS b/Lua/src/lib/midi/CIRCBUF.PAS
index 77cb3643..3ceb4c6e 100644
--- a/Lua/src/lib/midi/CIRCBUF.PAS
+++ b/Lua/src/lib/midi/CIRCBUF.PAS
@@ -23,7 +23,7 @@ interface
 
 {$IFDEF FPC}
   {$MODE Delphi}
-  {$H+} // use AnsiString
+  {$H+} // use long strings
 {$ENDIF}
 
 Uses
diff --git a/Lua/src/lib/midi/DELPHMCB.PAS b/Lua/src/lib/midi/DELPHMCB.PAS
index e607627d..ef0d5451 100644
--- a/Lua/src/lib/midi/DELPHMCB.PAS
+++ b/Lua/src/lib/midi/DELPHMCB.PAS
@@ -13,7 +13,7 @@ interface
 
 {$IFDEF FPC}
   {$MODE Delphi}
-  {$H+} // use AnsiString
+  {$H+} // use long strings
 {$ENDIF}
 
 uses
diff --git a/Lua/src/lib/midi/MIDIDEFS.PAS b/Lua/src/lib/midi/MIDIDEFS.PAS
index fc8eed26..4afe56ef 100644
--- a/Lua/src/lib/midi/MIDIDEFS.PAS
+++ b/Lua/src/lib/midi/MIDIDEFS.PAS
@@ -13,7 +13,7 @@ interface
 
 {$IFDEF FPC}
   {$MODE Delphi}
-  {$H+} // use AnsiString
+  {$H+} // use long strings
 {$ENDIF}
 
 uses
diff --git a/Lua/src/lib/midi/MIDITYPE.PAS b/Lua/src/lib/midi/MIDITYPE.PAS
index b1ec1bdd..45b50820 100644
--- a/Lua/src/lib/midi/MIDITYPE.PAS
+++ b/Lua/src/lib/midi/MIDITYPE.PAS
@@ -10,7 +10,7 @@ interface
 
 {$IFDEF FPC}
   {$MODE Delphi}
-  {$H+} // use AnsiString
+  {$H+} // use long strings
 {$ENDIF}
 
 uses
diff --git a/Lua/src/lib/midi/MidiFile.pas b/Lua/src/lib/midi/MidiFile.pas
index 11b1ca0b..acf44c04 100644
--- a/Lua/src/lib/midi/MidiFile.pas
+++ b/Lua/src/lib/midi/MidiFile.pas
@@ -92,18 +92,18 @@ interface
 
 {$IFDEF FPC}
   {$MODE Delphi}
-  {$H+} // use AnsiString
+  {$H+} // use long strings
 {$ENDIF}
 
 uses
   Windows,
-  //Forms,
   Messages,
   Classes,
   {$IFDEF FPC}
   WinAllocation,
   {$ENDIF}
-  SysUtils;
+  SysUtils,
+  UPath;
 
 type
   TChunkType = (illegal, header, track);
@@ -162,7 +162,7 @@ type
     procedure WndProc(var Msg : TMessage);
   protected
     { Protected declarations }
-    midiFile: file of byte;
+    midiFile: TBinaryFileStream;
     chunkType: TChunkType;
     chunkLength: integer;
     chunkData: PByte;
@@ -177,7 +177,7 @@ type
     FBpm: integer;
     FBeatsPerMeasure: integer;
     FusPerTick: double;
-    FFilename: string;
+    FFilename: IPath;
 
     Tracks: TList;
     currentTrack: TMidiTrack;
@@ -191,7 +191,7 @@ type
     currentPos: Double; // Current Position in ticks
 
     procedure OnTrackReady;
-    procedure setFilename(val: string);
+    procedure SetFilename(val: IPath);
     procedure ReadChunkHeader;
     procedure ReadChunkContent;
     procedure ReadChunk;
@@ -221,7 +221,7 @@ type
     function  Ready: boolean;
   published
     { Published declarations }
-    property Filename: string read FFilename write setFilename;
+    property Filename: IPath read FFilename write SetFilename;
     property NumberOfTracks: integer read numberTracks;
     property TicksPerQuarter: integer read deltaTicks;
     property FileFormat: TFileFormat read FFileFormat;
@@ -463,7 +463,7 @@ begin
   result := Tracks.Items[index];
 end;
 
-procedure TMidifile.setFilename(val: string);
+procedure TMidifile.SetFilename(val: IPath);
 begin
   FFilename := val;
 //  ReadFile;
@@ -586,7 +586,7 @@ procedure TMidifile.ReadChunkHeader;
 var
   theByte: array[0..7] of byte;
 begin
-  BlockRead(midiFile, theByte, 8);
+  midiFile.Read(theByte[0], 8);
   if (theByte[0] = $4D) and (theByte[1] = $54) then
   begin
     if (theByte[2] = $68) and (theByte[3] = $64) then
@@ -608,7 +608,7 @@ begin
   if not (chunkData = nil) then
     FreeMem(chunkData);
   GetMem(chunkData, chunkLength + 10);
-  BlockRead(midiFile, chunkData^, chunkLength);
+  midiFile.Read(chunkData^, chunkLength);
   chunkIndex := chunkData;
   chunkEnd := PByte(integer(chunkIndex) + integer(chunkLength) - 1);
 end;
@@ -848,12 +848,10 @@ begin
   Tracks.Clear;
   chunkType := illegal;
 
-  AssignFile(midiFile, FFilename);
-  FileMode := 0;
-  Reset(midiFile);
-  while not eof(midiFile) do
+  midiFile := TBinaryFileStream.Create(FFilename, fmOpenRead);
+  while (midiFile.Position < midiFile.Size) do
     ReadChunk;
-  CloseFile(midiFile);
+  FreeAndNil(midiFile);
   numberTracks := Tracks.Count;
 end;
 
diff --git a/Lua/src/lib/midi/MidiScope.pas b/Lua/src/lib/midi/MidiScope.pas
index 42fc65fc..afc20b0f 100644
--- a/Lua/src/lib/midi/MidiScope.pas
+++ b/Lua/src/lib/midi/MidiScope.pas
@@ -20,7 +20,7 @@ interface
 
 {$IFDEF FPC}
   {$MODE Delphi}
-  {$H+} // use AnsiString
+  {$H+} // use long strings
 {$ENDIF}
 
 uses
diff --git a/Lua/src/lib/midi/Midicons.pas b/Lua/src/lib/midi/Midicons.pas
index 35dbb5f3..72259beb 100644
--- a/Lua/src/lib/midi/Midicons.pas
+++ b/Lua/src/lib/midi/Midicons.pas
@@ -11,7 +11,7 @@ interface
 
 {$IFDEF FPC}
   {$MODE Delphi}
-  {$H+} // use AnsiString
+  {$H+} // use long strings
 {$ENDIF}
 
 uses Messages;
diff --git a/Lua/src/lib/midi/Midiin.pas b/Lua/src/lib/midi/Midiin.pas
index 21db0298..66e4f76d 100644
--- a/Lua/src/lib/midi/Midiin.pas
+++ b/Lua/src/lib/midi/Midiin.pas
@@ -103,7 +103,7 @@ interface
 
 {$IFDEF FPC}
   {$MODE Delphi}
-  {$H+} // use AnsiString
+  {$H+} // use long strings
 {$ENDIF}
 
 uses
diff --git a/Lua/src/lib/midi/Midiout.pas b/Lua/src/lib/midi/Midiout.pas
index 606d0dae..98e6e3fb 100644
--- a/Lua/src/lib/midi/Midiout.pas
+++ b/Lua/src/lib/midi/Midiout.pas
@@ -98,7 +98,7 @@ interface
 
 {$IFDEF FPC}
   {$MODE Delphi}
-  {$H+} // use AnsiString
+  {$H+} // use long strings
 {$ENDIF}
 
 uses
diff --git a/Lua/src/lib/other/DirWatch.pas b/Lua/src/lib/other/DirWatch.pas
index 9d395840..1e00ec5d 100644
--- a/Lua/src/lib/other/DirWatch.pas
+++ b/Lua/src/lib/other/DirWatch.pas
@@ -25,7 +25,7 @@ interface
 
 {$IFDEF FPC}
   {$MODE Delphi}
-  {$H+} // use AnsiString
+  {$H+} // use long strings
 {$ENDIF}
 
 uses
diff --git a/Lua/src/lib/pcre/pcre.pas b/Lua/src/lib/pcre/pcre.pas
new file mode 100644
index 00000000..50e3371a
--- /dev/null
+++ b/Lua/src/lib/pcre/pcre.pas
@@ -0,0 +1,852 @@
+{**************************************************************************************************}
+{                                                                                                  }
+{ Project JEDI Code Library (JCL)                                                                  }
+{                                                                                                  }
+{ The contents of this file are subject to the Mozilla Public License Version 1.1 (the "License"); }
+{ you may not use this file except in compliance with the License. You may obtain a copy of the    }
+{ License at http://www.mozilla.org/MPL/                                                           }
+{                                                                                                  }
+{ Software distributed under the License is distributed on an "AS IS" basis, WITHOUT WARRANTY OF   }
+{ ANY KIND, either express or implied. See the License for the specific language governing rights  }
+{ and limitations under the License.                                                               }
+{                                                                                                  }
+{ The Original Code is JclPRCE.pas.                                                                }
+{                                                                                                  }
+{ The Initial Developer of the Original Code is Peter Thornqvist.                                  }
+{ Portions created by Peter Thornqvist are Copyright (C) of Peter Thornqvist. All rights reserved. }
+{ Portions created by University of Cambridge are                                                  }
+{ Copyright (C) 1997-2001 by University of Cambridge.                                              }
+{                                                                                                  }
+{ Contributor(s):                                                                                  }
+{   Robert Rossmair (rrossmair)                                                                    }
+{   Mario R. Carro                                                                                 }
+{   Florent Ouchet (outchy)                                                                        }
+{                                                                                                  }
+{ The latest release of PCRE is always available from                                              }
+{ ftp://ftp.csx.cam.ac.uk/pub/software/programming/pcre/pcre-xxx.tar.gz                            }
+{                                                                                                  }
+{**************************************************************************************************}
+{                                                                                                  }
+{ Header conversion of pcre.h                                                                      }
+{                                                                                                  }
+{                                                                                                  }
+{**************************************************************************************************}
+{                                                                                                  }
+{ Last modified: $Date::                                                                         $ }
+{ Revision:      $Rev::                                                                          $ }
+{ Author:        $Author::                                                                       $ }
+{                                                                                                  }
+{**************************************************************************************************}
+
+unit pcre;
+
+interface
+
+(*************************************************
+*       Perl-Compatible Regular Expressions      *
+*************************************************)
+
+{$IFDEF FPC}
+  {$MODE DELPHI}
+  {$PACKENUM 4}    (* use 4-byte enums *)
+  {$PACKRECORDS C} (* C/C++-compatible record packing *)
+{$ELSE}
+  {$MINENUMSIZE 4} (* use 4-byte enums *)
+{$ENDIF}
+
+{$WEAKPACKAGEUNIT ON}
+
+(*$HPPEMIT '#include "pcre.h"'*)
+
+const
+  MAX_PATTERN_LENGTH = $10003;
+  {$EXTERNALSYM MAX_PATTERN_LENGTH}
+  MAX_QUANTIFY_REPEAT = $10000;
+  {$EXTERNALSYM MAX_QUANTIFY_REPEAT}
+  MAX_CAPTURE_COUNT = $FFFF;
+  {$EXTERNALSYM MAX_CAPTURE_COUNT}
+  MAX_NESTING_DEPTH = 200;
+  {$EXTERNALSYM MAX_NESTING_DEPTH}
+
+const
+  (* Options *)
+  PCRE_CASELESS = $00000001;
+  {$EXTERNALSYM PCRE_CASELESS}
+  PCRE_MULTILINE = $00000002;
+  {$EXTERNALSYM PCRE_MULTILINE}
+  PCRE_DOTALL = $00000004;
+  {$EXTERNALSYM PCRE_DOTALL}
+  PCRE_EXTENDED = $00000008;
+  {$EXTERNALSYM PCRE_EXTENDED}
+  PCRE_ANCHORED = $00000010;
+  {$EXTERNALSYM PCRE_ANCHORED}
+  PCRE_DOLLAR_ENDONLY = $00000020;
+  {$EXTERNALSYM PCRE_DOLLAR_ENDONLY}
+  PCRE_EXTRA = $00000040;
+  {$EXTERNALSYM PCRE_EXTRA}
+  PCRE_NOTBOL = $00000080;
+  {$EXTERNALSYM PCRE_NOTBOL}
+  PCRE_NOTEOL = $00000100;
+  {$EXTERNALSYM PCRE_NOTEOL}
+  PCRE_UNGREEDY = $00000200;
+  {$EXTERNALSYM PCRE_UNGREEDY}
+  PCRE_NOTEMPTY = $00000400;
+  {$EXTERNALSYM PCRE_NOTEMPTY}
+  PCRE_UTF8 = $00000800;
+  {$EXTERNALSYM PCRE_UTF8}
+  PCRE_NO_AUTO_CAPTURE = $00001000;
+  {$EXTERNALSYM PCRE_NO_AUTO_CAPTURE}
+  PCRE_NO_UTF8_CHECK = $00002000;
+  {$EXTERNALSYM PCRE_NO_UTF8_CHECK}
+  PCRE_AUTO_CALLOUT = $00004000;
+  {$EXTERNALSYM PCRE_AUTO_CALLOUT}
+  PCRE_PARTIAL_SOFT = $00008000;
+  {$EXTERNALSYM PCRE_PARTIAL_SOFT}
+  PCRE_PARTIAL = PCRE_PARTIAL_SOFT; // Backwards compatible synonym
+  {$EXTERNALSYM PCRE_PARTIAL}
+  PCRE_DFA_SHORTEST = $00010000;
+  {$EXTERNALSYM PCRE_DFA_SHORTEST}
+  PCRE_DFA_RESTART = $00020000;
+  {$EXTERNALSYM PCRE_DFA_RESTART}
+  PCRE_FIRSTLINE = $00040000;
+  {$EXTERNALSYM PCRE_FIRSTLINE}
+  PCRE_DUPNAMES = $00080000;
+  {$EXTERNALSYM PCRE_DUPNAMES}
+  PCRE_NEWLINE_CR = $00100000;
+  {$EXTERNALSYM PCRE_NEWLINE_CR}
+  PCRE_NEWLINE_LF = $00200000;
+  {$EXTERNALSYM PCRE_NEWLINE_LF}
+  PCRE_NEWLINE_CRLF = $00300000;
+  {$EXTERNALSYM PCRE_NEWLINE_CRLF}
+  PCRE_NEWLINE_ANY = $00400000;
+  {$EXTERNALSYM PCRE_NEWLINE_ANY}
+  PCRE_NEWLINE_ANYCRLF = $00500000;
+  {$EXTERNALSYM PCRE_NEWLINE_ANYCRLF}
+  PCRE_BSR_ANYCRLF = $00800000;
+  {$EXTERNALSYM PCRE_BSR_ANYCRLF}
+  PCRE_BSR_UNICODE = $01000000;
+  {$EXTERNALSYM PCRE_BSR_UNICODE}
+  PCRE_JAVASCRIPT_COMPAT = $02000000;
+  {$EXTERNALSYM PCRE_JAVASCRIPT_COMPAT}
+  PCRE_NO_START_OPTIMIZE = $04000000;
+  {$EXTERNALSYM PCRE_NO_START_OPTIMIZE}
+  PCRE_NO_START_OPTIMISE = $04000000;
+  {$EXTERNALSYM PCRE_NO_START_OPTIMISE}
+  PCRE_PARTIAL_HARD = $08000000;
+  {$EXTERNALSYM PCRE_PARTIAL_HARD}
+  PCRE_NOTEMPTY_ATSTART = $10000000;
+  {$EXTERNALSYM PCRE_NOTEMPTY_ATSTART}
+
+  (* Exec-time and get-time error codes *)
+
+  PCRE_ERROR_NOMATCH = -1;
+  {$EXTERNALSYM PCRE_ERROR_NOMATCH}
+  PCRE_ERROR_NULL = -2;
+  {$EXTERNALSYM PCRE_ERROR_NULL}
+  PCRE_ERROR_BADOPTION = -3;
+  {$EXTERNALSYM PCRE_ERROR_BADOPTION}
+  PCRE_ERROR_BADMAGIC = -4;
+  {$EXTERNALSYM PCRE_ERROR_BADMAGIC}
+  PCRE_ERROR_UNKNOWN_NODE = -5;
+  {$EXTERNALSYM PCRE_ERROR_UNKNOWN_NODE}
+  PCRE_ERROR_NOMEMORY = -6;
+  {$EXTERNALSYM PCRE_ERROR_NOMEMORY}
+  PCRE_ERROR_NOSUBSTRING = -7;
+  {$EXTERNALSYM PCRE_ERROR_NOSUBSTRING}
+  PCRE_ERROR_MATCHLIMIT = -8;
+  {$EXTERNALSYM PCRE_ERROR_MATCHLIMIT}
+  PCRE_ERROR_CALLOUT = -9;  (* Never used by PCRE itself *)
+  {$EXTERNALSYM PCRE_ERROR_CALLOUT}
+  PCRE_ERROR_BADUTF8 = -10;
+  {$EXTERNALSYM PCRE_ERROR_BADUTF8}
+  PCRE_ERROR_BADUTF8_OFFSET = -11;
+  {$EXTERNALSYM PCRE_ERROR_BADUTF8_OFFSET}
+  PCRE_ERROR_PARTIAL = -12;
+  {$EXTERNALSYM PCRE_ERROR_PARTIAL}
+  PCRE_ERROR_BADPARTIAL = -13;
+  {$EXTERNALSYM PCRE_ERROR_BADPARTIAL}
+  PCRE_ERROR_INTERNAL = -14;
+  {$EXTERNALSYM PCRE_ERROR_INTERNAL}
+  PCRE_ERROR_BADCOUNT = -15;
+  {$EXTERNALSYM PCRE_ERROR_BADCOUNT}
+  PCRE_ERROR_DFA_UITEM = -16;
+  {$EXTERNALSYM PCRE_ERROR_DFA_UITEM}
+  PCRE_ERROR_DFA_UCOND = -17;
+  {$EXTERNALSYM PCRE_ERROR_DFA_UCOND}
+  PCRE_ERROR_DFA_UMLIMIT = -18;
+  {$EXTERNALSYM PCRE_ERROR_DFA_UMLIMIT}
+  PCRE_ERROR_DFA_WSSIZE = -19;
+  {$EXTERNALSYM PCRE_ERROR_DFA_WSSIZE}
+  PCRE_ERROR_DFA_RECURSE = -20;
+  {$EXTERNALSYM PCRE_ERROR_DFA_RECURSE}
+  PCRE_ERROR_RECURSIONLIMIT = -21;
+  {$EXTERNALSYM PCRE_ERROR_RECURSIONLIMIT}
+  PCRE_ERROR_NULLWSLIMIT = -22;  (* No longer actually used *)
+  {$EXTERNALSYM PCRE_ERROR_NULLWSLIMIT}
+  PCRE_ERROR_BADNEWLINE = -23;
+  {$EXTERNALSYM PCRE_ERROR_BADNEWLINE}
+
+  (* Request types for pcre_fullinfo() *)
+
+  PCRE_INFO_OPTIONS = 0;
+  {$EXTERNALSYM PCRE_INFO_OPTIONS}
+  PCRE_INFO_SIZE = 1;
+  {$EXTERNALSYM PCRE_INFO_SIZE}
+  PCRE_INFO_CAPTURECOUNT = 2;
+  {$EXTERNALSYM PCRE_INFO_CAPTURECOUNT}
+  PCRE_INFO_BACKREFMAX = 3;
+  {$EXTERNALSYM PCRE_INFO_BACKREFMAX}
+  PCRE_INFO_FIRSTCHAR = 4;
+  {$EXTERNALSYM PCRE_INFO_FIRSTCHAR}
+  PCRE_INFO_FIRSTTABLE = 5;
+  {$EXTERNALSYM PCRE_INFO_FIRSTTABLE}
+  PCRE_INFO_LASTLITERAL = 6;
+  {$EXTERNALSYM PCRE_INFO_LASTLITERAL}
+  PCRE_INFO_NAMEENTRYSIZE = 7;
+  {$EXTERNALSYM PCRE_INFO_NAMEENTRYSIZE}
+  PCRE_INFO_NAMECOUNT = 8;
+  {$EXTERNALSYM PCRE_INFO_NAMECOUNT}
+  PCRE_INFO_NAMETABLE = 9;
+  {$EXTERNALSYM PCRE_INFO_NAMETABLE}
+  PCRE_INFO_STUDYSIZE = 10;
+  {$EXTERNALSYM PCRE_INFO_STUDYSIZE}
+  PCRE_INFO_DEFAULT_TABLES = 11;
+  {$EXTERNALSYM PCRE_INFO_DEFAULT_TABLES}
+  PCRE_INFO_OKPARTIAL = 12;
+  {$EXTERNALSYM PCRE_INFO_OKPARTIAL}
+  PCRE_INFO_JCHANGED = 13;
+  {$EXTERNALSYM PCRE_INFO_JCHANGED}
+  PCRE_INFO_HASCRORLF = 14;
+  {$EXTERNALSYM PCRE_INFO_HASCRORLF}
+  PCRE_INFO_MINLENGTH = 15;
+  {$EXTERNALSYM PCRE_INFO_MINLENGTH}
+
+  (* Request types for pcre_config() *)
+  PCRE_CONFIG_UTF8 = 0;
+  {$EXTERNALSYM PCRE_CONFIG_UTF8}
+  PCRE_CONFIG_NEWLINE = 1;
+  {$EXTERNALSYM PCRE_CONFIG_NEWLINE}
+  PCRE_CONFIG_LINK_SIZE = 2;
+  {$EXTERNALSYM PCRE_CONFIG_LINK_SIZE}
+  PCRE_CONFIG_POSIX_MALLOC_THRESHOLD = 3;
+  {$EXTERNALSYM PCRE_CONFIG_POSIX_MALLOC_THRESHOLD}
+  PCRE_CONFIG_MATCH_LIMIT = 4;
+  {$EXTERNALSYM PCRE_CONFIG_MATCH_LIMIT}
+  PCRE_CONFIG_STACKRECURSE = 5;
+  {$EXTERNALSYM PCRE_CONFIG_STACKRECURSE}
+  PCRE_CONFIG_UNICODE_PROPERTIES = 6;
+  {$EXTERNALSYM PCRE_CONFIG_UNICODE_PROPERTIES}
+  PCRE_CONFIG_MATCH_LIMIT_RECURSION = 7;
+  {$EXTERNALSYM PCRE_CONFIG_MATCH_LIMIT_RECURSION}
+  PCRE_CONFIG_BSR = 8;
+  {$EXTERNALSYM PCRE_CONFIG_BSR}
+
+  (* Bit flags for the pcre_extra structure *)
+
+  PCRE_EXTRA_STUDY_DATA = $0001;
+  {$EXTERNALSYM PCRE_EXTRA_STUDY_DATA}
+  PCRE_EXTRA_MATCH_LIMIT = $0002;
+  {$EXTERNALSYM PCRE_EXTRA_MATCH_LIMIT}
+  PCRE_EXTRA_CALLOUT_DATA = $0004;
+  {$EXTERNALSYM PCRE_EXTRA_CALLOUT_DATA}
+  PCRE_EXTRA_TABLES = $0008;
+  {$EXTERNALSYM PCRE_EXTRA_TABLES}
+  PCRE_EXTRA_MATCH_LIMIT_RECURSION = $0010;
+  {$EXTERNALSYM PCRE_EXTRA_MATCH_LIMIT_RECURSION}
+
+type
+  {$IFNDEF FPC}
+  {$IFDEF CPU64}
+  SizeInt = Int64;
+  {$ELSE ~CPU64}
+  SizeInt = Integer;
+  {$ENDIF ~CPU64}
+  PPAnsiChar = ^PAnsiChar;
+  {$ENDIF ~FPC}
+  PPPAnsiChar = ^PPAnsiChar;
+
+  real_pcre = packed record
+    {magic_number: Longword;
+    size: Integer;
+    tables: PAnsiChar;
+    options: Longword;
+    top_bracket: Word;
+    top_backref: word;
+    first_char: PAnsiChar;
+    req_char: PAnsiChar;
+    code: array [0..0] of AnsiChar;}
+  end;
+  TPCRE = real_pcre;
+  PPCRE = ^TPCRE;
+
+  real_pcre_extra = packed record
+    {options: PAnsiChar;
+    start_bits: array [0..31] of AnsiChar;}
+    flags: Cardinal;        (* Bits for which fields are set *)
+    study_data: Pointer;    (* Opaque data from pcre_study() *)
+    match_limit: Cardinal;  (* Maximum number of calls to match() *)
+    callout_data: Pointer;  (* Data passed back in callouts *)
+    tables: PAnsiChar;      (* Pointer to character tables *)
+    match_limit_recursion: Cardinal; (* Max recursive calls to match() *)
+  end;
+  TPCREExtra = real_pcre_extra;
+  PPCREExtra = ^TPCREExtra;
+
+  pcre_callout_block = packed record
+    version: Integer;           (* Identifies version of block *)
+  (* ------------------------ Version 0 ------------------------------- *)
+    callout_number: Integer;    (* Number compiled into pattern *)
+    offset_vector: PInteger;    (* The offset vector *)
+    subject: PAnsiChar;         (* The subject being matched *)
+    subject_length: Integer;    (* The length of the subject *)
+    start_match: Integer;       (* Offset to start of this match attempt *)
+    current_position: Integer;  (* Where we currently are in the subject *)
+    capture_top: Integer;       (* Max current capture *)
+    capture_last: Integer;      (* Most recently closed capture *)
+    callout_data: Pointer;      (* Data passed in with the call *)
+  (* ------------------- Added for Version 1 -------------------------- *)
+    pattern_position: Integer;  (* Offset to next item in the pattern *)
+    next_item_length: Integer;  (* Length of next item in the pattern *)
+  (* ------------------------------------------------------------------ *)
+  end;
+
+  pcre_malloc_callback = function(Size: SizeInt): Pointer; cdecl;
+  {$EXTERNALSYM pcre_malloc_callback}
+  pcre_free_callback = procedure(P: Pointer); cdecl;
+  {$EXTERNALSYM pcre_free_callback}
+  pcre_stack_malloc_callback = function(Size: SizeInt): Pointer; cdecl;
+  {$EXTERNALSYM pcre_stack_malloc_callback}
+  pcre_stack_free_callback = procedure(P: Pointer); cdecl;
+  {$EXTERNALSYM pcre_stack_free_callback}
+  pcre_callout_callback = function(var callout_block: pcre_callout_block): Integer; cdecl;
+  {$EXTERNALSYM pcre_callout_callback}
+
+var
+  // renamed from "pcre_X" to "pcre_X_func" to allow functions with name "pcre_X" to be
+  // declared in implementation when static linked
+  pcre_malloc_func: ^pcre_malloc_callback = nil;
+  {$EXTERNALSYM pcre_malloc_func}
+  pcre_free_func: ^pcre_free_callback = nil;
+  {$EXTERNALSYM pcre_free_func}
+  pcre_stack_malloc_func: ^pcre_stack_malloc_callback = nil;
+  {$EXTERNALSYM pcre_stack_malloc_func}
+  pcre_stack_free_func: ^pcre_stack_free_callback = nil;
+  {$EXTERNALSYM pcre_stack_free_func}
+  pcre_callout_func: ^pcre_callout_callback = nil;
+  {$EXTERNALSYM pcre_callout_func}
+
+procedure SetPCREMallocCallback(const Value: pcre_malloc_callback);
+{$EXTERNALSYM SetPCREMallocCallback}
+function GetPCREMallocCallback: pcre_malloc_callback;
+{$EXTERNALSYM GetPCREMallocCallback}
+function CallPCREMalloc(Size: SizeInt): Pointer;
+{$EXTERNALSYM CallPCREMalloc}
+
+procedure SetPCREFreeCallback(const Value: pcre_free_callback);
+{$EXTERNALSYM SetPCREFreeCallback}
+function GetPCREFreeCallback: pcre_free_callback;
+{$EXTERNALSYM GetPCREFreeCallback}
+procedure CallPCREFree(P: Pointer);
+{$EXTERNALSYM CallPCREFree}
+
+procedure SetPCREStackMallocCallback(const Value: pcre_stack_malloc_callback);
+{$EXTERNALSYM SetPCREStackMallocCallback}
+function GetPCREStackMallocCallback: pcre_stack_malloc_callback;
+{$EXTERNALSYM GetPCREStackMallocCallback}
+function CallPCREStackMalloc(Size: SizeInt): Pointer;
+{$EXTERNALSYM CallPCREStackMalloc}
+
+procedure SetPCREStackFreeCallback(const Value: pcre_stack_free_callback);
+{$EXTERNALSYM SetPCREStackFreeCallback}
+function GetPCREStackFreeCallback: pcre_stack_free_callback;
+{$EXTERNALSYM GetPCREStackFreeCallback}
+procedure CallPCREStackFree(P: Pointer);
+{$EXTERNALSYM CallPCREStackFree}
+
+procedure SetPCRECalloutCallback(const Value: pcre_callout_callback);
+{$EXTERNALSYM SetPCRECalloutCallback}
+function GetPCRECalloutCallback: pcre_callout_callback;
+{$EXTERNALSYM GetPCRECalloutCallback}
+function CallPCRECallout(var callout_block: pcre_callout_block): Integer;
+{$EXTERNALSYM CallPCRECallout}
+
+type
+  TPCRELibNotLoadedHandler = procedure; cdecl;
+
+var
+  // Value to initialize function pointers below with, in case LoadPCRE fails
+  // or UnloadPCRE is called.  Typically the handler will raise an exception.
+  LibNotLoadedHandler: TPCRELibNotLoadedHandler = nil;
+
+(* Functions *)
+
+// dynamic dll import
+type
+  pcre_compile_func = function(const pattern: PAnsiChar; options: Integer;
+    const errptr: PPAnsiChar; erroffset: PInteger; const tableptr: PAnsiChar): PPCRE;
+    cdecl;
+  {$EXTERNALSYM pcre_compile_func}
+  pcre_compile2_func = function(const pattern: PAnsiChar; options: Integer;
+    const errorcodeptr: PInteger; const errorptr: PPAnsiChar; erroroffset: PInteger;
+    const tables: PAnsiChar): PPCRE; cdecl;
+  {$EXTERNALSYM pcre_compile2_func}
+  pcre_config_func = function(what: Integer; where: Pointer): Integer;
+  cdecl;
+  {$EXTERNALSYM pcre_config_func}
+  pcre_copy_named_substring_func = function(const code: PPCRE; const subject: PAnsiChar;
+    ovector: PInteger; stringcount: Integer; const stringname: PAnsiChar;
+    buffer: PAnsiChar; size: Integer): Integer; cdecl;
+  {$EXTERNALSYM pcre_copy_named_substring_func}
+  pcre_copy_substring_func = function(const subject: PAnsiChar; ovector: PInteger;
+    stringcount, stringnumber: Integer; buffer: PAnsiChar; buffersize: Integer): Integer;
+    cdecl;
+  {$EXTERNALSYM pcre_copy_substring_func}
+  pcre_dfa_exec_func = function(const argument_re: PPCRE; const extra_data: PPCREExtra;
+    const subject: PAnsiChar; length: Integer; start_offset: Integer;
+    options: Integer; offsets: PInteger; offsetcount: Integer; workspace: PInteger;
+    wscount: Integer): Integer; cdecl;
+  {$EXTERNALSYM pcre_dfa_exec_func}
+  pcre_exec_func = function(const code: PPCRE; const extra: PPCREExtra; const subject: PAnsiChar;
+    length, startoffset, options: Integer; ovector: PInteger; ovecsize: Integer): Integer;
+    cdecl;
+  {$EXTERNALSYM pcre_exec_func}
+  pcre_free_substring_func = procedure(stringptr: PAnsiChar);
+    cdecl;
+  {$EXTERNALSYM pcre_free_substring_func}
+  pcre_free_substring_list_func = procedure(stringptr: PPAnsiChar);
+    cdecl;
+  {$EXTERNALSYM pcre_free_substring_list_func}
+  pcre_fullinfo_func = function(const code: PPCRE; const extra: PPCREExtra;
+    what: Integer; where: Pointer): Integer;
+    cdecl;
+  {$EXTERNALSYM pcre_fullinfo_func}
+  pcre_get_named_substring_func = function(const code: PPCRE; const subject: PAnsiChar;
+    ovector: PInteger; stringcount: Integer; const stringname: PAnsiChar;
+    const stringptr: PPAnsiChar): Integer; cdecl;
+  {$EXTERNALSYM pcre_get_named_substring_func}
+  pcre_get_stringnumber_func = function(const code: PPCRE;
+    const stringname: PAnsiChar): Integer; cdecl;
+  {$EXTERNALSYM pcre_get_stringnumber_func}
+  pcre_get_stringtable_entries_func = function(const code: PPCRE; const stringname: PAnsiChar;
+    firstptr: PPAnsiChar; lastptr: PPAnsiChar): Integer;
+    cdecl;
+  {$EXTERNALSYM pcre_get_stringtable_entries_func}
+  pcre_get_substring_func = function(const subject: PAnsiChar; ovector: PInteger;
+    stringcount, stringnumber: Integer; const stringptr: PPAnsiChar): Integer;
+    cdecl;
+  {$EXTERNALSYM pcre_get_substring_func}
+  pcre_get_substring_list_func = function(const subject: PAnsiChar; ovector: PInteger;
+    stringcount: Integer; listptr: PPPAnsiChar): Integer;
+    cdecl;
+  {$EXTERNALSYM pcre_get_substring_list_func}
+  pcre_info_func = function(const code: PPCRE; optptr, firstcharptr: PInteger): Integer;
+  cdecl;
+  {$EXTERNALSYM pcre_info_func}
+  pcre_maketables_func = function: PAnsiChar; cdecl;
+  {$EXTERNALSYM pcre_maketables_func}
+  pcre_refcount_func = function(argument_re: PPCRE; adjust: Integer): Integer;
+  cdecl;
+  {$EXTERNALSYM pcre_refcount_func}
+  pcre_study_func = function(const code: PPCRE; options: Integer; const errptr: PPAnsiChar): PPCREExtra;
+  cdecl;
+  {$EXTERNALSYM pcre_study_func}
+  pcre_version_func = function: PAnsiChar; cdecl;
+  {$EXTERNALSYM pcre_version_func}
+
+var
+  pcre_compile: pcre_compile_func = nil;
+  {$EXTERNALSYM pcre_compile}
+  pcre_compile2: pcre_compile2_func = nil;
+  {$EXTERNALSYM pcre_compile2}
+  pcre_config: pcre_config_func = nil;
+  {$EXTERNALSYM pcre_config}
+  pcre_copy_named_substring: pcre_copy_named_substring_func = nil;
+  {$EXTERNALSYM pcre_copy_named_substring}
+  pcre_copy_substring: pcre_copy_substring_func = nil;
+  {$EXTERNALSYM pcre_copy_substring}
+  pcre_dfa_exec: pcre_dfa_exec_func = nil;
+  {$EXTERNALSYM pcre_dfa_exec}
+  pcre_exec: pcre_exec_func = nil;
+  {$EXTERNALSYM pcre_exec}
+  pcre_free_substring: pcre_free_substring_func = nil;
+  {$EXTERNALSYM pcre_free_substring}
+  pcre_free_substring_list: pcre_free_substring_list_func = nil;
+  {$EXTERNALSYM pcre_free_substring_list}
+  pcre_fullinfo: pcre_fullinfo_func = nil;
+  {$EXTERNALSYM pcre_fullinfo}
+  pcre_get_named_substring: pcre_get_named_substring_func = nil;
+  {$EXTERNALSYM pcre_get_named_substring}
+  pcre_get_stringnumber: pcre_get_stringnumber_func = nil;
+  {$EXTERNALSYM pcre_get_stringnumber}
+  pcre_get_stringtable_entries: pcre_get_stringtable_entries_func = nil;
+  {$EXTERNALSYM pcre_get_stringtable_entries}
+  pcre_get_substring: pcre_get_substring_func = nil;
+  {$EXTERNALSYM pcre_get_substring}
+  pcre_get_substring_list: pcre_get_substring_list_func = nil;
+  {$EXTERNALSYM pcre_get_substring_list}
+  pcre_info: pcre_info_func = nil;
+  {$EXTERNALSYM pcre_info}
+  pcre_maketables: pcre_maketables_func = nil;
+  {$EXTERNALSYM pcre_maketables}
+  pcre_refcount: pcre_refcount_func = nil;
+  {$EXTERNALSYM pcre_refcount}
+  pcre_study: pcre_study_func = nil;
+  {$EXTERNALSYM pcre_study}
+  pcre_version: pcre_version_func = nil;
+  {$EXTERNALSYM pcre_version}
+
+function IsPCRELoaded: Boolean;
+function LoadPCRE: Boolean;
+procedure UnloadPCRE;
+
+implementation
+
+uses
+  SysUtils,
+  {$IFDEF MSWINDOWS}
+  Windows;
+  {$ENDIF MSWINDOWS}
+  {$IFDEF UNIX}
+  {$IFDEF HAS_UNIT_TYPES}
+  Types,
+  {$ENDIF HAS_UNIT_TYPES}
+  {$IFDEF HAS_UNIT_LIBC}
+  Libc;
+  {$ELSE ~HAS_UNIT_LIBC}
+  dl;
+  {$ENDIF ~HAS_UNIT_LIBC}
+  {$ENDIF UNIX}
+
+type
+  {$IFDEF MSWINDOWS}
+  TModuleHandle = HINST;
+  {$ENDIF MSWINDOWS}
+  {$IFDEF LINUX}
+  TModuleHandle = Pointer;
+  {$ENDIF LINUX}
+  {$IFDEF DARWIN}
+  TModuleHandle = Pointer;
+  {$ENDIF DARWIN}
+
+const
+  {$IFDEF MSWINDOWS}
+  libpcremodulename = 'pcre3.dll';
+  {$ENDIF MSWINDOWS}
+  {$IFDEF LINUX}
+  libpcremodulename = 'libpcre.so.0';
+  {$ENDIF LINUX}
+  {$IFDEF DARWIN}
+  libpcremodulename = 'libpcre.dylib';
+  {$ENDIF DARWIN}
+  PCRECompileExportName = 'pcre_compile';
+  PCRECompile2ExportName = 'pcre_compile2';
+  PCREConfigExportName = 'pcre_config';
+  PCRECopyNamedSubstringExportName = 'pcre_copy_named_substring';
+  PCRECopySubStringExportName = 'pcre_copy_substring';
+  PCREDfaExecExportName = 'pcre_dfa_exec';
+  PCREExecExportName = 'pcre_exec';
+  PCREFreeSubStringExportName = 'pcre_free_substring';
+  PCREFreeSubStringListExportName = 'pcre_free_substring_list';
+  PCREFullInfoExportName = 'pcre_fullinfo';
+  PCREGetNamedSubstringExportName = 'pcre_get_named_substring';
+  PCREGetStringNumberExportName = 'pcre_get_stringnumber';
+  PCREGetStringTableEntriesExportName = 'pcre_get_stringtable_entries';
+  PCREGetSubStringExportName = 'pcre_get_substring';
+  PCREGetSubStringListExportName = 'pcre_get_substring_list';
+  PCREInfoExportName = 'pcre_info';
+  PCREMakeTablesExportName = 'pcre_maketables';
+  PCRERefCountExportName = 'pcre_refcount';
+  PCREStudyExportName = 'pcre_study';
+  PCREVersionExportName = 'pcre_version';
+  PCREMallocExportName = 'pcre_malloc';
+  PCREFreeExportName = 'pcre_free';
+  PCREStackMallocExportName = 'pcre_stack_malloc';
+  PCREStackFreeExportName = 'pcre_stack_free';
+  PCRECalloutExportName = 'pcre_callout';
+  INVALID_MODULEHANDLE_VALUE = TModuleHandle(0);
+
+var
+  PCRELib: TModuleHandle = INVALID_MODULEHANDLE_VALUE;
+
+procedure SetPCREMallocCallback(const Value: pcre_malloc_callback);
+begin
+  if not Assigned(pcre_malloc_func) then
+    LoadPCRE;
+
+  if Assigned(pcre_malloc_func) then
+    pcre_malloc_func^ := Value
+  else if Assigned(LibNotLoadedHandler) then
+    LibNotLoadedHandler;
+end;
+
+function GetPCREMallocCallback: pcre_malloc_callback;
+begin
+  if not Assigned(pcre_malloc_func) then
+    LoadPCRE;
+
+  if not Assigned(pcre_malloc_func) then
+  begin
+    Result := nil;
+    if Assigned(LibNotLoadedHandler) then
+      LibNotLoadedHandler;
+  end
+  else
+    Result := pcre_malloc_func^;
+end;
+
+function CallPCREMalloc(Size: SizeInt): Pointer;
+begin
+  Result := pcre_malloc_func^(Size);
+end;
+
+procedure SetPCREFreeCallback(const Value: pcre_free_callback);
+begin
+  if not Assigned(pcre_free_func) then
+    LoadPCRE;
+
+  if Assigned(pcre_free_func) then
+    pcre_free_func^ := Value
+  else if Assigned(LibNotLoadedHandler) then
+    LibNotLoadedHandler;
+end;
+
+function GetPCREFreeCallback: pcre_free_callback;
+begin
+  if not Assigned(pcre_free_func) then
+    LoadPCRE;
+
+  if not Assigned(pcre_free_func) then
+  begin
+    Result := nil;
+    if Assigned(LibNotLoadedHandler) then
+      LibNotLoadedHandler;
+  end
+  else
+    Result := pcre_free_func^
+end;
+
+procedure CallPCREFree(P: Pointer);
+begin
+  pcre_free_func^(P);
+end;
+
+procedure SetPCREStackMallocCallback(const Value: pcre_stack_malloc_callback);
+begin
+  if not Assigned(pcre_stack_malloc_func) then
+    LoadPCRE;
+
+  if Assigned(pcre_stack_malloc_func) then
+    pcre_stack_malloc_func^ := Value
+  else if Assigned(LibNotLoadedHandler) then
+    LibNotLoadedHandler;
+end;
+
+function GetPCREStackMallocCallback: pcre_stack_malloc_callback;
+begin
+  if not Assigned(pcre_stack_malloc_func) then
+    LoadPCRE;
+
+  if not Assigned(pcre_stack_malloc_func) then
+  begin
+    Result := nil;
+    if Assigned(LibNotLoadedHandler) then
+      LibNotLoadedHandler;
+  end
+  else
+    Result := pcre_stack_malloc_func^;
+end;
+
+function CallPCREStackMalloc(Size: SizeInt): Pointer;
+begin
+  Result := pcre_stack_malloc_func^(Size);
+end;
+
+procedure SetPCREStackFreeCallback(const Value: pcre_stack_free_callback);
+begin
+  if not Assigned(pcre_stack_free_func) then
+    LoadPCRE;
+
+  if Assigned(pcre_stack_free_func) then
+    pcre_stack_free_func^ := Value
+  else if Assigned(LibNotLoadedHandler) then
+    LibNotLoadedHandler;
+end;
+
+function GetPCREStackFreeCallback: pcre_stack_free_callback;
+begin
+  if not Assigned(pcre_stack_free_func) then
+    LoadPCRE;
+
+  if not Assigned(pcre_stack_free_func) then
+  begin
+    Result := nil;
+    if Assigned(LibNotLoadedHandler) then
+      LibNotLoadedHandler;
+  end
+  else
+    Result := pcre_stack_free_func^;
+end;
+
+procedure CallPCREStackFree(P: Pointer);
+begin
+  pcre_stack_free_func^(P);
+end;
+
+procedure SetPCRECalloutCallback(const Value: pcre_callout_callback);
+begin
+  if not Assigned(pcre_callout_func) then
+    LoadPCRE;
+
+  if Assigned(pcre_callout_func) then
+    pcre_callout_func^ := Value
+  else if Assigned(LibNotLoadedHandler) then
+    LibNotLoadedHandler;
+end;
+
+function GetPCRECalloutCallback: pcre_callout_callback;
+begin
+  if not Assigned(pcre_callout_func) then
+    LoadPCRE;
+
+  if not Assigned(pcre_callout_func) then
+  begin
+    Result := nil;
+    if Assigned(LibNotLoadedHandler) then
+      LibNotLoadedHandler;
+  end
+  else
+    Result := pcre_callout_func^;
+end;
+
+function CallPCRECallout(var callout_block: pcre_callout_block): Integer;
+begin
+  Result := pcre_callout_func^(callout_block);
+end;
+
+procedure InitPCREFuncPtrs(const Value: Pointer);
+begin
+  @pcre_compile := Value;
+  @pcre_compile2 := Value;
+  @pcre_config := Value;
+  @pcre_copy_named_substring := Value;
+  @pcre_copy_substring := Value;
+  @pcre_dfa_exec := Value;
+  @pcre_exec := Value;
+  @pcre_free_substring := Value;
+  @pcre_free_substring_list := Value;
+  @pcre_fullinfo := Value;
+  @pcre_get_named_substring := Value;
+  @pcre_get_stringnumber := Value;
+  @pcre_get_stringtable_entries := Value;
+  @pcre_get_substring := Value;
+  @pcre_get_substring_list := Value;
+  @pcre_info := Value;
+  @pcre_maketables := Value;
+  @pcre_refcount := Value;
+  @pcre_study := Value;
+  @pcre_version := Value;
+  pcre_malloc_func := nil;
+  pcre_free_func := nil;
+  pcre_stack_malloc_func := nil;
+  pcre_stack_free_func := nil;
+  pcre_callout_func := nil;
+end;
+
+function IsPCRELoaded: Boolean;
+begin
+  Result := PCRELib <> INVALID_MODULEHANDLE_VALUE;
+end;
+
+function LoadPCRE: Boolean;
+  function GetSymbol(SymbolName: PAnsiChar): Pointer;
+  begin
+    {$IFDEF MSWINDOWS}
+    Result := GetProcAddress(PCRELib, SymbolName);
+    {$ENDIF MSWINDOWS}
+    {$IFDEF UNIX}
+    Result := dlsym(PCRELib, SymbolName);
+    {$ENDIF UNIX}
+  end;
+
+begin
+  Result := PCRELib <> INVALID_MODULEHANDLE_VALUE;
+  if Result then
+    Exit;
+
+  if PCRELib = INVALID_MODULEHANDLE_VALUE then
+    {$IFDEF MSWINDOWS}
+    PCRELib := SafeLoadLibrary(libpcremodulename);
+    {$ENDIF MSWINDOWS}
+    {$IFDEF UNIX}
+    PCRELib := dlopen(PAnsiChar(libpcremodulename), RTLD_NOW);
+    {$ENDIF UNIX}
+  Result := PCRELib <> INVALID_MODULEHANDLE_VALUE;
+  if Result then
+  begin
+    @pcre_compile := GetSymbol(PCRECompileExportName);
+    @pcre_compile2 := GetSymbol(PCRECompile2ExportName);
+    @pcre_config := GetSymbol(PCREConfigExportName);
+    @pcre_copy_named_substring := GetSymbol(PCRECopyNamedSubstringExportName);
+    @pcre_copy_substring := GetSymbol(PCRECopySubStringExportName);
+    @pcre_dfa_exec := GetSymbol(PCREDfaExecExportName);
+    @pcre_exec := GetSymbol(PCREExecExportName);
+    @pcre_free_substring := GetSymbol(PCREFreeSubStringExportName);
+    @pcre_free_substring_list := GetSymbol(PCREFreeSubStringListExportName);
+    @pcre_fullinfo := GetSymbol(PCREFullInfoExportName);
+    @pcre_get_named_substring := GetSymbol(PCREGetNamedSubstringExportName);
+    @pcre_get_stringnumber := GetSymbol(PCREGetStringNumberExportName);
+    @pcre_get_stringtable_entries := GetSymbol(PCREGetStringTableEntriesExportName);
+    @pcre_get_substring := GetSymbol(PCREGetSubStringExportName);
+    @pcre_get_substring_list := GetSymbol(PCREGetSubStringListExportName);
+    @pcre_info := GetSymbol(PCREInfoExportName);
+    @pcre_maketables := GetSymbol(PCREMakeTablesExportName);
+    @pcre_refcount := GetSymbol(PCRERefCountExportName);
+    @pcre_study := GetSymbol(PCREStudyExportName);
+    @pcre_version := GetSymbol(PCREVersionExportName);
+    pcre_malloc_func := GetSymbol(PCREMallocExportName);
+    pcre_free_func := GetSymbol(PCREFreeExportName);
+    pcre_stack_malloc_func := GetSymbol(PCREStackMallocExportName);
+    pcre_stack_free_func := GetSymbol(PCREStackFreeExportName);
+    pcre_callout_func := GetSymbol(PCRECalloutExportName);
+  end
+  else
+    InitPCREFuncPtrs(@LibNotLoadedHandler);
+end;
+
+procedure UnloadPCRE;
+begin
+  if PCRELib <> INVALID_MODULEHANDLE_VALUE then
+    {$IFDEF MSWINDOWS}
+    FreeLibrary(PCRELib);
+    {$ENDIF MSWINDOWS}
+    {$IFDEF UNIX}
+    dlclose(Pointer(PCRELib));
+    {$ENDIF UNIX}
+  PCRELib := INVALID_MODULEHANDLE_VALUE;
+  InitPCREFuncPtrs(@LibNotLoadedHandler);
+end;
+
+(*
+function pcre_compile; external libpcremodulename name PCRECompileExportName;
+function pcre_compile2; external libpcremodulename name PCRECompile2ExportName;
+function pcre_config; external libpcremodulename name PCREConfigExportName;
+function pcre_copy_named_substring; external libpcremodulename name PCRECopyNamedSubStringExportName;
+function pcre_copy_substring; external libpcremodulename name PCRECopySubStringExportName;
+function pcre_dfa_exec; external libpcremodulename name PCREDfaExecExportName;
+function pcre_exec; external libpcremodulename name PCREExecExportName;
+procedure pcre_free_substring; external libpcremodulename name PCREFreeSubStringExportName;
+procedure pcre_free_substring_list; external libpcremodulename name PCREFreeSubStringListExportName;
+function pcre_fullinfo; external libpcremodulename name PCREFullInfoExportName;
+function pcre_get_named_substring; external libpcremodulename name PCREGetNamedSubStringExportName;
+function pcre_get_stringnumber; external libpcremodulename name PCREGetStringNumberExportName;
+function pcre_get_stringtable_entries; external libpcremodulename name PCREGetStringTableEntriesExportName;
+function pcre_get_substring; external libpcremodulename name PCREGetSubStringExportName;
+function pcre_get_substring_list; external libpcremodulename name PCREGetSubStringListExportName;
+function pcre_info; external libpcremodulename name PCREInfoExportName;
+function pcre_maketables; external libpcremodulename name PCREMakeTablesExportName;
+function pcre_refcount; external libpcremodulename name PCRERefCountExportName;
+function pcre_study; external libpcremodulename name PCREStudyExportName;
+function pcre_version; external libpcremodulename name PCREVersionExportName;
+*)
+
+end.
diff --git a/Lua/src/lib/portaudio/portaudio.pas b/Lua/src/lib/portaudio/portaudio.pas
index a0286b48..ea7d06b7 100644
--- a/Lua/src/lib/portaudio/portaudio.pas
+++ b/Lua/src/lib/portaudio/portaudio.pas
@@ -109,8 +109,8 @@ type TPaErrorCode = {enum}cint; const
     paStreamIsNotStopped                    = (paNotInitialized+18);
     paInputOverflowed                       = (paNotInitialized+19);
     paOutputUnderflowed                     = (paNotInitialized+20);
-    paHostApiNotFound                       = (paNotInitialized+21);
-    paInvalidHostApi                        = (paNotInitialized+22);
+    paHostApiNotFound                       = (paNotInitialized+21); // The notes below are from the 
+    paInvalidHostApi                        = (paNotInitialized+22); // original file portaudio.h
     paCanNotReadFromACallbackStream         = (paNotInitialized+23); {**< @todo review error code name *}
     paCanNotWriteToACallbackStream          = (paNotInitialized+24); {**< @todo review error code name *}
     paCanNotReadFromAnOutputOnlyStream      = (paNotInitialized+25); {**< @todo review error code name *}
diff --git a/Lua/src/lib/projectM/projectM.pas b/Lua/src/lib/projectM/projectM.pas
index 4adba17d..533cb19b 100644
--- a/Lua/src/lib/projectM/projectM.pas
+++ b/Lua/src/lib/projectM/projectM.pas
@@ -2,7 +2,7 @@ unit projectM;
 
 {$IFDEF FPC}
   {$MODE DELPHI}
-  {$H+}            (* use AnsiString *)
+  {$H+}            (* use long strings *)
   {$PACKENUM 4}    (* use 4-byte enums *)
   {$PACKRECORDS C} (* C/C++-compatible record packing *)
 {$ELSE}
diff --git a/Lua/src/lib/zlib/zlib.pas b/Lua/src/lib/zlib/zlib.pas
index 31d6a68b..8d09313f 100644
--- a/Lua/src/lib/zlib/zlib.pas
+++ b/Lua/src/lib/zlib/zlib.pas
@@ -14,7 +14,7 @@ interface
 
 {$ifdef FPC}
   {$mode objfpc} // Needed for array of const
-  {$H+} // use AnsiString
+  {$H+} // use long strings
   {$PACKRECORDS C}
 {$endif}
author	whiteshark0 <whiteshark0@b956fd51-792f-4845-bead-9b4dfca2ff2c>	2009-12-11 17:34:54 +0000
committer	whiteshark0 <whiteshark0@b956fd51-792f-4845-bead-9b4dfca2ff2c>	2009-12-11 17:34:54 +0000
commit	1ab628e8ad6c85c8f1b562f10480253ee3e622b7 (patch)
tree	d21621f68850ecd7762137e1c4387fa15731a811 /Lua/src/lib
parent	6ec275387c320d3d9a8f5b6fe185687643565b8c (diff)
download	usdx-1ab628e8ad6c85c8f1b562f10480253ee3e622b7.tar.gz usdx-1ab628e8ad6c85c8f1b562f10480253ee3e622b7.tar.xz usdx-1ab628e8ad6c85c8f1b562f10480253ee3e622b7.zip