开通博客赚积分
发布资源赚积分
分类

源码开发语言/平台
当前位置：首页 > 源码/资料 > Windows编程 > 查看源码
JwaWinType.pas
资源名称：win32api.zip　[点击查看]
上传用户：davidchvip
上传日期：2009-07-28
资源大小：1749k
文件大小：46k
源码类别：

Windows编程

开发平台：

Delphi

JwaWinType.pas：源码内容
  1. {******************************************************************************}
  2. {                                                                       }
  3. { Windows Base Types API interface Unit for Object Pascal                      }
  4. {                                                                       }
  5. { Portions created by Microsoft are Copyright (C) 1995-2001 Microsoft          }
  6. { Corporation. All Rights Reserved.                                            }
  7. {                 }
  8. { The original file is: basetsd.h, released August 2001. The original Pascal   }
  9. { code is: WinType.pas, released December 2000. The initial developer of the   }
  10. { Pascal code is Marcel van Brakel (brakelm@chello.nl).                        }
  11. {                                                                              }
  12. { Portions created by Marcel van Brakel are Copyright (C) 1999-2001            }
  13. { Marcel van Brakel. All Rights Reserved.                                      }
  14. {                 }
  15. { Obtained through: Joint Endeavour of Delphi Innovators (Project JEDI)        }
  16. {                }
  17. { You may retrieve the latest version of this file at the Project JEDI home    }
  18. { page, located at http://delphi-jedi.org or my personal homepage located at   }
  19. { http://members.chello.nl/m.vanbrakel2                                        }
  20. {                }
  21. { The contents of this file are used with permission, subject to the Mozilla   }
  22. { Public License Version 1.1 (the "License"); you may not use this file except }
  23. { in compliance with the License. You may obtain a copy of the License at      }
  24. { http://www.mozilla.org/MPL/MPL-1.1.html                                      }
  25. {                                                                              }
  26. { Software distributed under the License is distributed on an "AS IS" basis,   }
  27. { WITHOUT WARRANTY OF ANY KIND, either express or implied. See the License for }
  28. { the specific language governing rights and limitations under the License.    }
  29. {                                                                              }
  30. { Alternatively, the contents of this file may be used under the terms of the  }
  31. { GNU Lesser General Public License (the  "LGPL License"), in which case the   }
  32. { provisions of the LGPL License are applicable instead of those above.        }
  33. { If you wish to allow use of your version of this file only under the terms   }
  34. { of the LGPL License and not to allow others to use your version of this file }
  35. { under the MPL, indicate your decision by deleting  the provisions above and  }
  36. { replace  them with the notice and other provisions required by the LGPL      }
  37. { License.  If you do not delete the provisions above, a recipient may use     }
  38. { your version of this file under either the MPL or the LGPL License.          }
  39. {                 }
  40. { For more information about the LGPL: http://www.gnu.org/copyleft/lesser.html }
  41. {                 }
  42. {******************************************************************************}
  44. unit JwaWinType;
  46. {$WEAKPACKAGEUNIT}
  48. {$HPPEMIT ''}
  49. {$HPPEMIT '#include "BaseTsd.h"'}
  50. {$HPPEMIT '#include "BaseTyps.h"'}
  51. {$HPPEMIT '#include "NtDef.h"'}
  52. {$HPPEMIT '#include "WinDef.h"'}
  53. {$HPPEMIT ''}
  54. {$HPPEMIT 'typedef LPVOID *LPLPVOID'}
  55. {$HPPEMIT 'typedef GUID TGUID'}
  56. {$HPPEMIT 'typedef GUID *LPGUID'}
  57. {$HPPEMIT 'typedef GUID CLSID'}
  58. {$HPPEMIT 'typedef HMODULE *PHMODULE'}
  59. {$HPPEMIT ''}
  61. {$I WINDEFINES.INC}
  63. interface
  65. uses
  66.   Windows, SysUtils; // TODO
  68. type
  69.   EJwaError = class (Exception)
  70.   end;
  72.   EJwaLoadLibraryError = class (EJwaError)
  73.   end;
  75.   EJwaGetProcAddressError = class (EJwaError)
  76.   end;
  78. procedure GetProcedureAddress(var P: Pointer; const ModuleName, ProcName: string);
  80. type
  81.   LPLPSTR = ^LPSTR;
  82.   {$NODEFINE LPLPSTR}
  83.   LPLPCSTR = ^LPCSTR;
  84.   {$NODEFINE LPLPCSTR}
  85.   LPLPCWSTR = ^LPCWSTR;
  86.   {$NODEFINE LPLPCWSTR}
  87.   LPLPWSTR = ^LPWSTR;
  88.   {$NODEFINE LPLPWSTR}
  90.   PPChar = ^PChar;
  91.   PPWideChar = ^PWideChar;
  92.   PPointer = ^Pointer;
  94.   GUID = TGUID;
  95.   {$NODEFINE GUID}
  96.   LPGUID = ^GUID;
  97.   {$NODEFINE LPGUID}
  98.   CLSID = TGUID;
  99.   {$NODEFINE CLSID}
  101. // ntdef.h
  103. type
  105. //typedef double DOUBLE;
  107.   PQuad = ^TQuad;
  108.   _QUAD = record                // QUAD is for those times we want
  109.     DoNotUseThisField: Double;  // an 8 byte aligned 8 byte long structure
  110.   end;                          // which is NOT really a floating point
  111.   {$EXTERNALSYM _QUAD}          // number.  Use DOUBLE if you want an FP number.
  112.   QUAD = _QUAD;
  113.   {$EXTERNALSYM QUAD}
  114.   TQuad = _QUAD;
  116. //
  117. // Unsigned Basics
  118. //
  120.   UCHAR = {$IFDEF USE_DELPHI_TYPES}Windows.UCHAR{$ELSE}Char{$ENDIF};
  121.   {$EXTERNALSYM UCHAR}
  122.   USHORT = Word;
  123.   {$EXTERNALSYM USHORT}
  124.   ULONG = {$IFDEF USE_DELPHI_TYPES}Windows.ULONG{$ELSE}Longword{$ENDIF};
  125.   {$EXTERNALSYM ULONG}
  126.   UQUAD = QUAD;
  127.   {$EXTERNALSYM UQUAD}
  129. //
  130. // __int64 is only supported by 2.0 and later midl.
  131. // __midl is set by the 2.0 midl and not by 1.0 midl.
  132. //
  134. type
  135.   LONGLONG = {$IFDEF USE_DELPHI_TYPES}Windows.LONGLONG{$ELSE}Int64{$ENDIF};
  136.   {$EXTERNALSYM LONGLONG}
  137.   ULONGLONG = Int64;
  138.   {$EXTERNALSYM ULONGLONG}
  140. const
  141.   MAXLONGLONG = $7fffffffffffffff;
  142.   {$EXTERNALSYM MAXLONGLONG}
  144. type
  145.   PLONGLONG = ^LONGLONG;
  146.   {$EXTERNALSYM PLONGLONG}
  147.   PULONGLONG = ^ULONGLONG;
  148.   {$EXTERNALSYM PULONGLONG}
  150.   BOOL = {$IFDEF USE_DELPHI_TYPES}Windows.BOOL{$ELSE}LongBool{$ENDIF};
  151.   {$EXTERNALSYM BOOL}
  153.   DWORD = {$IFDEF USE_DELPHI_TYPES}Windows.DWORD{$ELSE}Longword{$ENDIF};
  154.   {$EXTERNALSYM DWORD}
  156. const
  157.   ANYSIZE_ARRAY = 1;
  158.   {$EXTERNALSYM ANYSIZE_ARRAY}
  160.   MAX_NATURAL_ALIGNMENT = SizeOf(ULONG);
  161.   {$EXTERNALSYM MAX_NATURAL_ALIGNMENT}
  163. //
  164. // Void
  165. //
  167. type
  168.   PVOID = Pointer;
  169.   {$EXTERNALSYM PVOID}
  170.   PPVOID = ^PVOID;
  171.   {$EXTERNALSYM PPVOID}
  172.   PVOID64 = Pointer;
  173.   {$EXTERNALSYM PVOID64}
  175. //
  176. // Basics
  177. //
  179.   SHORT = {$IFDEF USE_DELPHI_TYPES}Windows.SHORT{$ELSE}Smallint{$ENDIF};
  180.   {$EXTERNALSYM SHORT}
  181.   LONG = Longint;
  182.   {$EXTERNALSYM LONG}
  184. //
  185. // UNICODE (Wide Character) types
  186. //
  188.   WCHAR = {$IFDEF USE_DELPHI_TYPES}Windows.WCHAR{$ELSE}WideChar{$ENDIF};
  189.   {$EXTERNALSYM WCHAR}
  191.   PWCHAR = {$IFDEF USE_DELPHI_TYPES}Windows.PWChar{$ELSE}^WCHAR{$ENDIF};
  192.   {$EXTERNALSYM PWCHAR}
  193.   LPWCH = ^WCHAR;
  194.   {$EXTERNALSYM LPWCH}
  195.   PWCH = ^WCHAR;
  196.   {$EXTERNALSYM PWCH}
  197.   LPCWCH = ^WCHAR;
  198.   {$EXTERNALSYM LPCWCH}
  199.   PCWCH = ^WCHAR;
  200.   {$EXTERNALSYM PCWCH}
  201.   NWPSTR = ^WCHAR;
  202.   {$EXTERNALSYM NWPSTR}
  203.   LPWSTR = {$IFDEF USE_DELPHI_TYPES}Windows.LPWSTR{$ELSE}^WCHAR{$ENDIF};
  204.   {$EXTERNALSYM LPWSTR}
  205.   LPCWSTR = {$IFDEF USE_DELPHI_TYPES}Windows.LPCWSTR{$ELSE}^WCHAR{$ENDIF};
  206.   {$EXTERNALSYM LPCWSTR}
  207.   PWSTR = {$IFDEF USE_DELPHI_TYPES}Windows.LPWSTR{$ELSE}^WCHAR{$ENDIF};
  208.   {$EXTERNALSYM PWSTR}
  209.   LPUWSTR = {$IFDEF USE_DELPHI_TYPES}Windows.LPWSTR{$ELSE}^WCHAR{$ENDIF};
  210.   {$EXTERNALSYM LPUWSTR}
  211.   PUWSTR = {$IFDEF USE_DELPHI_TYPES}Windows.LPWSTR{$ELSE}^WCHAR{$ENDIF};
  212.   {$EXTERNALSYM PUWSTR}
  213.   LCPUWSTR = {$IFDEF USE_DELPHI_TYPES}Windows.LPWSTR{$ELSE}^WCHAR{$ENDIF};
  214.   {$EXTERNALSYM LCPUWSTR}
  215.   PCUWSTR = {$IFDEF USE_DELPHI_TYPES}Windows.LPWSTR{$ELSE}^WCHAR{$ENDIF};
  216.   {$EXTERNALSYM PCUWSTR}
  218. //
  219. // ANSI (Multi-byte Character) types
  220. //
  222.   LPCH = ^CHAR;
  223.   {$EXTERNALSYM LPCH}
  224.   PCH = ^CHAR;
  225.   {$EXTERNALSYM PCH}
  227.   LPCCH = ^CHAR;
  228.   {$EXTERNALSYM LPCCH}
  229.   PCCH = ^CHAR;
  230.   {$EXTERNALSYM PCCH}
  231.   NPSTR = ^CHAR;
  232.   {$EXTERNALSYM NPSTR}
  233.   LPSTR = {$IFDEF USE_DELPHI_TYPES}Windows.LPSTR{$ELSE}^CHAR{$ENDIF};
  234.   {$EXTERNALSYM LPSTR}
  235.   PSTR = {$IFDEF USE_DELPHI_TYPES}PChar{$ELSE}^CHAR{$ENDIF};
  236.   {$EXTERNALSYM PSTR}
  237.   LPCSTR = {$IFDEF USE_DELPHI_TYPES}Windows.LPCSTR{$ELSE}^CHAR{$ENDIF};
  238.   {$EXTERNALSYM LPCSTR}
  239.   PCSTR = {$IFDEF USE_DELPHI_TYPES}PChar{$ELSE}^CHAR{$ENDIF};
  240.   {$EXTERNALSYM PCSTR}
  242. //
  243. // Neutral ANSI/UNICODE types and macros
  244. //
  246. {$IFDEF UNICODE}
  248.   TCHAR = WCHAR;
  249.   {$EXTERNALSYM TCHAR}
  250.   PTCHAR = ^TCHAR;
  251.   {$EXTERNALSYM PTCHAR}
  252.   TUCHAR = WCHAR;
  253.   {$EXTERNALSYM TUCHAR}
  254.   PTUCHAR = ^TUCHAR;
  255.   {$EXTERNALSYM PTUCHAR}
  257.   LPTCH = LPWSTR;
  258.   {$EXTERNALSYM LPTCH}
  259.   PTCH = LPWSTR;
  260.   {$EXTERNALSYM PTCH}
  261.   PTSTR = LPWSTR;
  262.   {$EXTERNALSYM PTSTR}
  263.   LPTSTR = {$IFDEF USE_DELPHI_TYPES}Windows.LPTSTR{$ELSE}LPWSTR{$ENDIF};
  264.   {$EXTERNALSYM LPTSTR}
  265.   PCTSTR = LPCWSTR;
  266.   {$EXTERNALSYM PCTSTR}
  267.   LPCTSTR = {$IFDEF USE_DELPHI_TYPES}Windows.LPCTSTR{$ELSE}LPCWSTR{$ENDIF};
  268.   {$EXTERNALSYM LPCTSTR}
  270.   PCUTSTR = {$IFDEF USE_DELPHI_TYPES}Windows.LPCTSTR{$ELSE}LPCWSTR{$ENDIF};
  271.   {$EXTERNALSYM PCUTSTR}
  272.   LPCUTSTR = {$IFDEF USE_DELPHI_TYPES}Windows.LPCTSTR{$ELSE}LPCWSTR{$ENDIF};
  273.   {$EXTERNALSYM LPCUTSTR}
  274.   PUTSTR = {$IFDEF USE_DELPHI_TYPES}Windows.LPCSTR{$ELSE}LPCWSTR{$ENDIF};
  275.   {$EXTERNALSYM PUTSTR}
  276.   LPUTSTR = {$IFDEF USE_DELPHI_TYPES}Windows.LPCSTR{$ELSE}LPCWSTR{$ENDIF};
  277.   {$EXTERNALSYM LPUTSTR}
  279.   __TEXT = WideString;
  280.   {$EXTERNALSYM __TEXT}
  282. {$ELSE}
  284.   TCHAR = CHAR;
  285.   {$EXTERNALSYM TCHAR}
  286.   PTCHAR = ^TCHAR;
  287.   {$EXTERNALSYM PTCHAR}
  288.   TUCHAR = CHAR;
  289.   {$EXTERNALSYM TUCHAR}
  290.   PTUCHAR = ^TUCHAR;
  291.   {$EXTERNALSYM PTUCHAR}
  293.   LPTCH = LPSTR;
  294.   {$EXTERNALSYM LPTCH}
  295.   PTCH = LPSTR;
  296.   {$EXTERNALSYM PTCH}
  297.   PTSTR = LPSTR;
  298.   {$EXTERNALSYM PTSTR}
  299.   LPTSTR = {$IFDEF USE_DELPHI_TYPES}Windows.LPTSTR{$ELSE}LPSTR{$ENDIF};
  300.   {$EXTERNALSYM LPTSTR}
  301.   PCTSTR = LPCSTR;
  302.   {$EXTERNALSYM PCTSTR}
  303.   LPCTSTR = {$IFDEF USE_DELPHI_TYPES}Windows.LPCTSTR{$ELSE}LPCSTR{$ENDIF};
  304.   {$EXTERNALSYM LPCTSTR}
  306.   PCUTSTR = {$IFDEF USE_DELPHI_TYPES}Windows.LPCSTR{$ELSE}LPCSTR{$ENDIF};
  307.   {$EXTERNALSYM PCUTSTR}
  308.   LPCUTSTR = {$IFDEF USE_DELPHI_TYPES}Windows.LPCSTR{$ELSE}LPCSTR{$ENDIF};
  309.   {$EXTERNALSYM LPCUTSTR}
  310.   PUTSTR = {$IFDEF USE_DELPHI_TYPES}Windows.LPCSTR{$ELSE}LPCSTR{$ENDIF};
  311.   {$EXTERNALSYM PUTSTR}
  312.   LPUTSTR = {$IFDEF USE_DELPHI_TYPES}Windows.LPCSTR{$ELSE}LPCSTR{$ENDIF};
  313.   {$EXTERNALSYM LPUTSTR}
  315.   __TEXT = AnsiString;
  316.   {$EXTERNALSYM __TEXT}
  318. {$ENDIF}
  320.   TEXT = __TEXT;
  321.   {$EXTERNALSYM TEXT}
  323. //
  324. // Pointer to Basics
  325. //
  327.   PSHORT = ^SHORT;
  328.   {$EXTERNALSYM PSHORT}
  329.   PLONG = ^LONG;
  330.   {$EXTERNALSYM PLONG}
  332. //
  333. // Pointer to Unsigned Basics
  334. //
  336.   PUCHAR = {$IFDEF USE_DELPHI_TYPES}Windows.PUCHAR{$ELSE}^UCHAR{$ENDIF};
  337.   {$EXTERNALSYM PUCHAR}
  338.   PUSHORT = ^USHORT;
  339.   {$EXTERNALSYM PUSHORT}
  340.   PULONG = {$IFDEF USE_DELPHI_TYPES}Windows.PULONG{$ELSE}^ULONG{$ENDIF};
  341.   {$EXTERNALSYM PULONG}
  342.   PUQUAD = ^UQUAD;
  343.   {$EXTERNALSYM PUQUAD}
  345. //
  346. // Signed characters
  347. //
  349.   SCHAR = Shortint;
  350.   {$EXTERNALSYM SCHAR}
  351.   PSCHAR = ^SCHAR;
  352.   {$EXTERNALSYM PSCHAR}
  354. //
  355. // Handle to an Object
  356. //
  358.   HANDLE = {$IFDEF USE_DELPHI_TYPES}Windows.THandle{$ELSE}Longword{$ENDIF};
  359.   {$EXTERNALSYM HANDLE}
  360.   PHANDLE = {$IFDEF USE_DELPHI_TYPES}Windows.PHandle{$ELSE}^HANDLE{$ENDIF};
  361.   {$EXTERNALSYM PHANDLE}
  362.   THandle = {$IFDEF USE_DELPHI_TYPES}Windows.THandle{$ELSE}HANDLE{$ENDIF};
  364. //
  365. // Flag (bit) fields
  366. //
  368.   FCHAR = UCHAR;
  369.   {$EXTERNALSYM FCHAR}
  370.   FSHORT = USHORT;
  371.   {$EXTERNALSYM FSHORT}
  372.   FLONG = ULONG;
  373.   {$EXTERNALSYM FLONG}
  375. // Component Object Model defines, and macros
  377.   HRESULT = System.HRESULT; // LONG;
  378.   {$EXTERNALSYM HRESULT}
  380. //
  381. // Low order two bits of a handle are ignored by the system and available
  382. // for use by application code as tag bits.  The remaining bits are opaque
  383. // and used to store a serial number and table index.
  384. //
  386. const
  387.   OBJ_HANDLE_TAGBITS = $00000003;
  388.   {$EXTERNALSYM OBJ_HANDLE_TAGBITS}
  390. //
  391. // Cardinal Data Types [0 - 2**N-2)
  392. //
  394. type
  395.   CCHAR = Char;
  396.   {$EXTERNALSYM CCHAR}
  397.   CSHORT = Shortint;
  398.   {$EXTERNALSYM CSHORT}
  399.   CLONG = ULONG;
  400.   {$EXTERNALSYM CLONG}
  402.   PCCHAR = ^CCHAR;
  403.   {$EXTERNALSYM PCCHAR}
  404.   PCSHORT = ^CSHORT;
  405.   {$EXTERNALSYM PCSHORT}
  406.   PCLONG = ^CLONG;
  407.   {$EXTERNALSYM PCLONG}
  409. //
  410. // NLS basics (Locale and Language Ids)
  411. //
  413.   LCID = {$IFDEF USE_DELPHI_TYPES}Windows.LCID{$ELSE}ULONG{$ENDIF};
  414.   {$EXTERNALSYM LCID}
  415.   PLCID = {$IFDEF USE_DELPHI_TYPES}^LCID{$ELSE}PULONG{$ENDIF};
  416.   {$EXTERNALSYM PLCID}
  417.   LANGID = {$IFDEF USE_DELPHI_TYPES}Windows.LANGID{$ELSE}USHORT{$ENDIF};
  418.   {$EXTERNALSYM LANGID}
  419.   PLANGID = ^LANGID; // TODO Not in original header (used in MSI)
  421. //
  422. // Logical Data Type - These are 32-bit logical values.
  423. //
  425.   LOGICAL = ULONG;
  426.   {$EXTERNALSYM LOGICAL}
  427.   PLOGICAL = ^ULONG;
  428.   {$EXTERNALSYM PLOGICAL}
  430. //
  431. // NTSTATUS
  432. //
  434.   NTSTATUS = LONG;
  435.   {$EXTERNALSYM NTSTATUS}
  436.   PNTSTATUS = ^NTSTATUS;
  437.   {$EXTERNALSYM PNTSTATUS}
  438.   TNTStatus = NTSTATUS;
  440. //
  441. //  Status values are 32 bit values layed out as follows:
  442. //
  443. //   3 3 2 2 2 2 2 2 2 2 2 2 1 1 1 1 1 1 1 1 1 1
  444. //   1 0 9 8 7 6 5 4 3 2 1 0 9 8 7 6 5 4 3 2 1 0 9 8 7 6 5 4 3 2 1 0
  445. //  +---+-+-------------------------+-------------------------------+
  446. //  |Sev|C|       Facility          |               Code            |
  447. //  +---+-+-------------------------+-------------------------------+
  448. //
  449. //  where
  450. //
  451. //      Sev - is the severity code
  452. //
  453. //          00 - Success
  454. //          01 - Informational
  455. //          10 - Warning
  456. //          11 - Error
  457. //
  458. //      C - is the Customer code flag
  459. //
  460. //      Facility - is the facility code
  461. //
  462. //      Code - is the facility's status code
  463. //
  465. //
  466. // Generic test for success on any status value (non-negative numbers
  467. // indicate success).
  468. //
  470. function NT_SUCCESS(Status: NTSTATUS): BOOL;
  471. {$EXTERNALSYM NT_SUCCESS}
  473. //
  474. // Generic test for information on any status value.
  475. //
  477. function NT_INFORMATION(Status: NTSTATUS): BOOL;
  478. {$EXTERNALSYM NT_INFORMATION}
  480. //
  481. // Generic test for warning on any status value.
  482. //
  484. function NT_WARNING(Status: NTSTATUS): BOOL;
  485. {$EXTERNALSYM NT_WARNING}
  487. //
  488. // Generic test for error on any status value.
  489. //
  491. function NT_ERROR(Status: NTSTATUS): BOOL;
  492. {$EXTERNALSYM NT_ERROR}
  494. const
  495.   APPLICATION_ERROR_MASK       = $20000000;
  496.   {$EXTERNALSYM APPLICATION_ERROR_MASK}
  497.   ERROR_SEVERITY_SUCCESS       = $00000000;
  498.   {$EXTERNALSYM ERROR_SEVERITY_SUCCESS}
  499.   ERROR_SEVERITY_INFORMATIONAL = $40000000;
  500.   {$EXTERNALSYM ERROR_SEVERITY_INFORMATIONAL}
  501.   ERROR_SEVERITY_WARNING       = DWORD($80000000);
  502.   {$EXTERNALSYM ERROR_SEVERITY_WARNING}
  503.   ERROR_SEVERITY_ERROR         = DWORD($C0000000);
  504.   {$EXTERNALSYM ERROR_SEVERITY_ERROR}
  506. //
  507. // Large (64-bit) integer types and operations
  508. //
  510. type
  511.   LPLARGE_INTEGER = ^LARGE_INTEGER;
  512.   {$EXTERNALSYM LPLARGE_INTEGER}
  514. {$IFDEF USE_DELPHI_TYPES}
  515.   _LARGE_INTEGER = Windows._LARGE_INTEGER;
  516.   LARGE_INTEGER = Windows.LARGE_INTEGER;
  517.   TLargeInteger = Windows.TLargeInteger;
  518. {$ELSE}
  519.   _LARGE_INTEGER = record
  520.     case Integer of
  521.     0: (
  522.       LowPart: DWORD;
  523.       HighPart: LONG);
  524.     1: (
  525.       QuadPart: LONGLONG);
  526.   end;
  527.   {$EXTERNALSYM _LARGE_INTEGER}
  528.   LARGE_INTEGER = _LARGE_INTEGER;
  529.   {$EXTERNALSYM LARGE_INTEGER}
  530.   TLargeInteger = LARGE_INTEGER;
  531. {$ENDIF}
  533.   PLARGE_INTEGER = ^LARGE_INTEGER;
  534.   {$EXTERNALSYM PLARGE_INTEGER}
  535.   PLargeInteger = LPLARGE_INTEGER;
  537.   LPULARGE_INTEGER = ^ULARGE_INTEGER;
  538.   {$EXTERNALSYM LPULARGE_INTEGER}
  540. {$IFDEF USE_DELPHI_TYPES}
  541.   ULARGE_INTEGER = Windows.ULARGE_INTEGER;
  542.   TULargeInteger = Windows.TULargeInteger;
  543.   PULargeInteger = Windows.PULargeInteger;
  544. {$ELSE}
  545.   ULARGE_INTEGER = record
  546.     case Integer of
  547.       0: (
  548.         LowPart: DWORD;
  549.         HighPart: DWORD);
  550.       1: (
  551.         QuadPart: LONGLONG);
  552.   end;
  553.   {$EXTERNALSYM ULARGE_INTEGER}
  554.   TULargeInteger = ULARGE_INTEGER;
  555.   PULargeInteger = LPULARGE_INTEGER;
  556. {$ENDIF}
  558.   PULARGE_INTEGER = ^ULARGE_INTEGER;
  559.   {$EXTERNALSYM PULARGE_INTEGER}
  561.   TIME = LARGE_INTEGER;
  562.   {$EXTERNALSYM TIME}
  563.   _TIME = _LARGE_INTEGER;
  564.   {$EXTERNALSYM _TIME}
  565.   PTIME = PLARGE_INTEGER;
  566.   {$EXTERNALSYM PTIME}
  568. //
  569. // _M_IX86 included so that EM CONTEXT structure compiles with
  570. // x86 programs. *** TBD should this be for all architectures?
  571. //
  573. //
  574. // 16 byte aligned type for 128 bit floats
  575. //
  577. //
  578. // For we define a 128 bit structure and use __declspec(align(16)) pragma to
  579. // align to 128 bits.
  580. //
  582. type
  583.   PFloat128 = ^TFloat128;
  584.   _FLOAT128 = record
  585.     LowPart: Int64;
  586.     HighPart: Int64;
  587.   end;
  588.   {$EXTERNALSYM _FLOAT128}
  589.   FLOAT128 = _FLOAT128;
  590.   {$EXTERNALSYM FLOAT128}
  591.   TFloat128 = FLOAT128;
  593. // Update Sequence Number
  595.   USN = LONGLONG;
  596.   {$EXTERNALSYM USN}
  598. //
  599. // Locally Unique Identifier
  600. //
  602. type
  603.   PLuid = ^LUID;
  604.   _LUID = record
  605.     LowPart: DWORD;
  606.     HighPart: LONG;
  607.   end;
  608.   {$EXTERNALSYM _LUID}
  609.   LUID = _LUID;
  610.   {$EXTERNALSYM LUID}  
  611.   TLuid = LUID;
  613.   DWORDLONG = ULONGLONG;
  614.   {$EXTERNALSYM DWORDLONG}
  615.   PDWORDLONG = ^DWORDLONG;
  616.   {$EXTERNALSYM PDWORDLONG}
  618. //
  619. // Physical address.
  620. //
  622.   PHYSICAL_ADDRESS = LARGE_INTEGER;
  623.   {$EXTERNALSYM PHYSICAL_ADDRESS}
  624.   PPHYSICAL_ADDRESS = ^LARGE_INTEGER;
  625.   {$EXTERNALSYM PPHYSICAL_ADDRESS}
  627. //
  628. // Define operations to logically shift an int64 by 0..31 bits and to multiply
  629. // 32-bits by 32-bits to form a 64-bit product.
  630. //
  632. //
  633. // The x86 C compiler understands inline assembler. Therefore, inline functions
  634. // that employ inline assembler are used for shifts of 0..31.  The multiplies
  635. // rely on the compiler recognizing the cast of the multiplicand to int64 to
  636. // generate the optimal code inline.
  637. //
  639. function Int32x32To64(a, b: LONG): LONGLONG;
  640. {$EXTERNALSYM Int32x32To64}
  641. function UInt32x32To64(a, b: DWORD): ULONGLONG;
  642. {$EXTERNALSYM UInt32x32To64}
  644. function Int64ShllMod32(Value: ULONGLONG; ShiftCount: DWORD): ULONGLONG;
  646. {$EXTERNALSYM Int64ShllMod32}
  647. function Int64ShraMod32(Value: LONGLONG; ShiftCount: DWORD): LONGLONG;
  648. {$EXTERNALSYM Int64ShraMod32}
  649. function Int64ShrlMod32(Value: ULONGLONG; ShiftCount: DWORD): ULONGLONG;
  650. {$EXTERNALSYM Int64ShrlMod32}
  652. //
  653. // Event type
  654. //
  656. type
  657.   _EVENT_TYPE = (NotificationEvent, SynchronizationEvent);
  658.   {$EXTERNALSYM _EVENT_TYPE}
  659.   EVENT_TYPE = _EVENT_TYPE;
  660.   {$EXTERNALSYM EVENT_TYPE}
  661.   TEventType = _EVENT_TYPE;
  663. //
  664. // Timer type
  665. //
  667.   _TIMER_TYPE = (NotificationTimer, SynchronizationTimer);
  668.   {$EXTERNALSYM _TIMER_TYPE}
  669.   TIMER_TYPE = _TIMER_TYPE;
  670.   {$EXTERNALSYM TIMER_TYPE}
  672. //
  673. // Wait type
  674. //
  676.   _WAIT_TYPE = (WaitAll, WaitAny);
  677.   {$EXTERNALSYM _WAIT_TYPE}
  678.   WAIT_TYPE = _WAIT_TYPE;
  679.   {$EXTERNALSYM WAIT_TYPE}
  681. //
  682. // Pointer to an Asciiz string
  683. //
  685.   PSZ = ^CHAR;
  686.   {$EXTERNALSYM PSZ}
  687.   PCSZ = ^CHAR;
  688.   {$EXTERNALSYM PCSZ}
  690. //
  691. // Counted String
  692. //
  694.   PString = ^TString;
  695.   _STRING = record
  696.     Length: USHORT;
  697.     MaximumLength: USHORT;
  698.     Buffer: PCHAR;
  699.   end;
  700.   {$EXTERNALSYM _STRING}
  701.   TString = _STRING;
  703.   ANSI_STRING = _STRING;
  704.   {$EXTERNALSYM ANSI_STRING}
  705.   PANSI_STRING = PSTRING;
  706.   {$EXTERNALSYM PANSI_STRING}
  708.   OEM_STRING = _STRING;
  709.   {$EXTERNALSYM OEM_STRING}
  710.   POEM_STRING = PSTRING;
  711.   {$EXTERNALSYM POEM_STRING}
  713. //
  714. // CONSTCounted String
  715. //
  717.   PCString = ^CSTRING;
  718.   _CSTRING = record
  719.     Length: USHORT;
  720.     MaximumLength: USHORT;
  721.     Buffer: PCHAR;
  722.   end;
  723.   {$EXTERNALSYM _CSTRING}
  724.   CSTRING = _CSTRING;
  725.   {$EXTERNALSYM CSTRING}
  726.   TCString = CSTRING;
  728. const
  729.   ANSI_NULL = CHAR(0);
  730.   {$EXTERNALSYM ANSI_NULL}
  731.   UNICODE_NULL = WCHAR(0);
  732.   {$EXTERNALSYM UNICODE_NULL}
  733.   UNICODE_STRING_MAX_BYTES = WORD(65534);
  734.   {$EXTERNALSYM UNICODE_STRING_MAX_BYTES}
  735.   UNICODE_STRING_MAX_CHARS = 32767;
  736.   {$EXTERNALSYM UNICODE_STRING_MAX_CHARS}
  738. type
  739.   CANSI_STRING = _STRING;
  740.   {$EXTERNALSYM CANSI_STRING}
  741.   PCANSI_STRING = PSTRING;
  742.   {$EXTERNALSYM PCANSI_STRING}
  744. //
  745. // Unicode strings are counted 16-bit character strings. If they are
  746. // NULL terminated, Length does not include trailing NULL.
  747. //
  749. type
  750.   PUNICODE_STRING = ^UNICODE_STRING;
  751.   {$EXTERNALSYM PUNICODE_STRING}
  752.   _UNICODE_STRING = record
  753.     Length: USHORT;
  754.     MaximumLength: USHORT;
  755.     Buffer: PWSTR;
  756.   end;
  757.   {$EXTERNALSYM _UNICODE_STRING}
  758.   UNICODE_STRING = _UNICODE_STRING;
  759.   {$EXTERNALSYM UNICODE_STRING}
  760.   PCUNICODE_STRING = ^UNICODE_STRING;
  761.   {$EXTERNALSYM PCUNICODE_STRING}
  762.   TUnicodeString = UNICODE_STRING;
  763.   PUnicodeString = PUNICODE_STRING;
  765. //
  766. // Boolean
  767. //
  769. type
  770. //typedef UCHAR BOOLEAN;
  771.   PBOOLEAN = ^ByteBool;
  772.   {$EXTERNALSYM PBOOLEAN}
  774. //
  775. //  Doubly linked list structure.  Can be used as either a list head, or
  776. //  as link words.
  777. //
  779. type
  780.   PLIST_ENTRY = ^LIST_ENTRY;
  781.   {$EXTERNALSYM PLIST_ENTRY}
  783. {$IFDEF USE_DELPHI_TYPES}
  784.   _LIST_ENTRY = Windows._LIST_ENTRY;
  785.   LIST_ENTRY = Windows.LIST_ENTRY;
  786.   TListEntry = Windows.TListEntry;
  787.   PListEntry = Windows.PListEntry;
  788. {$ELSE}
  789.   _LIST_ENTRY = record
  790.     Flink: PLIST_ENTRY;
  791.     Blink: PLIST_ENTRY;
  792.   end;
  793.   {$EXTERNALSYM _LIST_ENTRY}
  794.   LIST_ENTRY = _LIST_ENTRY;
  795.   {$EXTERNALSYM LIST_ENTRY}
  796.   TListEntry = LIST_ENTRY;
  797.   PListEntry = PLIST_ENTRY;
  798. {$ENDIF}
  800.   PRLIST_ENTRY = ^LIST_ENTRY;
  801.   {$EXTERNALSYM PLIST_ENTRY}
  803. //
  804. //  Singly linked list structure. Can be used as either a list head, or
  805. //  as link words.
  806. //
  808.   PSINGLE_LIST_ENTRY = ^SINGLE_LIST_ENTRY;
  809.   {$EXTERNALSYM PSINGLE_LIST_ENTRY}
  810.   _SINGLE_LIST_ENTRY = record
  811.     Next: PSINGLE_LIST_ENTRY;
  812.   end;
  813.   {$EXTERNALSYM _SINGLE_LIST_ENTRY}
  814.   SINGLE_LIST_ENTRY = _SINGLE_LIST_ENTRY;
  815.   {$EXTERNALSYM SINGLE_LIST_ENTRY}
  816.   TSingleListEntry = SINGLE_LIST_ENTRY;
  817.   PSingleListEntry = PSINGLE_LIST_ENTRY;
  819. //
  820. // These are needed for portable debugger support.
  821. //
  823.   PLIST_ENTRY32 = ^LIST_ENTRY32;
  824.   {$EXTERNALSYM PLIST_ENTRY32}  
  825.   {$EXTERNALSYM PLIST_ENTRY32}
  826.   LIST_ENTRY32 = record
  827.     Flink: DWORD;
  828.     Blink: DWORD;
  829.   end;
  830.   {$EXTERNALSYM LIST_ENTRY32}
  831.   TListEntry32 = LIST_ENTRY32;
  832.   PListEntry32 = PLIST_ENTRY32;
  834.   PLIST_ENTRY64 = ^LIST_ENTRY64;
  835.   {$EXTERNALSYM PLIST_ENTRY64}
  836.   LIST_ENTRY64 = record
  837.     Flink: ULONGLONG;
  838.     Blink: ULONGLONG;
  839.   end;
  840.   {$EXTERNALSYM LIST_ENTRY64}
  841.   TListEntry64 = LIST_ENTRY64;
  842.   PListEntry64 = PLIST_ENTRY64;
  844. procedure ListEntry32To64(l32: PLIST_ENTRY32; l64: PLIST_ENTRY64);
  845. {$EXTERNALSYM ListEntry32To64}
  847. procedure ListEntry64To32(l64: PLIST_ENTRY64; l32: PLIST_ENTRY32);
  848. {$EXTERNALSYM ListEntry64To32}
  850. //
  851. // These macros are used to walk lists on a target system
  852. //
  854. {
  855. #define CONTAINING_RECORD32(address, type, field) ( 
  856.                                                   (ULONG_PTR)(address) - 
  857.                                                   (ULONG_PTR)(&((type *)0)->field))
  859. #define CONTAINING_RECORD64(address, type, field) ( 
  860.                                                   (ULONGLONG)(address) - 
  861.                                                   (ULONGLONG)(&((type *)0)->field))
  862. }
  864. type
  865.   PString32 = ^STRING32;
  866.   _STRING32 = record
  867.     Length: USHORT;
  868.     MaximumLength: USHORT;
  869.     Buffer: ULONG;
  870.   end;
  871.   {$EXTERNALSYM _STRING32}
  872.   STRING32 = _STRING32;
  873.   {$EXTERNALSYM STRING32}
  874.   TString32 = STRING32;
  876.   UNICODE_STRING32 = STRING32;
  877.   {$EXTERNALSYM UNICODE_STRING32}
  878.   PUNICODE_STRING32 = ^UNICODE_STRING32;
  879.   {$EXTERNALSYM PUNICODE_STRING32}
  881.   ANSI_STRING32 = STRING32;
  882.   {$EXTERNALSYM ANSI_STRING32}
  883.   PANSI_STRING32 = ^ANSI_STRING32;
  884.   {$EXTERNALSYM PANSI_STRING32}
  886.   PString64 = ^STRING64;
  887.   _STRING64 = record
  888.     Length: USHORT;
  889.     MaximumLength: USHORT;
  890.     Buffer: ULONGLONG;
  891.   end;
  892.   {$EXTERNALSYM _STRING64}
  893.   STRING64 = _STRING64;
  894.   {$EXTERNALSYM STRING64}
  895.   TString64 = STRING64;
  897.   UNICODE_STRING64 = STRING64;
  898.   {$EXTERNALSYM UNICODE_STRING64}
  899.   PUNICODE_STRING64 = ^UNICODE_STRING64;
  900.   {$EXTERNALSYM PUNICODE_STRING64}
  902.   ANSI_STRING64 = STRING64;
  903.   {$EXTERNALSYM ANSI_STRING64}
  904.   PANSI_STRING64 = ^ANSI_STRING64;
  905.   {$EXTERNALSYM PANSI_STRING64}
  907. //
  908. // Valid values for the Attributes field
  909. //
  911. const
  912.   OBJ_INHERIT          = $00000002;
  913.   {$EXTERNALSYM OBJ_INHERIT}
  914.   OBJ_PERMANENT        = $00000010;
  915.   {$EXTERNALSYM OBJ_PERMANENT}
  916.   OBJ_EXCLUSIVE        = $00000020;
  917.   {$EXTERNALSYM OBJ_EXCLUSIVE}
  918.   OBJ_CASE_INSENSITIVE = $00000040;
  919.   {$EXTERNALSYM OBJ_CASE_INSENSITIVE}
  920.   OBJ_OPENIF           = $00000080;
  921.   {$EXTERNALSYM OBJ_OPENIF}
  922.   OBJ_OPENLINK         = $00000100;
  923.   {$EXTERNALSYM OBJ_OPENLINK}
  924.   OBJ_KERNEL_HANDLE    = $00000200;
  925.   {$EXTERNALSYM OBJ_KERNEL_HANDLE}
  926.   OBJ_VALID_ATTRIBUTES = $000003F2;
  927.   {$EXTERNALSYM OBJ_VALID_ATTRIBUTES}
  929. //
  930. // Object Attributes structure
  931. //
  933. type
  934.   POBJECT_ATTRIBUTES = ^OBJECT_ATTRIBUTES;
  935.   {$EXTERNALSYM POBJECT_ATTRIBUTES}
  936.   _OBJECT_ATTRIBUTES = record
  937.     Length: ULONG;
  938.     RootDirectory: HANDLE;
  939.     ObjectName: PUNICODE_STRING;
  940.     Attributes: ULONG;
  941.     SecurityDescriptor: PVOID;       // Points to type SECURITY_DESCRIPTOR
  942.     SecurityQualityOfService: PVOID; // Points to type SECURITY_QUALITY_OF_SERVICE
  943.   end;
  944.   {$EXTERNALSYM _OBJECT_ATTRIBUTES}
  945.   OBJECT_ATTRIBUTES = _OBJECT_ATTRIBUTES;
  946.   {$EXTERNALSYM OBJECT_ATTRIBUTES}
  947.   TObjectAttributes = OBJECT_ATTRIBUTES;
  948.   PObjectAttributes = POBJECT_ATTRIBUTES;
  950. procedure InitializeObjectAttributes(p: POBJECT_ATTRIBUTES; n: PUNICODE_STRING;
  951.   a: ULONG; r: HANDLE; s: PVOID{PSECURITY_DESCRIPTOR});
  952. {$EXTERNALSYM InitializeObjectAttributes}
  954. //
  955. // Constants
  956. //
  958. const
  960. //#define FALSE   0
  961. //#define TRUE    1
  963.   NULL   = 0;
  964.   {$EXTERNALSYM NULL}
  965.   NULL64 = 0;
  966.   {$EXTERNALSYM NULL64}
  968. //#include <guiddef.h>
  970. type
  971.   PObjectId = ^OBJECTID;
  972.   _OBJECTID = record  // size is 20
  973.     Lineage: GUID;
  974.     Uniquifier: ULONG;
  975.   end;
  976.   {$EXTERNALSYM _OBJECTID}
  977.   OBJECTID = _OBJECTID;
  978.   {$EXTERNALSYM OBJECTID}
  979.   TObjectId = OBJECTID;
  981. const
  982.   MINCHAR   = $80;
  983.   {$EXTERNALSYM MINCHAR}
  984.   MAXCHAR   = $7f;
  985.   {$EXTERNALSYM MAXCHAR}
  986.   MINSHORT  = $8000;
  987.   {$EXTERNALSYM MINSHORT}
  988.   MAXSHORT  = $7fff;
  989.   {$EXTERNALSYM MAXSHORT}
  990.   MINLONG   = DWORD($80000000);
  991.   {$EXTERNALSYM MINLONG}
  992.   MAXLONG   = $7fffffff;
  993.   {$EXTERNALSYM MAXLONG}
  994.   MAXUCHAR  = $ff;
  995.   {$EXTERNALSYM MAXUCHAR}
  996.   MAXUSHORT = $ffff;
  997.   {$EXTERNALSYM MAXUSHORT}
  998.   MAXULONG  = DWORD($ffffffff);
  999.   {$EXTERNALSYM MAXULONG}
  1001. //
  1002. // Useful Helper Macros
  1003. //
  1005. //
  1006. // Determine if an argument is present by testing the value of the pointer
  1007. // to the argument value.
  1008. //
  1010. function ARGUMENT_PRESENT(ArgumentPointer: Pointer): BOOL;
  1011. {$EXTERNALSYM ARGUMENT_PRESENT}
  1013. //
  1014. // Exception handler routine definition.
  1015. //
  1017. // struct _CONTEXT;
  1018. // struct _EXCEPTION_RECORD;
  1020. //type
  1021. //  PEXCEPTION_ROUTINE = function (ExceptionRecord: LP_EXCEPTION_RECORD;
  1022. //    EstablisherFrame: PVOID; ContextRecord: LPCONTEXT;
  1023. //    DispatcherContext: PVOID): EXCEPTION_DISPOSITION; stdcall;
  1024. //  {$EXTERNALSYM PEXCEPTION_ROUTINE}
  1026. //
  1027. // Interrupt Request Level (IRQL)
  1028. //
  1030. type
  1031.   KIRQL = UCHAR;
  1032.   {$EXTERNALSYM KIRQL}
  1033.   PKIRQL = ^KIRQL;
  1034.   {$EXTERNALSYM PKIRQL}
  1036. //
  1037. // Product types
  1038. //
  1040.   _NT_PRODUCT_TYPE = (Filler0, NtProductWinNt, NtProductLanManNt, NtProductServer);
  1041.   {$EXTERNALSYM _NT_PRODUCT_TYPE}
  1042.   NT_PRODUCT_TYPE = _NT_PRODUCT_TYPE;
  1043.   {$EXTERNALSYM NT_PRODUCT_TYPE}
  1044.   PNT_PRODUCT_TYPE = ^NT_PRODUCT_TYPE;
  1045.   TNtProductType = _NT_PRODUCT_TYPE;
  1047. //
  1048. // the bit mask, SharedUserData->SuiteMask, is a ULONG
  1049. // so there can be a maximum of 32 entries
  1050. // in this enum.
  1051. //
  1053. type
  1054.   _SUITE_TYPE = (
  1055.     SmallBusiness,
  1056.     Enterprise,
  1057.     BackOffice,
  1058.     CommunicationServer,
  1059.     TerminalServer,
  1060.     SmallBusinessRestricted,
  1061.     EmbeddedNT,
  1062.     DataCenter,
  1063.     SingleUserTS,
  1064.     MaxSuiteType);
  1065.   {$EXTERNALSYM _SUITE_TYPE}
  1066.   SUITE_TYPE = _SUITE_TYPE;
  1067.   {$EXTERNALSYM SUITE_TYPE}
  1068.   TSuiteType = SUITE_TYPE;
  1070. const
  1071.   VER_SERVER_NT                      = DWORD($80000000);
  1072.   {$EXTERNALSYM VER_SERVER_NT}
  1073.   VER_WORKSTATION_NT                 = $40000000;
  1074.   {$EXTERNALSYM VER_WORKSTATION_NT}
  1075.   VER_SUITE_SMALLBUSINESS            = $00000001;
  1076.   {$EXTERNALSYM VER_SUITE_SMALLBUSINESS}
  1077.   VER_SUITE_ENTERPRISE               = $00000002;
  1078.   {$EXTERNALSYM VER_SUITE_ENTERPRISE}
  1079.   VER_SUITE_BACKOFFICE               = $00000004;
  1080.   {$EXTERNALSYM VER_SUITE_BACKOFFICE}
  1081.   VER_SUITE_COMMUNICATIONS           = $00000008;
  1082.   {$EXTERNALSYM VER_SUITE_COMMUNICATIONS}
  1083.   VER_SUITE_TERMINAL                 = $00000010;
  1084.   {$EXTERNALSYM VER_SUITE_TERMINAL}
  1085.   VER_SUITE_SMALLBUSINESS_RESTRICTED = $00000020;
  1086.   {$EXTERNALSYM VER_SUITE_SMALLBUSINESS_RESTRICTED}
  1087.   VER_SUITE_EMBEDDEDNT               = $00000040;
  1088.   {$EXTERNALSYM VER_SUITE_EMBEDDEDNT}
  1089.   VER_SUITE_DATACENTER               = $00000080;
  1090.   {$EXTERNALSYM VER_SUITE_DATACENTER}
  1091.   VER_SUITE_SINGLEUSERTS             = $00000100;
  1092.   {$EXTERNALSYM VER_SUITE_SINGLEUSERTS}
  1093.   VER_SUITE_PERSONAL                 = $00000200;
  1094.   {$EXTERNALSYM VER_SUITE_PERSONAL}
  1095.   VER_SUITE_BLADE                    = $00000400;
  1096.   {$EXTERNALSYM VER_SUITE_BLADE}
  1098. // ntdef.h
  1100. type
  1101.   error_status_t = Longword;
  1102.   {$EXTERNALSYM error_status_t}
  1103.   wchar_t = Word;
  1104.   {$EXTERNALSYM wchar_t}
  1106. //
  1107. // The following types are guaranteed to be signed and 32 bits wide.
  1108. //
  1110. type
  1111.   INT_PTR = Integer;
  1112.   {$EXTERNALSYM INT_PTR}
  1113.   PINT_PTR = ^INT_PTR;
  1114.   {$EXTERNALSYM PINT_PTR}
  1115.   UINT_PTR = Longword;
  1116.   {$EXTERNALSYM UINT_PTR}
  1117.   PUINT_PTR = ^UINT_PTR;
  1118.   {$EXTERNALSYM PUINT_PTR}
  1119.   LONG_PTR = Longint;
  1120.   {$EXTERNALSYM LONG_PTR}
  1121.   PLONG_PTR = ^LONG_PTR;
  1122.   {$EXTERNALSYM PLONG_PTR}
  1123.   ULONG_PTR = Longword;
  1124.   {$EXTERNALSYM ULONG_PTR}
  1125.   PULONG_PTR = ^PULONG_PTR;
  1126.   {$EXTERNALSYM PULONG_PTR}
  1128.   LONG32 = Integer;
  1129.   {$EXTERNALSYM LONG32}
  1130.   PLONG32 = ^LONG32;
  1131.   {$EXTERNALSYM PLONG32}
  1132.   INT32 = Integer;
  1133.   {$EXTERNALSYM INT32}
  1134.   PINT32 = ^INT32;
  1135.   {$EXTERNALSYM PINT32}
  1137. //
  1138. // The following types are guaranteed to be unsigned and 32 bits wide.
  1139. //
  1141.   ULONG32 = Longword;
  1142.   {$EXTERNALSYM ULONG32}
  1143.   PULONG32 = ^ULONG32;
  1144.   {$EXTERNALSYM PULONG32}
  1145.   DWORD32 = Longword;
  1146.   {$EXTERNALSYM DWORD32}
  1147.   PDWORD32 = ^DWORD32;
  1148.   {$EXTERNALSYM PDWORD32}
  1149.   UINT32 = Longword;
  1150.   {$EXTERNALSYM UINT32}
  1151.   PUINT32 = ^UINT32;
  1152.   {$EXTERNALSYM PUINT32}
  1154. const
  1155.   MAX_PATH = 260;
  1156.   {$EXTERNALSYM MAX_PATH}
  1158. type
  1160. //unsigned char       BYTE;
  1161. //unsigned short      WORD;
  1163.   FLOAT = Single;
  1164.   {$EXTERNALSYM FLOAT}
  1165.   PFLOAT = ^FLOAT;
  1166.   {$EXTERNALSYM PFLOAT}
  1167.   PBOOL = {$IFDEF USE_DELPHI_TYPES}Windows.PBOOL{$ELSE}^BOOL{$ENDIF};
  1168.   {$EXTERNALSYM PBOOL}
  1169.   LPBOOL = {$IFDEF USE_DELPHI_TYPES}Windows.PBOOL{$ELSE}^BOOL{$ENDIF};
  1170.   {$EXTERNALSYM LPBOOL}
  1171.   PBYTE = {$IFDEF USE_DELPHI_TYPES}Windows.PBYTE{$ELSE}^BYTE{$ENDIF};
  1172.   {$EXTERNALSYM PBYTE}
  1173.   LPBYTE = {$IFDEF USE_DELPHI_TYPES}Windows.PBYTE{$ELSE}^BYTE{$ENDIF};
  1174.   {$EXTERNALSYM LPBYTE}
  1175.   PINT = {$IFDEF USE_DELPHI_TYPES}Windows.PINT{$ELSE}^INT{$ENDIF};
  1176.   {$EXTERNALSYM PINT}
  1177.   PUINT = {$IFDEF USE_DELPHI_TYPES}Windows.PUINT{$ELSE}^UINT{$ENDIF};
  1178.   {$EXTERNALSYM PUINT}
  1179.   LPUINT = {$IFDEF USE_DELPHI_TYPES}Windows.PUINT{$ELSE}^UINT{$ENDIF};
  1180.   {$EXTERNALSYM LPUINT}
  1181.   LPINT = {$IFDEF USE_DELPHI_TYPES}Windows.PINT{$ELSE}^INT{$ENDIF};
  1182.   {$EXTERNALSYM LPINT}
  1183.   PWORD = {$IFDEF USE_DELPHI_TYPES}Windows.PWORD{$ELSE}^WORD{$ENDIF};
  1184.   {$EXTERNALSYM PWORD}
  1185.   LPWORD = {$IFDEF USE_DELPHI_TYPES}Windows.PWORD{$ELSE}^WORD{$ENDIF};
  1186.   {$EXTERNALSYM LPWORD}
  1187.   LPLONG = ^LONG;
  1188.   {$EXTERNALSYM LPLONG}
  1189.   PDWORD = {$IFDEF USE_DELPHI_TYPES}Windows.PDWORD{$ELSE}^DWORD{$ENDIF};
  1190.   {$EXTERNALSYM PDWORD}
  1191.   LPDWORD = {$IFDEF USE_DELPHI_TYPES}Windows.LPDWORD{$ELSE}^DWORD{$ENDIF};
  1192.   {$EXTERNALSYM LPDWORD}
  1193.   LPVOID = Pointer;
  1194.   {$EXTERNALSYM LPVOID}
  1195.   LPCVOID = Pointer;
  1196.   {$EXTERNALSYM LPCVOID}
  1197.   LPLPVOID = ^LPVOID;
  1198.   {$NODEFINE LPVOID}
  1200.   INT = Integer;
  1201.   {$EXTERNALSYM INT}
  1202.   UINT = {$IFDEF USE_DELPHI_TYPES}Windows.UINT{$ELSE}Longword{$ENDIF};
  1203.   {$EXTERNALSYM UINT}
  1205. // Types use for passing & returning polymorphic values
  1207.   WPARAM = {$IFDEF USE_DELPHI_TYPES}Windows.WPARAM{$ELSE}UINT_PTR{$ENDIF};
  1208.   {$EXTERNALSYM WPARAM}
  1209.   LPARAM = {$IFDEF USE_DELPHI_TYPES}Windows.LPARAM{$ELSE}LONG_PTR{$ENDIF};
  1210.   {$EXTERNALSYM LPARAM}
  1211.   LRESULT = {$IFDEF USE_DELPHI_TYPES}Windows.LRESULT{$ELSE}LONG_PTR{$ENDIF};
  1212.   {$EXTERNALSYM LRESULT}
  1214. function MAKEWORD(a, b: BYTE): WORD;
  1215. {$EXTERNALSYM MAKEWORD}
  1216. function MAKELONG(a, b: WORD): DWORD;
  1217. {$EXTERNALSYM MAKELONG}
  1219. function LOWORD(L: DWORD): WORD;
  1220. {$EXTERNALSYM LOWORD}
  1221. function HIWORD(L: DWORD): WORD;
  1222. {$EXTERNALSYM HIWORD}
  1223. function LOBYTE(W: WORD): BYTE;
  1224. {$EXTERNALSYM LOBYTE}
  1225. function HIBYTE(W: WORD): BYTE;
  1226. {$EXTERNALSYM HIBYTE}
  1228. type
  1229.   HWND = {$IFDEF USE_DELPHI_TYPES}Windows.HWND{$ELSE}HANDLE{$ENDIF};
  1230.   {$EXTERNALSYM HWND}
  1231.   LPHWND = ^HWND;
  1232.   {$EXTERNALSYM LPHWND}
  1233.   HHOOK = {$IFDEF USE_DELPHI_TYPES}Windows.HHOOK{$ELSE}HANDLE{$ENDIF};
  1234.   {$EXTERNALSYM HHOOK}
  1235.   LPHHOOK = ^HHOOK;
  1236.   {$EXTERNALSYM LPHHOOK}
  1237.   HEVENT = HANDLE;
  1238.   {$EXTERNALSYM HEVENT}
  1240.   ATOM = {$IFDEF USE_DELPHI_TYPES}Windows.ATOM{$ELSE}WORD{$ENDIF};
  1241.   {$EXTERNALSYM ATOM}
  1243.   SPHANDLE = ^HANDLE;
  1244.   {$EXTERNALSYM SPHANDLE}
  1245.   LPHANDLE = ^HANDLE;
  1246.   {$EXTERNALSYM LPHANDLE}
  1247.   HGLOBAL = {$IFDEF USE_DELPHI_TYPES}Windows.HGLOBAL{$ELSE}HANDLE{$ENDIF};
  1248.   {$EXTERNALSYM HGLOBAL}
  1249.   HLOCAL = {$IFDEF USE_DELPHI_TYPES}Windows.HLOCAL{$ELSE}HANDLE{$ENDIF};
  1250.   {$EXTERNALSYM HLOCAL}
  1251.   GLOBALHANDLE = HANDLE;
  1252.   {$EXTERNALSYM GLOBALHANDLE}
  1253.   //LOCALHANDLE = HANDLE; // todo clashes with WinBase.LocalHandle function
  1254.   //{$EXTERNALSYM LOCALHANDLE}
  1255.   FARPROC = {$IFDEF USE_DELPHI_TYPES}Windows.FARPROC{$ELSE}function: Integer{$ENDIF};
  1256.   {$EXTERNALSYM FARPROC}
  1257.   NEARPROC = function: Integer; stdcall;
  1258.   {$EXTERNALSYM NEARPROC}
  1259.   PROC = function: Integer; stdcall;
  1260.   {$EXTERNALSYM PROC}
  1262.   HGDIOBJ = {$IFDEF USE_DELPHI_TYPES}Windows.HGDIOBJ{$ELSE}HANDLE{$ENDIF};
  1263.   {$EXTERNALSYM HGDIOBJ}
  1265.   HKEY = {$IFDEF USE_DELPHI_TYPES}Windows.HKEY{$ELSE}HANDLE{$ENDIF};
  1266.   {$EXTERNALSYM HKEY}
  1267.   PHKEY = {$IFDEF USE_DELPHI_TYPES}Windows.PHKEY{$ELSE}^HKEY{$ENDIF};
  1268.   {$EXTERNALSYM PHKEY}
  1270.   HACCEL = {$IFDEF USE_DELPHI_TYPES}Windows.HACCEL{$ELSE}HANDLE{$ENDIF};
  1271.   {$EXTERNALSYM HACCEL}
  1273.   HBITMAP = {$IFDEF USE_DELPHI_TYPES}Windows.HBITMAP{$ELSE}HANDLE{$ENDIF};
  1274.   {$EXTERNALSYM HBITMAP}
  1275.   HBRUSH = {$IFDEF USE_DELPHI_TYPES}Windows.HBRUSH{$ELSE}HANDLE{$ENDIF};
  1276.   {$EXTERNALSYM HBRUSH}
  1278.   HCOLORSPACE = {$IFDEF USE_DELPHI_TYPES}Windows.HCOLORSPACE{$ELSE}HANDLE{$ENDIF};
  1279.   {$EXTERNALSYM HCOLORSPACE}
  1281.   HDC = {$IFDEF USE_DELPHI_TYPES}Windows.HDC{$ELSE}HANDLE{$ENDIF};
  1282.   {$EXTERNALSYM HDC}
  1283.   HGLRC = {$IFDEF USE_DELPHI_TYPES}Windows.HGLRC{$ELSE}HANDLE{$ENDIF};
  1284.   {$EXTERNALSYM HGLRC}
  1285.   HDESK = {$IFDEF USE_DELPHI_TYPES}Windows.HDESK{$ELSE}HANDLE{$ENDIF};
  1286.   {$EXTERNALSYM HDESK}
  1287.   HENHMETAFILE = {$IFDEF USE_DELPHI_TYPES}Windows.HENHMETAFILE{$ELSE}HANDLE{$ENDIF};
  1288.   {$EXTERNALSYM HENHMETAFILE}
  1289.   HFONT = {$IFDEF USE_DELPHI_TYPES}Windows.HFONT{$ELSE}HANDLE{$ENDIF};
  1290.   {$EXTERNALSYM HFONT}
  1291.   HICON = {$IFDEF USE_DELPHI_TYPES}Windows.HICON{$ELSE}HANDLE{$ENDIF};
  1292.   {$EXTERNALSYM HICON}
  1293.   HMENU = {$IFDEF USE_DELPHI_TYPES}Windows.HMENU{$ELSE}HANDLE{$ENDIF};
  1294.   {$EXTERNALSYM HMENU}
  1295.   HMETAFILE = {$IFDEF USE_DELPHI_TYPES}Windows.HMETAFILE{$ELSE}HANDLE{$ENDIF};
  1296.   {$EXTERNALSYM HMETAFILE}
  1297.   HINSTANCE = {$IFDEF USE_DELPHI_TYPES}Windows.HINST{$ELSE}HANDLE{$ENDIF};
  1298.   {$EXTERNALSYM HINSTANCE}
  1299.   HMODULE = {$IFDEF USE_DELPHI_TYPES}Windows.HMODULE{$ELSE}HINSTANCE{$ENDIF};
  1300.   {$EXTERNALSYM HMODULE}
  1301.   HPALETTE = {$IFDEF USE_DELPHI_TYPES}Windows.HPALETTE{$ELSE}HANDLE{$ENDIF};
  1302.   {$EXTERNALSYM HPALETTE}
  1303.   HPEN = {$IFDEF USE_DELPHI_TYPES}Windows.HPEN{$ELSE}HANDLE{$ENDIF};
  1304.   {$EXTERNALSYM HPEN}
  1305.   HRGN = {$IFDEF USE_DELPHI_TYPES}Windows.HRGN{$ELSE}HANDLE{$ENDIF};
  1306.   {$EXTERNALSYM HRGN}
  1307.   HRSRC = {$IFDEF USE_DELPHI_TYPES}Windows.HRSRC{$ELSE}HANDLE{$ENDIF};
  1308.   {$EXTERNALSYM HRSRC}
  1309.   HSTR = {$IFDEF USE_DELPHI_TYPES}Windows.HSTR{$ELSE}HANDLE{$ENDIF};
  1310.   {$EXTERNALSYM HSTR}
  1311.   HTASK = {$IFDEF USE_DELPHI_TYPES}Windows.HTASK{$ELSE}HANDLE{$ENDIF};
  1312.   {$EXTERNALSYM HTASK}
  1313.   HWINSTA = {$IFDEF USE_DELPHI_TYPES}Windows.HWINSTA{$ELSE}HANDLE{$ENDIF};
  1314.   {$EXTERNALSYM HWINSTA}
  1315.   HKL = {$IFDEF USE_DELPHI_TYPES}Windows.HKL{$ELSE}HANDLE{$ENDIF};
  1316.   {$EXTERNALSYM HKL}
  1317.   PHKL = {$IFDEF USE_DELPHI_TYPES}^HKL{$ELSE}^HANDLE{$ENDIF};
  1318.   {$EXTERNALSYM PHKL}
  1320.   HMONITOR = HANDLE;
  1321.   {$EXTERNALSYM HMONITOR}
  1322.   HWINEVENTHOOK = HANDLE;
  1323.   {$EXTERNALSYM HWINEVENTHOOK}
  1324.   HUMPD = HANDLE;
  1325.   {$EXTERNALSYM HUMPD}  
  1327.   HFILE = {$IFDEF USE_DELPHI_TYPES}Windows.HFILE{$ELSE}Integer{$ENDIF};
  1328.   {$EXTERNALSYM HFILE}
  1329.   HCURSOR = {$IFDEF USE_DELPHI_TYPES}Windows.HCURSOR{$ELSE}HICON{$ENDIF};
  1330.   {$EXTERNALSYM HCURSOR}
  1332.   COLORREF = {$IFDEF USE_DELPHI_TYPES}Windows.COLORREF{$ELSE}DWORD{$ENDIF};
  1333.   {$EXTERNALSYM COLORREF}
  1334.   LPCOLORREF = ^COLORREF;
  1335.   {$EXTERNALSYM LPCOLORREF}
  1337.   PHMODULE = ^HMODULE;
  1338.   {$NODEFINE PHMODULE}
  1340. const
  1341.   HFILE_ERROR = HFILE(-1);
  1342.   {$EXTERNALSYM HFILE_ERROR}
  1344. type
  1345.   LPRECT = ^RECT;
  1346.   {$EXTERNALSYM LPRECT}
  1347.   tagRECT = record
  1348.     left: LONG;
  1349.     top: LONG;
  1350.     right: LONG;
  1351.     bottom: LONG;
  1352.   end;
  1353.   {$EXTERNALSYM tagRECT}
  1354.   RECT = {$IFDEF USE_DELPHI_TYPES}Windows.TRect{$ELSE}tagRECT{$ENDIF};
  1355.   {$EXTERNALSYM RECT}
  1356.   NPRECT = ^RECT;
  1357.   {$EXTERNALSYM NPRECT}
  1358.   LPCRECT = ^RECT;
  1359.   {$EXTERNALSYM LPCRECT}
  1360.   TRect = {$IFDEF USE_DELPHI_TYPES}Windows.TRect{$ELSE}RECT{$ENDIF};
  1361.   PRect = {$IFDEF USE_DELPHI_TYPES}Windows.PRect{$ELSE}LPRECT{$ENDIF};
  1363.   LPRECTL = ^RECTL;
  1364.   {$EXTERNALSYM LPRECTL}
  1365.   _RECTL = record
  1366.     left: LONG;
  1367.     top: LONG;
  1368.     right: LONG;
  1369.     bottom: LONG;
  1370.   end;
  1371.   {$EXTERNALSYM _RECTL}
  1372.   RECTL = _RECTL;
  1373.   {$EXTERNALSYM RECTL}
  1374.   LPCRECTL = ^_RECTL;
  1375.   {$EXTERNALSYM LPCRECTL}
  1376.   TRectl = RECTL;
  1377.   PRectl = LPRECTL;
  1379.   LPPOINT = ^POINT;
  1380.   {$EXTERNALSYM LPPOINT}
  1381.   tagPOINT = record
  1382.     x: LONG;
  1383.     y: LONG;
  1384.   end;
  1385.   {$EXTERNALSYM tagPOINT}
  1386.   NPPOINT = ^tagPoint;
  1387.   {$EXTERNALSYM NPPOINT}
  1388.   POINT = tagPOINT;
  1389.   {$EXTERNALSYM tagPOINT}
  1390.   TPoint = {$IFDEF USE_DELPHI_TYPES}Windows.TPoint{$ELSE}POINT{$ENDIF};
  1391.   PPoint = {$IFDEF USE_DELPHI_TYPES}Windows.PPoint{$ELSE}LPPOINT{$ENDIF};
  1393.   PPointl = ^POINTL;
  1394.   _POINTL = record
  1395.     x: LONG;
  1396.     y: LONG;
  1397.   end;
  1398.   {$EXTERNALSYM _POINTL}
  1399.   POINTL = _POINTL;
  1400.   {$EXTERNALSYM POINTL}
  1401.   TPointl = POINTL;
  1403.   LPSIZE = ^TSize;
  1404.   {$EXTERNALSYM LPSIZE}
  1406. {$IFDEF USE_DELPHI_TYPES}
  1407.   TSize = Windows.TSize;
  1408.   PSize = Windows.PSize;
  1409. {$ELSE}
  1410.   tagSIZE = record
  1411.     cx: LONG;
  1412.     cy: LONG;
  1413.   end;
  1414.   {$EXTERNALSYM tagSIZE}
  1415.   TSize = tagSIZE;
  1416.   PSize = LPSIZE;
  1417. {$ENDIF}
  1419.   SIZE = TSize;
  1420.   {$EXTERNALSYM SIZE}
  1421.   SIZEL = TSize;
  1422.   {$EXTERNALSYM SIZEL}
  1423.   PSIZEL = PSize;
  1424.   {$EXTERNALSYM PSIZEL}
  1425.   LPSIZEL = PSize;
  1426.   {$EXTERNALSYM LPSIZEL}
  1428.   LPPOINTS = ^POINTS;
  1429.   {$EXTERNALSYM LPPOINTS}
  1430.   tagPOINTS = record
  1431.     x: SHORT;
  1432.     y: SHORT;
  1433.   end;
  1434.   {$EXTERNALSYM tagPOINTS}
  1435.   POINTS = tagPOINTS;
  1436.   {$EXTERNALSYM POINTS}
  1437.   TPoints = POINTS;
  1438.   PPoints = LPPOINTS;
  1440. //
  1441. //  File System time stamps are represented with the following structure:
  1442. //
  1444.   {$IFNDEF _FILETIME_}
  1445.   {$DEFINE _FILETIME_}
  1446.   _FILETIME = record
  1447.     dwLowDateTime: DWORD;
  1448.     dwHighDateTime: DWORD;
  1449.   end;
  1450.   {$EXTERNALSYM _FILETIME}
  1451.   FILETIME = _FILETIME;
  1452.   {$EXTERNALSYM FILETIME}
  1453.   PFILETIME = ^FILETIME;
  1454.   {$EXTERNALSYM PFILETIME}
  1455.   LPFILETIME = PFILETIME;
  1456.   {$EXTERNALSYM LPFILETIME}
  1457.   TFileTime = FILETIME;
  1458.   {$ENDIF}
  1460. // mode selections for the device mode function
  1462. const
  1463.   DM_UPDATE = 1;
  1464.   {$EXTERNALSYM DM_UPDATE}
  1465.   DM_COPY   = 2;
  1466.   {$EXTERNALSYM DM_COPY}
  1467.   DM_PROMPT = 4;
  1468.   {$EXTERNALSYM DM_PROMPT}
  1469.   DM_MODIFY = 8;
  1470.   {$EXTERNALSYM DM_MODIFY}
  1472.   DM_IN_BUFFER   = DM_MODIFY;
  1473.   {$EXTERNALSYM DM_IN_BUFFER}
  1474.   DM_IN_PROMPT   = DM_PROMPT;
  1475.   {$EXTERNALSYM DM_IN_PROMPT}
  1476.   DM_OUT_BUFFER  = DM_COPY;
  1477.   {$EXTERNALSYM DM_OUT_BUFFER}
  1478.   DM_OUT_DEFAULT = DM_UPDATE;
  1479.   {$EXTERNALSYM DM_OUT_DEFAULT}
  1481. // device capabilities indices
  1483.   DC_FIELDS           = 1;
  1484.   {$EXTERNALSYM DC_FIELDS}
  1485.   DC_PAPERS           = 2;
  1486.   {$EXTERNALSYM DC_PAPERS}
  1487.   DC_PAPERSIZE        = 3;
  1488.   {$EXTERNALSYM DC_PAPERSIZE}
  1489.   DC_MINEXTENT        = 4;
  1490.   {$EXTERNALSYM DC_MINEXTENT}
  1491.   DC_MAXEXTENT        = 5;
  1492.   {$EXTERNALSYM DC_MAXEXTENT}
  1493.   DC_BINS             = 6;
  1494.   {$EXTERNALSYM DC_BINS}
  1495.   DC_DUPLEX           = 7;
  1496.   {$EXTERNALSYM DC_DUPLEX}
  1497.   DC_SIZE             = 8;
  1498.   {$EXTERNALSYM DC_SIZE}
  1499.   DC_EXTRA            = 9;
  1500.   {$EXTERNALSYM DC_EXTRA}
  1501.   DC_VERSION          = 10;
  1502.   {$EXTERNALSYM DC_VERSION}
  1503.   DC_DRIVER           = 11;
  1504.   {$EXTERNALSYM DC_DRIVER}
  1505.   DC_BINNAMES         = 12;
  1506.   {$EXTERNALSYM DC_BINNAMES}
  1507.   DC_ENUMRESOLUTIONS  = 13;
  1508.   {$EXTERNALSYM DC_ENUMRESOLUTIONS}
  1509.   DC_FILEDEPENDENCIES = 14;
  1510.   {$EXTERNALSYM DC_FILEDEPENDENCIES}
  1511.   DC_TRUETYPE         = 15;
  1512.   {$EXTERNALSYM DC_TRUETYPE}
  1513.   DC_PAPERNAMES       = 16;
  1514.   {$EXTERNALSYM DC_PAPERNAMES}
  1515.   DC_ORIENTATION      = 17;
  1516.   {$EXTERNALSYM DC_ORIENTATION}
  1517.   DC_COPIES           = 18;
  1518.   {$EXTERNALSYM DC_COPIES}
  1520. //
  1521. // HALF_PTR is half the size of a pointer it intended for use with
  1522. // within strcuture which contain a pointer and two small fields.
  1523. // UHALF_PTR is the unsigned variation.
  1524. //
  1526. const
  1527.   ADDRESS_TAG_BIT = DWORD($80000000);
  1528.   {$EXTERNALSYM ADDRESS_TAG_BIT}
  1530. type
  1531.   UHALF_PTR = Byte;
  1532.   {$EXTERNALSYM UHALF_PTR}
  1533.   PUHALF_PTR = ^UHALF_PTR;
  1534.   {$EXTERNALSYM PUHALF_PTR}
  1535.   HALF_PTR = Shortint;
  1536.   {$EXTERNALSYM HALF_PTR}
  1537.   PHALF_PTR = ^HALF_PTR;
  1538.   {$EXTERNALSYM PHALF_PTR}
  1540.   SHANDLE_PTR = Longint;
  1541.   {$EXTERNALSYM SHANDLE_PTR}
  1542.   HANDLE_PTR = Longint;
  1543.   {$EXTERNALSYM HANDLE_PTR}
  1545. //
  1546. // SIZE_T used for counts or ranges which need to span the range of
  1547. // of a pointer.  SSIZE_T is the signed variation.
  1548. //
  1550.   SIZE_T = ULONG_PTR;
  1551.   {$EXTERNALSYM SIZE_T}
  1552.   PSIZE_T = ^SIZE_T;
  1553.   {$EXTERNALSYM PSIZE_T}
  1554.   SSIZE_T = LONG_PTR;
  1555.   {$EXTERNALSYM SSIZE_T}
  1556.   PSSIZE_T = ^SSIZE_T;
  1557.   {$EXTERNALSYM PSSIZE_T}
  1559. //
  1560. // Add Windows flavor DWORD_PTR types
  1561. //
  1563.   DWORD_PTR = ULONG_PTR;
  1564.   {$EXTERNALSYM DWORD_PTR}
  1565.   PDWORD_PTR = ^DWORD_PTR;
  1566.   {$EXTERNALSYM PDWORD_PTR}
  1568. //
  1569. // The following types are guaranteed to be signed and 64 bits wide.
  1570. //
  1572.   LONG64 = Int64;
  1573.   {$EXTERNALSYM LONG64}
  1574.   PLONG64 = ^LONG64;
  1575.   {$EXTERNALSYM PLONG64}
  1577.   PINT64 = ^Int64;
  1578.   {$EXTERNALSYM PINT64}
  1580. //
  1581. // The following types are guaranteed to be unsigned and 64 bits wide.
  1582. //
  1584.   ULONG64 = Int64;
  1585.   {$EXTERNALSYM ULONG64}
  1586.   PULONG64 = ^ULONG64;
  1587.   {$EXTERNALSYM PULONG64}
  1588.   DWORD64 = Int64;
  1589.   {$EXTERNALSYM DWORD64}
  1590.   PDWORD64 = ^DWORD64;
  1591.   {$EXTERNALSYM PDWORD64}
  1592.   UINT64 = Int64;
  1593.   {$EXTERNALSYM UINT64}
  1594.   PUINT64 = ^UINT64;
  1595.   {$EXTERNALSYM PUINT64}
  1597. const
  1598.   MAXUINT_PTR   = not UINT_PTR(0);
  1599.   {$EXTERNALSYM MAXUINT_PTR}
  1600.   MAXINT_PTR    = INT_PTR((MAXUINT_PTR shr 1));
  1601.   {$EXTERNALSYM MAXINT_PTR}
  1602.   MININT_PTR    = not MAXINT_PTR;
  1603.   {$EXTERNALSYM MININT_PTR}
  1605.   MAXULONG_PTR  = not ULONG_PTR(0);
  1606.   {$EXTERNALSYM MAXULONG_PTR}
  1607.   MAXLONG_PTR   = LONG_PTR(MAXULONG_PTR shr 1);
  1608.   {$EXTERNALSYM MAXLONG_PTR}
  1609.   MINLONG_PTR   = not MAXLONG_PTR;
  1610.   {$EXTERNALSYM MINLONG_PTR}
  1612.   MAXUHALF_PTR  = UHALF_PTR( not 0);
  1613.   {$EXTERNALSYM MAXUHALF_PTR}
  1614.   MAXHALF_PTR   = HALF_PTR(MAXUHALF_PTR shr 1);
  1615.   {$EXTERNALSYM MAXHALF_PTR}
  1616.   MINHALF_PTR   = not MAXHALF_PTR;
  1617.   {$EXTERNALSYM MINHALF_PTR}
  1619. // basetsd
  1621. type
  1622.   INT8 = Shortint;
  1623.   {$EXTERNALSYM INT8}
  1624.   PINT8 = ^INT8;
  1625.   {$EXTERNALSYM PINT8}
  1626.   INT16 = Smallint;
  1627.   {$EXTERNALSYM INT16}
  1628.   PINT16 = ^INT16;
  1629.   {$EXTERNALSYM PINT16}
  1630.   UINT8 = Byte;
  1631.   {$EXTERNALSYM UINT8}
  1632.   PUINT8 = ^UINT8;
  1633.   {$EXTERNALSYM PUINT8}
  1634.   UINT16 = Word;
  1635.   {$EXTERNALSYM UINT16}
  1636.   PUINT16 = ^UINT16;
  1637.   {$EXTERNALSYM PUINT16}
  1639. //
  1640. // Thread affinity.
  1641. //
  1643.   KAFFINITY = ULONG_PTR;
  1644.   {$EXTERNALSYM KAFFINITY}
  1645.   PKAFFINITY = ^KAFFINITY;
  1646.   {$EXTERNALSYM PKAFFINITY}
  1648. implementation
  1650. uses
  1651.   JwaWinNT;
  1653. function Int32x32To64(a, b: LONG): LONGLONG;
  1654. begin
  1655.   Result := a * b;
  1656. end;
  1658. function UInt32x32To64(a, b: DWORD): ULONGLONG;
  1659. begin
  1660.   Result := a * b;
  1661. end;
  1663. function Int64ShllMod32(Value: ULONGLONG; ShiftCount: DWORD): ULONGLONG;
  1664. asm
  1665.         MOV     ECX, ShiftCount
  1666.         MOV     EAX, DWORD PTR [Value]
  1667.         MOV     EDX, DWORD PTR [Value + 4]
  1668.         SHLD    EDX, EAX, CL
  1669.         SHL     EAX, CL
  1670. end;
  1672. function Int64ShraMod32(Value: LONGLONG; ShiftCount: DWORD): LONGLONG;
  1673. asm
  1674.         MOV     ECX, ShiftCount
  1675.         MOV     EAX, DWORD PTR [Value]
  1676.         MOV     EDX, DWORD PTR [Value + 4]
  1677.         SHRD    EAX, EDX, CL
  1678.         SAR     EDX, CL
  1679. end;
  1681. function Int64ShrlMod32(Value: ULONGLONG; ShiftCount: DWORD): ULONGLONG;
  1682. asm
  1683.         MOV     ECX, ShiftCount
  1684.         MOV     EAX, DWORD PTR [Value]
  1685.         MOV     EDX, DWORD PTR [Value + 4]
  1686.         SHRD    EAX, EDX, CL
  1687.         SHR     EDX, CL
  1688. end;
  1690. procedure ListEntry32To64(l32: PLIST_ENTRY32; l64: PLIST_ENTRY64);
  1691. begin
  1692.   l64^.Flink := l32^.Flink;
  1693.   l64^.Blink := l32^.Blink;
  1694. end;
  1696. procedure ListEntry64To32(l64: PLIST_ENTRY64; l32: PLIST_ENTRY32);
  1697. begin
  1698.   l32^.Flink := ULONG(l64^.Flink);
  1699.   l32^.Blink := ULONG(l64^.Blink);
  1700. end;
  1702. function NT_SUCCESS(Status: NTSTATUS): BOOL;
  1703. begin
  1704.   Result := Status >= 0;
  1705. end;
  1707. function NT_INFORMATION(Status: NTSTATUS): BOOL;
  1708. begin
  1709.   Result := (ULONG(Status) shr 30) = 1;
  1710. end;
  1712. function NT_WARNING(Status: NTSTATUS): BOOL;
  1713. begin
  1714.   Result := (ULONG(Status) shr 30) = 2;
  1715. end;
  1717. function NT_ERROR(Status: NTSTATUS): BOOL;
  1718. begin
  1719.   Result := (ULONG(Status) shr 30) = 3;
  1720. end;
  1722. procedure InitializeObjectAttributes(p: POBJECT_ATTRIBUTES; n: PUNICODE_STRING;
  1723.   a: ULONG; r: HANDLE; s: PVOID{PSECURITY_DESCRIPTOR});
  1724. begin
  1725.   p^.Length := sizeof(OBJECT_ATTRIBUTES);
  1726.   p^.RootDirectory := r;
  1727.   p^.Attributes := a;
  1728.   p^.ObjectName := n;
  1729.   p^.SecurityDescriptor := s;
  1730.   p^.SecurityQualityOfService := nil;
  1731. end;
  1733. function ARGUMENT_PRESENT(ArgumentPointer: Pointer): BOOL;
  1734. begin
  1735.   Result := ArgumentPointer <> nil;
  1736. end;
  1738. function MAKEWORD(a, b: BYTE): WORD;
  1739. begin
  1740.   Result := (b shl 8) or a;
  1741. end;
  1743. function MAKELONG(a, b: WORD): DWORD;
  1744. begin
  1745.   Result := (b shl 16) or a;
  1746. end;
  1748. function LOWORD(L: DWORD): WORD;
  1749. begin
  1750.   Result := L and $0000FFFF;
  1751. end;
  1753. function HIWORD(L: DWORD): WORD;
  1754. begin
  1755.   Result := L shr 16;
  1756. end;
  1758. function LOBYTE(W: WORD): BYTE;
  1759. begin
  1760.   Result := W and $FF;
  1761. end;
  1763. function HIBYTE(W: WORD): BYTE;
  1764. begin
  1765.   Result := W shr 8;
  1766. end;
  1768. function GetModuleHandle(lpModuleName: LPCSTR): HMODULE; stdcall; external kernel32 name 'GetModuleHandleA';
  1769. function LoadLibrary(lpLibFileName: LPCSTR): HMODULE; stdcall; external kernel32 name 'LoadLibraryA';
  1770. function GetProcAddress(hModule: HMODULE; lpProcName: LPCSTR): FARPROC; stdcall; external kernel32 name 'GetProcAddress';
  1772. procedure GetProcedureAddress(var P: Pointer; const ModuleName, ProcName: string);
  1773. var
  1774.   ModuleHandle: HMODULE;
  1775. begin
  1776.   if not Assigned(P) then
  1777.   begin
  1778.     ModuleHandle := GetModuleHandle(PChar(ModuleName));
  1779.     if ModuleHandle = 0 then
  1780.     begin
  1781.       ModuleHandle := LoadLibrary(PChar(ModuleName));
  1782.       if ModuleHandle = 0 then raise EJwaLoadLibraryError.Create('Library not found: ' + ModuleName);
  1783.     end;
  1784.     P := GetProcAddress(ModuleHandle, PChar(ProcName));
  1785.     if not Assigned(P) then raise EJwaGetProcAddressError.Create('Function not found: ' + ModuleName + '.' + ProcName);
  1786.   end;
  1787. end;
  1790. end.