{******************************************************************************}
{                                                       	               }
{ NT Status Codes API interface Unit for Object Pascal                         }
{                                                       	               }
{ Portions created by Microsoft are Copyright (C) 1995-2001 Microsoft          }
{ Corporation. All Rights Reserved.                                            }
{ 								               }
{ The original file is: ntstatus.h, released June 2000. The original Pascal    }
{ code is: Nt_Status.pas, released December 2000. The initial developer of the }
{ Pascal code is Marcel van Brakel (brakelm@chello.nl).                        }
{                                                                              }
{ Portions created by Marcel van Brakel are Copyright (C) 1999-2001            }
{ Marcel van Brakel. All Rights Reserved.                                      }
{ 								               }
{ 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 or my personal homepage located at   }
{ http://members.chello.nl/m.vanbrakel2                                        }
{								               }
{ 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.    }
{                                                                              }
{ Alternatively, the contents of this file may be used under the terms of the  }
{ GNU Lesser General Public License (the  "LGPL License"), in which case the   }
{ provisions of the LGPL License are applicable instead of those above.        }
{ If you wish to allow use of your version of this file only under the terms   }
{ of the LGPL License and not to allow others to use your version of this file }
{ under the MPL, indicate your decision by deleting  the provisions above and  }
{ replace  them with the notice and other provisions required by the LGPL      }
{ License.  If you do not delete the provisions above, a recipient may use     }
{ your version of this file under either the MPL or the LGPL License.          }
{ 								               }
{ For more information about the LGPL: http://www.gnu.org/copyleft/lesser.html }
{ 								               }
{******************************************************************************}

unit JwaNtStatus;

{$WEAKPACKAGEUNIT}

{$HPPEMIT ''}
{$HPPEMIT '#include "ntstatus.h"'}
{$HPPEMIT ''}

{$I WINDEFINES.INC}

interface

uses
  JwaWinType;

/////////////////////////////////////////////////////////////////////////
//
// Standard Success values
//
//
/////////////////////////////////////////////////////////////////////////

//
// The success status codes 0 - 63 are reserved for wait completion status.
// FacilityCodes 0x5 - 0xF have been allocated by various drivers.
//

const
  STATUS_SUCCESS = NTSTATUS($00000000); // ntsubauth
  {$EXTERNALSYM STATUS_SUCCESS}

//
//  Values are 32 bit values layed out as follows:
//
//   3 3 2 2 2 2 2 2 2 2 2 2 1 1 1 1 1 1 1 1 1 1
//   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
//  +---+-+-+-----------------------+-------------------------------+
//  |Sev|C|R|     Facility          |               Code            |
//  +---+-+-+-----------------------+-------------------------------+
//
//  where
//
//      Sev - is the severity code
//
//          00 - Success
//          01 - Informational
//          10 - Warning
//          11 - Error
//
//      C - is the Customer code flag
//
//      R - is a reserved bit
//
//      Facility - is the facility code
//
//      Code - is the facility's status code
//
//
// Define the facility codes
//

  FACILITY_USB_ERROR_CODE      = $10;
  {$EXTERNALSYM FACILITY_USB_ERROR_CODE}
  FACILITY_TERMINAL_SERVER     = $A;
  {$EXTERNALSYM FACILITY_TERMINAL_SERVER}
  FACILITY_RPC_STUBS           = $3;
  {$EXTERNALSYM FACILITY_RPC_STUBS}
  FACILITY_RPC_RUNTIME         = $2;
  {$EXTERNALSYM FACILITY_RPC_RUNTIME}
  FACILITY_IO_ERROR_CODE       = $4;
  {$EXTERNALSYM FACILITY_IO_ERROR_CODE}
  FACILITY_HID_ERROR_CODE      = $11;
  {$EXTERNALSYM FACILITY_HID_ERROR_CODE}
  FACILITY_FIREWIRE_ERROR_CODE = $12;
  {$EXTERNALSYM FACILITY_FIREWIRE_ERROR_CODE}
  FACILITY_DEBUGGER            = $1;
  {$EXTERNALSYM FACILITY_DEBUGGER}
  FACILITY_CLUSTER_ERROR_CODE  = $13;
  {$EXTERNALSYM FACILITY_CLUSTER_ERROR_CODE}
  FACILITY_ACPI_ERROR_CODE     = $14;
  {$EXTERNALSYM FACILITY_ACPI_ERROR_CODE}

//
// Define the severity codes
//

  STATUS_SEVERITY_WARNING       = $2;
  {$EXTERNALSYM STATUS_SEVERITY_WARNING}
  STATUS_SEVERITY_SUCCESS       = $0;
  {$EXTERNALSYM STATUS_SEVERITY_SUCCESS}
  STATUS_SEVERITY_INFORMATIONAL = $1;
  {$EXTERNALSYM STATUS_SEVERITY_INFORMATIONAL}
  STATUS_SEVERITY_ERROR         = $3;
  {$EXTERNALSYM STATUS_SEVERITY_ERROR}

//
// MessageId: STATUS_WAIT_0
//
// MessageText:
//
//  STATUS_WAIT_0
//

  STATUS_WAIT_0 = NTSTATUS($00000000); // winnt
  {$EXTERNALSYM STATUS_WAIT_0}

//
// MessageId: STATUS_WAIT_1
//
// MessageText:
//
//  STATUS_WAIT_1
//

  STATUS_WAIT_1 = NTSTATUS($00000001);
  {$EXTERNALSYM STATUS_WAIT_1}

//
// MessageId: STATUS_WAIT_2
//
// MessageText:
//
//  STATUS_WAIT_2
//

  STATUS_WAIT_2 = NTSTATUS($00000002);
  {$EXTERNALSYM STATUS_WAIT_2}

//
// MessageId: STATUS_WAIT_3
//
// MessageText:
//
//  STATUS_WAIT_3
//

  STATUS_WAIT_3 = NTSTATUS($00000003);
  {$EXTERNALSYM STATUS_WAIT_3}

//
// MessageId: STATUS_WAIT_63
//
// MessageText:
//
//  STATUS_WAIT_63
//

  STATUS_WAIT_63 = NTSTATUS($0000003F);
  {$EXTERNALSYM STATUS_WAIT_63}


//
// The success status codes 128 - 191 are reserved for wait completion
// status with an abandoned mutant object.
//

  STATUS_ABANDONED = NTSTATUS($00000080);
  {$EXTERNALSYM STATUS_ABANDONED}

//
// MessageId: STATUS_ABANDONED_WAIT_0
//
// MessageText:
//
//  STATUS_ABANDONED_WAIT_0
//

  STATUS_ABANDONED_WAIT_0 = NTSTATUS($00000080); // winnt
  {$EXTERNALSYM STATUS_ABANDONED_WAIT_0}

//
// MessageId: STATUS_ABANDONED_WAIT_63
//
// MessageText:
//
//  STATUS_ABANDONED_WAIT_63
//

  STATUS_ABANDONED_WAIT_63 = NTSTATUS($000000BF);
  {$EXTERNALSYM STATUS_ABANDONED_WAIT_63}


//                                                             
// The success status codes 256, 257, 258, and 258 are reserved for
// User APC, Kernel APC, Alerted, and Timeout.                 
//                                                             
//
// MessageId: STATUS_USER_APC
//
// MessageText:
//
//  STATUS_USER_APC
//

  STATUS_USER_APC = NTSTATUS($000000C0); // winnt
  {$EXTERNALSYM STATUS_USER_APC}

//
// MessageId: STATUS_KERNEL_APC
//
// MessageText:
//
//  STATUS_KERNEL_APC
//

  STATUS_KERNEL_APC = NTSTATUS($00000100);
  {$EXTERNALSYM STATUS_KERNEL_APC}

//
// MessageId: STATUS_ALERTED
//
// MessageText:
//
//  STATUS_ALERTED
//

  STATUS_ALERTED = NTSTATUS($00000101);
  {$EXTERNALSYM STATUS_ALERTED}

//
// MessageId: STATUS_TIMEOUT
//
// MessageText:
//
//  STATUS_TIMEOUT
//

  STATUS_TIMEOUT = NTSTATUS($00000102); // winnt
  {$EXTERNALSYM STATUS_TIMEOUT}

//
// MessageId: STATUS_PENDING
//
// MessageText:
//
//  The operation that was requested is pending completion.
//

  STATUS_PENDING = NTSTATUS($00000103); // winnt
  {$EXTERNALSYM STATUS_PENDING}

//
// MessageId: STATUS_REPARSE
//
// MessageText:
//
//  A reparse should be performed by the Object Manager since the name of the file resulted in a symbolic link.
//

  STATUS_REPARSE = NTSTATUS($00000104);
  {$EXTERNALSYM STATUS_REPARSE}

//
// MessageId: STATUS_MORE_ENTRIES
//
// MessageText:
//
//  Returned by enumeration APIs to indicate more information is available to successive calls.
//

  STATUS_MORE_ENTRIES = NTSTATUS($00000105);
  {$EXTERNALSYM STATUS_MORE_ENTRIES}

//
// MessageId: STATUS_NOT_ALL_ASSIGNED
//
// MessageText:
//
//  Indicates not all privileges referenced are assigned to the caller.
//  This allows, for example, all privileges to be disabled without having to know exactly which privileges are assigned.
//

  STATUS_NOT_ALL_ASSIGNED = NTSTATUS($00000106);
  {$EXTERNALSYM STATUS_NOT_ALL_ASSIGNED}

//
// MessageId: STATUS_SOME_NOT_MAPPED
//
// MessageText:
//
//  Some of the information to be translated has not been translated.
//

  STATUS_SOME_NOT_MAPPED = NTSTATUS($00000107);
  {$EXTERNALSYM STATUS_SOME_NOT_MAPPED}

//
// MessageId: STATUS_OPLOCK_BREAK_IN_PROGRESS
//
// MessageText:
//
//  An open/create operation completed while an oplock break is underway.
//

  STATUS_OPLOCK_BREAK_IN_PROGRESS = NTSTATUS($00000108);
  {$EXTERNALSYM STATUS_OPLOCK_BREAK_IN_PROGRESS}

//
// MessageId: STATUS_VOLUME_MOUNTED
//
// MessageText:
//
//  A new volume has been mounted by a file system.
//

  STATUS_VOLUME_MOUNTED = NTSTATUS($00000109);
  {$EXTERNALSYM STATUS_VOLUME_MOUNTED}

//
// MessageId: STATUS_RXACT_COMMITTED
//
// MessageText:
//
//  This success level status indicates that the transaction state already exists for the registry sub-tree,
//  but that a transaction commit was previously aborted.
//  The commit has now been completed.
//

  STATUS_RXACT_COMMITTED = NTSTATUS($0000010A);
  {$EXTERNALSYM STATUS_RXACT_COMMITTED}

//
// MessageId: STATUS_NOTIFY_CLEANUP
//
// MessageText:
//
//  This indicates that a notify change request has been completed due to closing the handle
//  which made the notify change request.
//

  STATUS_NOTIFY_CLEANUP = NTSTATUS($0000010B);
  {$EXTERNALSYM STATUS_NOTIFY_CLEANUP}

//
// MessageId: STATUS_NOTIFY_ENUM_DIR
//
// MessageText:
//
//  This indicates that a notify change request is being completed and that the information
//  is not being returned in the caller's buffer.
//  The caller now needs to enumerate the files to find the changes.
//

  STATUS_NOTIFY_ENUM_DIR = NTSTATUS($0000010C);
  {$EXTERNALSYM STATUS_NOTIFY_ENUM_DIR}

//
// MessageId: STATUS_NO_QUOTAS_FOR_ACCOUNT
//
// MessageText:
//
//  {No Quotas}
//  No system quota limits are specifically set for this account.
//

  STATUS_NO_QUOTAS_FOR_ACCOUNT = NTSTATUS($0000010D);
  {$EXTERNALSYM STATUS_NO_QUOTAS_FOR_ACCOUNT}

//
// MessageId: STATUS_PRIMARY_TRANSPORT_CONNECT_FAILED
//
// MessageText:
//
//  {Connect Failure on Primary Transport}
//  An attempt was made to connect to the remote server %hs on the primary transport, but the connection failed.
//  The computer WAS able to connect on a secondary transport.
//

  STATUS_PRIMARY_TRANSPORT_CONNECT_FAILED = NTSTATUS($0000010E);
  {$EXTERNALSYM STATUS_PRIMARY_TRANSPORT_CONNECT_FAILED}

//
// MessageId: STATUS_PAGE_FAULT_TRANSITION
//
// MessageText:
//
//  Page fault was a transition fault.
//

  STATUS_PAGE_FAULT_TRANSITION = NTSTATUS($00000110);
  {$EXTERNALSYM STATUS_PAGE_FAULT_TRANSITION}

//
// MessageId: STATUS_PAGE_FAULT_DEMAND_ZERO
//
// MessageText:
//
//  Page fault was a demand zero fault.
//

  STATUS_PAGE_FAULT_DEMAND_ZERO = NTSTATUS($00000111);
  {$EXTERNALSYM STATUS_PAGE_FAULT_DEMAND_ZERO}

//
// MessageId: STATUS_PAGE_FAULT_COPY_ON_WRITE
//
// MessageText:
//
//  Page fault was a demand zero fault.
//

  STATUS_PAGE_FAULT_COPY_ON_WRITE = NTSTATUS($00000112);
  {$EXTERNALSYM STATUS_PAGE_FAULT_COPY_ON_WRITE}

//
// MessageId: STATUS_PAGE_FAULT_GUARD_PAGE
//
// MessageText:
//
//  Page fault was a demand zero fault.
//

  STATUS_PAGE_FAULT_GUARD_PAGE = NTSTATUS($00000113);
  {$EXTERNALSYM STATUS_PAGE_FAULT_GUARD_PAGE}

//
// MessageId: STATUS_PAGE_FAULT_PAGING_FILE
//
// MessageText:
//
//  Page fault was satisfied by reading from a secondary storage device.
//

  STATUS_PAGE_FAULT_PAGING_FILE = NTSTATUS($00000114);
  {$EXTERNALSYM STATUS_PAGE_FAULT_PAGING_FILE}

//
// MessageId: STATUS_CACHE_PAGE_LOCKED
//
// MessageText:
//
//  Cached page was locked during operation.
//

  STATUS_CACHE_PAGE_LOCKED = NTSTATUS($00000115);
  {$EXTERNALSYM STATUS_CACHE_PAGE_LOCKED}

//
// MessageId: STATUS_CRASH_DUMP
//
// MessageText:
//
//  Crash dump exists in paging file.
//

  STATUS_CRASH_DUMP = NTSTATUS($00000116);
  {$EXTERNALSYM STATUS_CRASH_DUMP}

//
// MessageId: STATUS_BUFFER_ALL_ZEROS
//
// MessageText:
//
//  Specified buffer contains all zeros.
//

  STATUS_BUFFER_ALL_ZEROS = NTSTATUS($00000117);
  {$EXTERNALSYM STATUS_BUFFER_ALL_ZEROS}

//
// MessageId: STATUS_REPARSE_OBJECT
//
// MessageText:
//
//  A reparse should be performed by the Object Manager since the name of the file resulted in a symbolic link.
//

  STATUS_REPARSE_OBJECT = NTSTATUS($00000118);
  {$EXTERNALSYM STATUS_REPARSE_OBJECT}

//
// MessageId: STATUS_RESOURCE_REQUIREMENTS_CHANGED
//
// MessageText:
//
//  The device has succeeded a query-stop and its resource requirements have changed.
//

  STATUS_RESOURCE_REQUIREMENTS_CHANGED = NTSTATUS($00000119);
  {$EXTERNALSYM STATUS_RESOURCE_REQUIREMENTS_CHANGED}

//
// MessageId: STATUS_TRANSLATION_COMPLETE
//
// MessageText:
//
//  The translator has translated these resources into the global space and no further translations should be performed.
//

  STATUS_TRANSLATION_COMPLETE = NTSTATUS($00000120);
  {$EXTERNALSYM STATUS_TRANSLATION_COMPLETE}

//
// MessageId: STATUS_DS_MEMBERSHIP_EVALUATED_LOCALLY
//
// MessageText:
//
//  The directory service evaluated group memberships locally, as it was unable to contact a global catalog server.
//

  STATUS_DS_MEMBERSHIP_EVALUATED_LOCALLY = NTSTATUS($00000121);
  {$EXTERNALSYM STATUS_DS_MEMBERSHIP_EVALUATED_LOCALLY}

//
// MessageId: DBG_EXCEPTION_HANDLED
//
// MessageText:
//
//  Debugger handled exception
//

  DBG_EXCEPTION_HANDLED = NTSTATUS($00010001); // windbgkd
  {$EXTERNALSYM DBG_EXCEPTION_HANDLED}