winnt.pas

详细Windows API大全有关知识以及相关问题

{******************************************************************}
{                                                       	   }
{       Borland Delphi Runtime Library                  	   }
{       Windows 95/NT types interface unit                         }
{ 								   }
{ Portions created by Microsoft are 				   }
{ Copyright (C) 1995-1999 Microsoft Corporation. 		   }
{ All Rights Reserved. 						   }
{ 								   }
{ The original file is: winnt.h, released June 2000. 	           }
{ The original Pascal code is: WinNT.pas, released December 2000   }
{ The initial developer of the Pascal code is Marcel van Brakel    }
{ ([e-mail]).                      			   }
{ 								   }
{ Portions created by Marcel van Brakel are			   }
{ Copyright (C) 1999 Marcel van Brakel.				   }
{ 								   }
{ Obtained through:                               	           }
{ Joint Endeavour of Delphi Innovators (Project JEDI)              }
{								   }
{ You may retrieve the latest version of this file at the Project  }
{ JEDI home page, located at http://delphi-jedi.org                }
{								   }
{ The contents of this file are used with permission, 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/MPL-1.1.html 	                   }
{                                                                  }
{ 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. 			   }
{ 								   }
{******************************************************************}

unit WinNT;

{$WEAKPACKAGEUNIT}

{$HPPEMIT ''}
{$HPPEMIT '#include "winnt.h"'}
{$HPPEMIT ''}
{$HPPEMIT 'typedef PACL *PPACL'}
{$HPPEMIT 'typedef PSID *PPSID'}
{$HPPEMIT 'typedef PSECURITY_DESCRIPTOR *PPSECURITY_DESCRIPTOR'}
{$HPPEMIT ''}

{$I WINDEFINES.INC}

interface

uses
  WinType;

(* Already defined in WinType

const
  ANYSIZE_ARRAY = 1;
  {$EXTERNALSYM ANYSIZE_ARRAY}

{$IFDEF _WIN64}
  MAX_NATURAL_ALIGNMENT = SizeOf(ULONGLONG);
  {$EXTERNALSYM MAX_NATURAL_ALIGNMENT}
{$ELSE}
  MAX_NATURAL_ALIGNMENT = SizeOf(DWORD);
  {$EXTERNALSYM MAX_NATURAL_ALIGNMENT}
{$ENDIF}

type
  POINTER_32 = Pointer;
  {$EXTERNALSYM POINTER_32}
  POINTER_64 = Pointer;
  {$EXTERNALSYM POINTER_64}

  POINTER_64_INT = Int64;
  {$EXTERNALSYM POINTER_64_INT}

{$IFDEF _IA64_}
  FIRMWARE_PTR = POINTER_64;
{$ELSE}
  FIRMWARE_PTR = POINTER_32;
  {$EXTERNALSYM FIRMWARE_PTR}
{$ENDIF}

type
  PVOID = Pointer;
  {$EXTERNALSYM PVOID}
  PVOID64 = POINTER_64;
  {$EXTERNALSYM PVOID64}

//
// Basics
//

type
  SHORT = Shortint;
  {$EXTERNALSYM SHORT}
  LONG = Longint;
  {$EXTERNALSYM LONG}

//
// UNICODE (Wide Character) types
//

type
  WCHAR = WideChar;
  {$EXTERNALSYM WCHAR}

  PWCHAR = ^WCHAR;
  {$EXTERNALSYM PWCHAR}
  LPWCH = ^WCHAR;
  {$EXTERNALSYM LPWCH}
  PWCH = ^WCHAR;
  {$EXTERNALSYM PWCH}
  LPCWCH = ^WCHAR;
  {$EXTERNALSYM LPCWCH}
  PCWCH = ^WCHAR;
  {$EXTERNALSYM PCWCH}
  NWPSTR = ^WCHAR;
  {$EXTERNALSYM NWPSTR}
  LPWSTR = ^WCHAR;
  {$EXTERNALSYM LPWSTR}
  PWSTR = ^WCHAR;
  {$EXTERNALSYM PWSTR}

  LPCWSTR = ^WCHAR;
  {$EXTERNALSYM LPCWSTR}
  PCWSTR = ^WCHAR;
  {$EXTERNALSYM PCWSTR}

//
// ANSI (Multi-byte Character) types
//

  PCHAR = ^CHAR;
  {$EXTERNALSYM PCHAR}

  LPCH = ^CHAR;
  {$EXTERNALSYM LPCH}
  PCH = ^CHAR;
  {$EXTERNALSYM PCH}

  LPCCH = ^CHAR;
  {$EXTERNALSYM LPCCH}
  PCCH = ^CHAR;
  {$EXTERNALSYM PCCH}
  NPSTR = ^CHAR;
  {$EXTERNALSYM NPSTR}
  LPSTR = ^CHAR;
  {$EXTERNALSYM LPSTR}
  PSTR = ^CHAR;
  {$EXTERNALSYM PSTR}
  LPCSTR = ^CHAR;
  {$EXTERNALSYM LPCSTR}
  PCSTR = ^CHAR;
  {$EXTERNALSYM PCSTR}

//
// Neutral ANSI/UNICODE types and macros
//

{$IFDEF UNICODE}

type
  TCHAR = WCHAR;
  {$EXTERNALSYM TCHAR}
  PTCHAR = ^TCHAR;
  {$EXTERNALSYM PTCHAR}
  TBYTE = WCHAR;
  {$EXTERNALSYM TBYTE}
  PTBYTE = ^TBYTE;
  {$EXTERNALSYM PTBYTE}

  LPTCH = LPWSTR;
  {$EXTERNALSYM LPTCH}
  PTCH = LPWSTR;
  {$EXTERNALSYM PTCH}
  PTSTR = LPWSTR;
  {$EXTERNALSYM PTSTR}
  LPTSTR = LPWSTR;
  {$EXTERNALSYM LPTSTR}
  PCTSTR = LPCWSTR;
  {$EXTERNALSYM PCTSTR}
  LPCTSTR = LPCWSTR;
  {$EXTERNALSYM LPCTSTR}
  LP = LPWSTR;
  {$EXTERNALSYM LP}

  __TEXT = WideString;
  {$EXTERNALSYM __TEXT}

{$ELSE}   // UNICODE

  TCHAR = CHAR;
  {$EXTERNALSYM TCHAR}
  PTCHAR = ^CHAR;
  {$EXTERNALSYM PTCHAR}
  TBYTE = BYTE;
  {$EXTERNALSYM TBYTE}
  PTBYTE = ^BYTE;
  {$EXTERNALSYM PTBYTE}

  LPTCH = LPSTR;
  {$EXTERNALSYM LPTCH}
  PTCH = LPSTR;
  {$EXTERNALSYM PTCH}
  PTSTR = LPSTR;
  {$EXTERNALSYM PTSTR}
  LPTSTR = LPSTR;
  {$EXTERNALSYM LPTSTR}
  PCTSTR = LPCSTR;
  {$EXTERNALSYM PCTSTR}
  LPCTSTR = LPCSTR;
  {$EXTERNALSYM LPCTSTR}

  __TEXT = AnsiString;
  {$EXTERNALSYM __TEXT}

{$ENDIF} // UNICODE

type
  TEXT = __TEXT;
  {$EXTERNALSYM TEXT}

  PSHORT = ^SHORT;
  {$EXTERNALSYM PSHORT}
  PLONG = ^LONG;
  {$EXTERNALSYM PLONG}

  HANDLE = Pointer;
  {$EXTERNALSYM HANDLE}
  PHANDLE = ^HANDLE;
  {$EXTERNALSYM PHANDLE}
  THandle = HANDLE;

//
// Flag (bit) fields
//

  FCHAR = UCHAR;
  {$EXTERNALSYM FCHAR}
  FSHORT = USHORT;
  {$EXTERNALSYM FSHORT}
  FLONG = ULONG;
  {$EXTERNALSYM FLONG}

// Component Object Model defines, and macros

  HRESULT = LONG;
  {$EXTERNALSYM HRESULT}

  CCHAR = CHAR;
  {$EXTERNALSYM CCHAR}
  LCID = DWORD;
  {$EXTERNALSYM LCID}
  PLCID = PDWORD;
  {$EXTERNALSYM PLCID}
  LANGID = WORD;
  {$EXTERNALSYM LANGID}

const
  APPLICATION_ERROR_MASK       = $20000000;
  {$EXTERNALSYM APPLICATION_ERROR_MASK}
  ERROR_SEVERITY_SUCCESS       = $00000000;
  {$EXTERNALSYM ERROR_SEVERITY_SUCCESS}
  ERROR_SEVERITY_INFORMATIONAL = $40000000;
  {$EXTERNALSYM ERROR_SEVERITY_INFORMATIONAL}
  ERROR_SEVERITY_WARNING       = DWORD($80000000);
  {$EXTERNALSYM ERROR_SEVERITY_WARNING}
  ERROR_SEVERITY_ERROR         = DWORD($C0000000);
  {$EXTERNALSYM ERROR_SEVERITY_ERROR}

//
// _M_IX86 included so that EM CONTEXT structure compiles with
// x86 programs. *** TBD should this be for all architectures?
//

//
// 16 byte aligned type for 128 bit floats
//

//
// For we define a 128 bit structure and use __declspec(align(16)) pragma to
// align to 128 bits.
//

type
  PFloat128 = ^TFloat128;
  _FLOAT128 = record
    LowPart: Int64;
    HighPart: Int64;
  end;
  {$EXTERNALSYM _FLOAT128}
  FLOAT128 = _FLOAT128;
  {$EXTERNALSYM FLOAT128}
  TFloat128 = _FLOAT128;

//
// __int64 is only supported by 2.0 and later midl.
// __midl is set by the 2.0 midl and not by 1.0 midl.
//

type
  LONGLONG = Int64;
  {$EXTERNALSYM LONGLONG}
  ULONGLONG = Int64; 
  {$EXTERNALSYM ULONGLONG}

const
  MAXLONGLONG = $7fffffffffffffff;
  {$EXTERNALSYM MAXLONGLONG}

type
  PLONGLONG = ^LONGLONG;
  {$EXTERNALSYM PLONGLONG}
  PULONGLONG = ^ULONGLONG;
  {$EXTERNALSYM PULONGLONG}

// Update Sequence Number

  USN = LONGLONG;
  {$EXTERNALSYM USN}

  PLargeInteger = ^TLargeInteger;
  _LARGE_INTEGER = record
    case Integer of
    0: (
      LowPart: DWORD;
      HighPart: LONG);
    1: (
      QuadPart: LONGLONG);
  end;
  {$EXTERNALSYM _LARGE_INTEGER}
  LARGE_INTEGER = _LARGE_INTEGER;
  {$EXTERNALSYM LARGE_INTEGER}
  PLARGE_INTEGER = ^LARGE_INTEGER;
  {$EXTERNALSYM PLARGE_INTEGER}
  TLargeInteger = Int64;

  PULargeInteger = ^TULargeInteger;
  ULARGE_INTEGER = record
    case Integer of
      0: (
        LowPart: DWORD;
        HighPart: DWORD);
      1: (
        QuadPart: LONGLONG);
  end;
  {$EXTERNALSYM ULARGE_INTEGER}
  PULARGE_INTEGER = ^ULARGE_INTEGER;
  {$EXTERNALSYM PULARGE_INTEGER}
  TULargeInteger = ULARGE_INTEGER;

//
// Locally Unique Identifier
//

type
  PLuid = ^TLuid;
  _LUID = record
    LowPart: DWORD;
    HighPart: LONG;
  end;
  {$EXTERNALSYM _LUID}
  LUID = _LUID;
  {$EXTERNALSYM LUID}
  TLuid = _LUID;

  DWORDLONG = ULONGLONG;
  {$EXTERNALSYM DWORDLONG}
  PDWORDLONG = ^DWORDLONG;
  {$EXTERNALSYM PDWORDLONG}

//
// Define operations to logically shift an int64 by 0..31 bits and to multiply
// 32-bits by 32-bits to form a 64-bit product.
//

//