Changeset 1890 for trunk/include


Ignore:
Timestamp:
Nov 30, 1999, 8:38:24 PM (26 years ago)
Author:
sandervl
Message:

Wine header updates

Location:
trunk/include/win
Files:
5 edited

Legend:

Unmodified
Added
Removed

  • trunk/include/win/ntddk.h

    r31 r1890  
    1 /* $Id: ntddk.h,v 1.2 1999-06-01 21:57:25 phaller Exp $ */
    2 
    3 /*
    4    this file defines interfaces mainly exposed to device drivers and
    5    native nt dll's
     1/* $Id: ntddk.h,v 1.3 1999-11-30 19:38:23 sandervl Exp $ */
     2/*
     3        this file defines interfaces mainly exposed to device drivers and
     4        native nt dll's
    65
    76*/
    … …  
    98#define __WINE_NTDDK_H
    109
    11 #include <ntdef.h>
    12 #include <winnt.h>
    13 #include "winbase.h"                     /* fixme: should be taken out sometimes */
     10#include "ntdef.h"
     11#include "winnt.h"
     12#include "winbase.h"    /* fixme: should be taken out sometimes */
    1413
    1514#ifdef __cplusplus
    … …  
    1716#endif
    1817
    19 /******************
    20  * asynchronous I/O
    21  */
    22 #undef Status  /* conflict with X11-includes*/
    23 
    24 typedef struct _IO_STATUS_BLOCK
    25 {  union
    26    { NTSTATUS Status;
    27      PVOID Pointer;
    28    } u;
    29    ULONG_PTR Information;
    30 } IO_STATUS_BLOCK, *PIO_STATUS_BLOCK;
    31 
    32 typedef VOID (NTAPI IO_APC_ROUTINE) ( PVOID ApcContext, PIO_STATUS_BLOCK IoStatusBlock, ULONG Reserved );
    33 typedef IO_APC_ROUTINE *PIO_APIO_APC_ROUTINE;
    34 
     18/******************
     19 * asynchronous I/O
     20 */
     21#undef Status   /* conflict with X11-includes*/
     22
     23typedef struct _IO_STATUS_BLOCK
     24{
     25        union {
     26          NTSTATUS Status;
     27          PVOID Pointer;
     28        } DUMMYUNIONNAME;
     29        ULONG_PTR Information;
     30} IO_STATUS_BLOCK, *PIO_STATUS_BLOCK;   
     31
     32typedef VOID (NTAPI *PIO_APC_ROUTINE) ( PVOID ApcContext, PIO_STATUS_BLOCK IoStatusBlock, ULONG Reserved );
    3533
    3634typedef enum _KEY_INFORMATION_CLASS {
    37    KeyBasicInformation,
    38    KeyNodeInformation,
    39    KeyFullInformation
     35        KeyBasicInformation,
     36        KeyNodeInformation,
     37        KeyFullInformation
    4038} KEY_INFORMATION_CLASS;
    4139
    4240typedef enum _KEY_VALUE_INFORMATION_CLASS {
    43    KeyValueBasicInformation,
    44    KeyValueFullInformation,
    45    KeyValuePartialInformation,
    46    KeyValueFullInformationAlign64,
    47    KeyValuePartialInformationAlign64
     41        KeyValueBasicInformation,
     42        KeyValueFullInformation,
     43        KeyValuePartialInformation,
     44        KeyValueFullInformationAlign64,
     45        KeyValuePartialInformationAlign64
    4846} KEY_VALUE_INFORMATION_CLASS;
    4947
    50 typedef enum _THREADINFOCLASS
    51 {  ThreadBasicInformation,
    52    ThreadTimes,
    53    ThreadPriority,
    54    ThreadBasePriority,
    55    ThreadAffinityMask,
    56    ThreadImpersonationToken,
    57    ThreadDescriptorTableEntry,
    58    ThreadEnableAlignmentFaultFixup,
    59    ThreadEventPair_Reusable,
    60    ThreadQuerySetWin32StartAddress,
    61    ThreadZeroTlsCell,
    62    ThreadPerformanceCount,
    63    ThreadAmILastThread,
    64    ThreadIdealProcessor,
    65    ThreadPriorityBoost,
    66    ThreadSetTlsArrayAddress,
    67    ThreadIsIoPending,
    68    MaxThreadInfoClass
     48typedef enum _THREADINFOCLASS 
     49{       ThreadBasicInformation,
     50        ThreadTimes,
     51        ThreadPriority,
     52        ThreadBasePriority,
     53        ThreadAffinityMask,
     54        ThreadImpersonationToken,
     55        ThreadDescriptorTableEntry,
     56        ThreadEnableAlignmentFaultFixup,
     57        ThreadEventPair_Reusable,
     58        ThreadQuerySetWin32StartAddress,
     59        ThreadZeroTlsCell,
     60        ThreadPerformanceCount,
     61        ThreadAmILastThread,
     62        ThreadIdealProcessor,
     63        ThreadPriorityBoost,
     64        ThreadSetTlsArrayAddress,
     65        ThreadIsIoPending,
     66        MaxThreadInfoClass
    6967} THREADINFOCLASS;
    7068
    7169typedef enum _FILE_INFORMATION_CLASS {
    72    FileDirectoryInformation = 1,
    73    FileFullDirectoryInformation,
    74    FileBothDirectoryInformation,
    75    FileBasicInformation,
    76    FileStandardInformation,
    77    FileInternalInformation,
    78    FileEaInformation,
    79    FileAccessInformation,
    80    FileNameInformation,
    81    FileRenameInformation,
    82    FileLinkInformation,
    83    FileNamesInformation,
    84    FileDispositionInformation,
    85    FilePositionInformation,
    86    FileFullEaInformation,
    87    FileModeInformation,
    88    FileAlignmentInformation,
    89    FileAllInformation,
    90    FileAllocationInformation,
    91    FileEndOfFileInformation,
    92    FileAlternateNameInformation,
    93    FileStreamInformation,
    94    FilePipeInformation,
    95    FilePipeLocalInformation,
    96    FilePipeRemoteInformation,
    97    FileMailslotQueryInformation,
    98    FileMailslotSetInformation,
    99    FileCompressionInformation,
    100    FileObjectIdInformation,
    101    FileCompletionInformation,
    102    FileMoveClusterInformation,
    103    FileQuotaInformation,
    104    FileReparsePointInformation,
    105    FileNetworkOpenInformation,
    106    FileAttributeTagInformation,
    107    FileTrackingInformation,
    108    FileMaximumInformation
     70        FileDirectoryInformation = 1,
     71        FileFullDirectoryInformation,
     72        FileBothDirectoryInformation,
     73        FileBasicInformation,
     74        FileStandardInformation,
     75        FileInternalInformation,
     76        FileEaInformation,
     77        FileAccessInformation,
     78        FileNameInformation,
     79        FileRenameInformation,
     80        FileLinkInformation,
     81        FileNamesInformation,
     82        FileDispositionInformation,
     83        FilePositionInformation,
     84        FileFullEaInformation,
     85        FileModeInformation,
     86        FileAlignmentInformation,
     87        FileAllInformation,
     88        FileAllocationInformation,
     89        FileEndOfFileInformation,
     90        FileAlternateNameInformation,
     91        FileStreamInformation,
     92        FilePipeInformation,
     93        FilePipeLocalInformation,
     94        FilePipeRemoteInformation,
     95        FileMailslotQueryInformation,
     96        FileMailslotSetInformation,
     97        FileCompressionInformation,
     98        FileObjectIdInformation,
     99        FileCompletionInformation,
     100        FileMoveClusterInformation,
     101        FileQuotaInformation,
     102        FileReparsePointInformation,
     103        FileNetworkOpenInformation,
     104        FileAttributeTagInformation,
     105        FileTrackingInformation,
     106        FileMaximumInformation
    109107} FILE_INFORMATION_CLASS, *PFILE_INFORMATION_CLASS;
    110108
    111 typedef enum _SECTION_INHERIT
     109typedef enum _FSINFOCLASS {
     110        FileFsVolumeInformation = 1,
     111        FileFsLabelInformation,
     112        FileFsSizeInformation,
     113        FileFsDeviceInformation,
     114        FileFsAttributeInformation,
     115        FileFsControlInformation,
     116        FileFsFullSizeInformation,
     117        FileFsObjectIdInformation,
     118        FileFsMaximumInformation
     119} FS_INFORMATION_CLASS, *PFS_INFORMATION_CLASS;
     120
     121typedef enum _SECTION_INHERIT
    112122{
    113    ViewShare = 1,
    114    ViewUnmap = 2
     123        ViewShare = 1,
     124        ViewUnmap = 2
    115125
    116126} SECTION_INHERIT;
    117 
    118 /*
    119    placeholder
     127 
     128/*
     129        placeholder
    120130*/
    121131typedef enum _OBJECT_INFORMATION_CLASS
    122132{
    123    DunnoTheConstants1
     133        DunnoTheConstants1
    124134
    125135} OBJECT_INFORMATION_CLASS, *POBJECT_INFORMATION_CLASS;
    … …  
    127137
    128138/*
    129  * NtQuerySystemInformation
     139 *      NtQuerySystemInformation
    130140 */
    131141
    132142typedef enum SYSTEM_INFORMATION_CLASS
    133 {  Unknown1 = 1,
    134    Unknown2,
    135    Unknown3,
    136    Unknown4,
    137    SystemPerformanceInformation
     143{       Unknown1 = 1,
     144        Unknown2,
     145        Unknown3,
     146        Unknown4,
     147        SystemPerformanceInformation
    138148} SYSTEM_INFORMATION_CLASS, *PSYSTEM_INFORMATION_CLASS;
    139149
    140150/* reading coffee grounds... */
    141151typedef struct _THREAD_INFO
    142 {  DWORD Unknown1[6];
    143    DWORD ThreadID;
    144    DWORD Unknown2[3];
    145    DWORD Status;
    146    DWORD WaitReason;
    147    DWORD Unknown3[4];
     152{       DWORD   Unknown1[6];
     153        DWORD   ThreadID;
     154        DWORD   Unknown2[3];
     155        DWORD   Status;
     156        DWORD   WaitReason;
     157        DWORD   Unknown3[4];
    148158} THREAD_INFO, PTHREAD_INFO;
    149159
    150160typedef struct _VM_COUNTERS_
    151 {  ULONG PeakVirtualSize;
    152    ULONG VirtualSize;
    153    ULONG PageFaultCount;
    154    ULONG PeakWorkingSetSize;
    155    ULONG WorkingSetSize;
    156    ULONG QuotaPeakPagedPoolUsage;
    157    ULONG QuotaPagedPoolUsage;
    158    ULONG QuotaPeakNonPagedPoolUsage;
    159    ULONG QuotaNonPagedPoolUsage;
    160    ULONG PagefileUsage;
    161    ULONG PeakPagefileUsage;
     161{       ULONG PeakVirtualSize;
     162        ULONG VirtualSize;
     163        ULONG PageFaultCount;
     164        ULONG PeakWorkingSetSize;
     165        ULONG WorkingSetSize;
     166        ULONG QuotaPeakPagedPoolUsage;
     167        ULONG QuotaPagedPoolUsage;
     168        ULONG QuotaPeakNonPagedPoolUsage;
     169        ULONG QuotaNonPagedPoolUsage;
     170        ULONG PagefileUsage;
     171        ULONG PeakPagefileUsage;
    162172} VM_COUNTERS, *PVM_COUNTERS;
    163173
    164174typedef struct _PROCESS_INFO
    165 {  DWORD    Offset;                         /* 00 offset to next PROCESS_INFO ok*/
    166    DWORD    ThreadCount;                 /* 04 number of ThreadInfo member ok */
    167    DWORD    Unknown1[6];
    168    FILETIME CreationTime;                /* 20 */
    169    DWORD    Unknown2[5];
    170    PWCHAR      ProcessName;              /* 3c ok */
    171    DWORD    BasePriority;
    172    DWORD    ProcessID;                   /* 44 ok*/
    173    DWORD    ParentProcessID;
    174    DWORD    HandleCount;
    175    DWORD    Unknown3[2];                 /* 50 */
    176    ULONG    PeakVirtualSize;
    177    ULONG    VirtualSize;
    178    ULONG    PageFaultCount;
    179    ULONG    PeakWorkingSetSize;
    180    ULONG    WorkingSetSize;
    181    ULONG    QuotaPeakPagedPoolUsage;
    182    ULONG    QuotaPagedPoolUsage;
    183    ULONG    QuotaPeakNonPagedPoolUsage;
    184    ULONG    QuotaNonPagedPoolUsage;
    185    ULONG    PagefileUsage;
    186    ULONG    PeakPagefileUsage;
    187    DWORD    PrivateBytes;
    188    DWORD    Unknown6[4];
    189    THREAD_INFO    ati[ANYSIZE_ARRAY];    /* 94 size=0x40*/
     175{       DWORD           Offset;         /* 00 offset to next PROCESS_INFO ok*/
     176        DWORD           ThreadCount;    /* 04 number of ThreadInfo member ok */
     177        DWORD           Unknown1[6];
     178        FILETIME        CreationTime;   /* 20 */
     179        DWORD           Unknown2[5];
     180        PWCHAR          ProcessName;    /* 3c ok */
     181        DWORD           BasePriority;
     182        DWORD           ProcessID;      /* 44 ok*/
     183        DWORD           ParentProcessID;
     184        DWORD           HandleCount;
     185        DWORD           Unknown3[2];    /* 50 */
     186        ULONG           PeakVirtualSize;
     187        ULONG           VirtualSize;
     188        ULONG           PageFaultCount;
     189        ULONG           PeakWorkingSetSize;
     190        ULONG           WorkingSetSize;
     191        ULONG           QuotaPeakPagedPoolUsage;
     192        ULONG           QuotaPagedPoolUsage;
     193        ULONG           QuotaPeakNonPagedPoolUsage;
     194        ULONG           QuotaNonPagedPoolUsage;
     195        ULONG           PagefileUsage;
     196        ULONG           PeakPagefileUsage;
     197        DWORD           PrivateBytes;
     198        DWORD           Unknown6[4];
     199        THREAD_INFO     ati[ANYSIZE_ARRAY];     /* 94 size=0x40*/
    190200} PROCESS_INFO, PPROCESS_INFO;
    191201
    192202NTSTATUS WINAPI NtQuerySystemInformation(
    193    IN SYSTEM_INFORMATION_CLASS SystemInformationClass,
    194    OUT PVOID SystemInformation,
    195    IN ULONG Length,
    196    OUT PULONG ResultLength);
    197 
    198 /*
    199  * system configuration
     203        IN SYSTEM_INFORMATION_CLASS SystemInformationClass,
     204        OUT PVOID SystemInformation,
     205        IN ULONG Length,
     206        OUT PULONG ResultLength);
     207
     208/*
     209 *      system configuration
    200210 */
    201211
    … …  
    203213typedef struct _SYSTEM_TIME_ADJUSTMENT
    204214{
    205    ULONG TimeAdjustment;
    206    BOOLEAN  TimeAdjustmentDisabled;
     215        ULONG   TimeAdjustment;
     216        BOOLEAN TimeAdjustmentDisabled;
    207217
    208218} SYSTEM_TIME_ADJUSTMENT, *PSYSTEM_TIME_ADJUSTMENT;
    209219
    210 typedef struct _SYSTEM_CONFIGURATION_INFO
     220typedef struct _SYSTEM_CONFIGURATION_INFO 
    211221{
    212    union
    213    { ULONG  OemId;
    214      struct
    215      { WORD ProcessorArchitecture;
    216        WORD Reserved;
    217      } tag1;
    218    } tag2;
    219    ULONG PageSize;
    220    PVOID MinimumApplicationAddress;
    221    PVOID MaximumApplicationAddress;
    222    ULONG ActiveProcessorMask;
    223    ULONG NumberOfProcessors;
    224    ULONG ProcessorType;
    225    ULONG AllocationGranularity;
    226    WORD  ProcessorLevel;
    227    WORD  ProcessorRevision;
     222        union
     223        { ULONG OemId;
     224          struct
     225          { WORD        ProcessorArchitecture;
     226            WORD        Reserved;
     227          } tag1;
     228        } tag2;
     229        ULONG   PageSize;
     230        PVOID   MinimumApplicationAddress;
     231        PVOID   MaximumApplicationAddress;
     232        ULONG   ActiveProcessorMask;
     233        ULONG   NumberOfProcessors;
     234        ULONG   ProcessorType;
     235        ULONG   AllocationGranularity;
     236        WORD    ProcessorLevel;
     237        WORD    ProcessorRevision;
    228238
    229239} SYSTEM_CONFIGURATION_INFO, *PSYSTEM_CONFIGURATION_INFO;
    230240
    231241
    232 typedef struct _SYSTEM_CACHE_INFORMATION
     242typedef struct _SYSTEM_CACHE_INFORMATION 
    233243{
    234    ULONG CurrentSize;
    235    ULONG PeakSize;
    236    ULONG PageFaultCount;
    237    ULONG MinimumWorkingSet;
    238    ULONG MaximumWorkingSet;
    239    ULONG Unused[4];
     244        ULONG   CurrentSize;
     245        ULONG   PeakSize;
     246        ULONG   PageFaultCount;
     247        ULONG   MinimumWorkingSet;
     248        ULONG   MaximumWorkingSet;
     249        ULONG   Unused[4];
    240250
    241251} SYSTEM_CACHE_INFORMATION;
    242252
    243253/*
    244  * NtQueryProcessInformation
     254 *      NtQueryProcessInformation
    245255 */
    246256
    247257/* parameter ProcessInformationClass */
    248258
    249 typedef enum _PROCESSINFOCLASS
    250 {  ProcessBasicInformation,
    251    ProcessQuotaLimits,
    252    ProcessIoCounters,
    253    ProcessVmCounters,
    254    ProcessTimes,
    255    ProcessBasePriority,
    256    ProcessRaisePriority,
    257    ProcessDebugPort,
    258    ProcessExceptionPort,
    259    ProcessAccessToken,
    260    ProcessLdtInformation,
    261    ProcessLdtSize,
    262    ProcessDefaultHardErrorMode,
    263    ProcessIoPortHandlers,
    264    ProcessPooledUsageAndLimits,
    265    ProcessWorkingSetWatch,
    266    ProcessUserModeIOPL,
    267    ProcessEnableAlignmentFaultFixup,
    268    ProcessPriorityClass,
    269    ProcessWx86Information,
    270    ProcessHandleCount,
    271    ProcessAffinityMask,
    272    ProcessPriorityBoost,
    273    ProcessDeviceMap,
    274    ProcessSessionInformation,
    275    ProcessForegroundInformation,
    276    ProcessWow64Information,
    277    MaxProcessInfoClass
     259typedef enum _PROCESSINFOCLASS 
     260{       ProcessBasicInformation,
     261        ProcessQuotaLimits,
     262        ProcessIoCounters,
     263        ProcessVmCounters,
     264        ProcessTimes,
     265        ProcessBasePriority,
     266        ProcessRaisePriority,
     267        ProcessDebugPort,
     268        ProcessExceptionPort,
     269        ProcessAccessToken,
     270        ProcessLdtInformation,
     271        ProcessLdtSize,
     272        ProcessDefaultHardErrorMode,
     273        ProcessIoPortHandlers,
     274        ProcessPooledUsageAndLimits,
     275        ProcessWorkingSetWatch,
     276        ProcessUserModeIOPL,
     277        ProcessEnableAlignmentFaultFixup,
     278        ProcessPriorityClass,
     279        ProcessWx86Information,
     280        ProcessHandleCount,
     281        ProcessAffinityMask,
     282        ProcessPriorityBoost,
     283        ProcessDeviceMap,
     284        ProcessSessionInformation,
     285        ProcessForegroundInformation,
     286        ProcessWow64Information,
     287        MaxProcessInfoClass
    278288} PROCESSINFOCLASS;
    279289
    280290/* parameter ProcessInformation (depending on ProcessInformationClass) */
    281291
    282 typedef struct _PROCESS_BASIC_INFORMATION
    283 {  DWORD ExitStatus;
    284    DWORD PebBaseAddress;
    285    DWORD AffinityMask;
    286    DWORD BasePriority;
    287    ULONG UniqueProcessId;
    288    ULONG InheritedFromUniqueProcessId;
     292typedef struct _PROCESS_BASIC_INFORMATION 
     293{       DWORD   ExitStatus;
     294        DWORD   PebBaseAddress;
     295        DWORD   AffinityMask;
     296        DWORD   BasePriority;
     297        ULONG   UniqueProcessId;
     298        ULONG   InheritedFromUniqueProcessId;
    289299} PROCESS_BASIC_INFORMATION;
    290300
    291301NTSTATUS WINAPI NtQueryInformationProcess(
    292    IN HANDLE ProcessHandle,
    293    IN PROCESSINFOCLASS ProcessInformationClass,
    294    OUT PVOID ProcessInformation,
    295    IN ULONG ProcessInformationLength,
    296    OUT PULONG ReturnLength);
     302        IN HANDLE ProcessHandle,
     303        IN PROCESSINFOCLASS ProcessInformationClass,
     304        OUT PVOID ProcessInformation,
     305        IN ULONG ProcessInformationLength,
     306        OUT PULONG ReturnLength);
    297307
    298308#define NtCurrentProcess() ( (HANDLE) -1 )
    299309
    300310/*
    301  * timer
    302  */
    303 
    304 typedef enum _TIMER_TYPE
     311 *      timer
     312 */
     313
     314typedef enum _TIMER_TYPE 
    305315{
    306    NotificationTimer,
    307    SynchronizationTimer
     316        NotificationTimer,
     317        SynchronizationTimer
    308318
    309319} TIMER_TYPE;
    310320
    311321/*
    312  * token functions
    313  */
    314 
     322 *      token functions
     323 */
     324 
    315325NTSTATUS WINAPI NtOpenProcessToken(
    316    HANDLE ProcessHandle,
    317    DWORD DesiredAccess,
    318    HANDLE *TokenHandle);
    319 
     326        HANDLE ProcessHandle,
     327        DWORD DesiredAccess,
     328        HANDLE *TokenHandle);
     329       
    320330NTSTATUS WINAPI NtOpenThreadToken(
    321    HANDLE ThreadHandle,
    322    DWORD DesiredAccess,
    323    BOOLEAN OpenAsSelf,
    324    HANDLE *TokenHandle);
     331        HANDLE ThreadHandle,
     332        DWORD DesiredAccess,
     333        BOOLEAN OpenAsSelf,
     334        HANDLE *TokenHandle);
    325335
    326336NTSTATUS WINAPI NtAdjustPrivilegesToken(
    327    IN HANDLE TokenHandle,
    328    IN BOOLEAN DisableAllPrivileges,
    329    IN PTOKEN_PRIVILEGES NewState,
    330    IN DWORD BufferLength,
    331    OUT PTOKEN_PRIVILEGES PreviousState,
    332    OUT PDWORD ReturnLength);
     337        IN HANDLE TokenHandle,
     338        IN BOOLEAN DisableAllPrivileges,
     339        IN PTOKEN_PRIVILEGES NewState,
     340        IN DWORD BufferLength,
     341        OUT PTOKEN_PRIVILEGES PreviousState,
     342        OUT PDWORD ReturnLength);
    333343
    334344NTSTATUS WINAPI NtQueryInformationToken(
    335    HANDLE token,
    336    DWORD tokeninfoclass,
    337    LPVOID tokeninfo,
    338    DWORD tokeninfolength,
    339    LPDWORD retlen );
    340 
    341 /*
    342  * sid functions
     345        HANDLE token,
     346        DWORD tokeninfoclass,
     347        LPVOID tokeninfo,
     348        DWORD tokeninfolength,
     349        LPDWORD retlen );
     350
     351/*
     352 *      sid functions
    343353 */
    344354
    345355BOOLEAN WINAPI RtlAllocateAndInitializeSid (
    346    PSID_IDENTIFIER_AUTHORITY pIdentifierAuthority,
    347    DWORD nSubAuthorityCount,
    348    DWORD x3,
    349    DWORD x4,
    350    DWORD x5,
    351    DWORD x6,
    352    DWORD x7,
    353    DWORD x8,
    354    DWORD x9,
    355    DWORD x10,
    356    PSID pSid);
    357 
     356        PSID_IDENTIFIER_AUTHORITY pIdentifierAuthority,
     357        DWORD nSubAuthorityCount,
     358        DWORD x3,
     359        DWORD x4,
     360        DWORD x5,
     361        DWORD x6,
     362        DWORD x7,
     363        DWORD x8,
     364        DWORD x9,
     365        DWORD x10,
     366        PSID pSid);
     367       
    358368DWORD WINAPI RtlEqualSid(DWORD x1,DWORD x2);
    359369DWORD WINAPI RtlFreeSid(DWORD x1);
    … …  
    366376
    367377/*
    368  * security descriptor functions
     378 *      security descriptor functions
    369379 */
    370380
    371381NTSTATUS WINAPI RtlCreateSecurityDescriptor(
    372    PSECURITY_DESCRIPTOR lpsd,
    373    DWORD rev);
     382        PSECURITY_DESCRIPTOR lpsd,
     383        DWORD rev);
    374384
    375385NTSTATUS WINAPI RtlValidSecurityDescriptor(
    376    PSECURITY_DESCRIPTOR SecurityDescriptor);
     386        PSECURITY_DESCRIPTOR SecurityDescriptor);
    377387
    378388ULONG WINAPI RtlLengthSecurityDescriptor(
    379    PSECURITY_DESCRIPTOR SecurityDescriptor);
     389        PSECURITY_DESCRIPTOR SecurityDescriptor);
    380390
    381391NTSTATUS WINAPI RtlGetDaclSecurityDescriptor(
    382    IN PSECURITY_DESCRIPTOR pSecurityDescriptor,
    383    OUT PBOOLEAN lpbDaclPresent,
    384    OUT PACL *pDacl,
    385    OUT PBOOLEAN lpbDaclDefaulted);
     392        IN PSECURITY_DESCRIPTOR pSecurityDescriptor,
     393        OUT PBOOLEAN lpbDaclPresent,
     394        OUT PACL *pDacl,
     395        OUT PBOOLEAN lpbDaclDefaulted);
    386396
    387397NTSTATUS WINAPI RtlSetDaclSecurityDescriptor (
    388    PSECURITY_DESCRIPTOR lpsd,
    389    BOOLEAN daclpresent,
    390    PACL dacl,
    391    BOOLEAN dacldefaulted );
     398        PSECURITY_DESCRIPTOR lpsd,
     399        BOOLEAN daclpresent,
     400        PACL dacl,
     401        BOOLEAN dacldefaulted );
    392402
    393403NTSTATUS WINAPI RtlGetSaclSecurityDescriptor(
    394    IN PSECURITY_DESCRIPTOR pSecurityDescriptor,
    395    OUT PBOOLEAN lpbSaclPresent,
    396    OUT PACL *pSacl,
    397    OUT PBOOLEAN lpbSaclDefaulted);
     404        IN PSECURITY_DESCRIPTOR pSecurityDescriptor,
     405        OUT PBOOLEAN lpbSaclPresent,
     406        OUT PACL *pSacl,
     407        OUT PBOOLEAN lpbSaclDefaulted);
    398408
    399409NTSTATUS WINAPI RtlSetSaclSecurityDescriptor (
    400    PSECURITY_DESCRIPTOR lpsd,
    401    BOOLEAN saclpresent,
    402    PACL sacl,
    403    BOOLEAN sacldefaulted);
     410        PSECURITY_DESCRIPTOR lpsd,
     411        BOOLEAN saclpresent,
     412        PACL sacl,
     413        BOOLEAN sacldefaulted);
    404414
    405415NTSTATUS WINAPI RtlGetOwnerSecurityDescriptor(
    406    PSECURITY_DESCRIPTOR SecurityDescriptor,
    407    PSID *Owner,
    408    PBOOLEAN OwnerDefaulted);
     416        PSECURITY_DESCRIPTOR SecurityDescriptor,
     417        PSID *Owner,
     418        PBOOLEAN OwnerDefaulted);
    409419
    410420NTSTATUS WINAPI RtlSetOwnerSecurityDescriptor(
    411    PSECURITY_DESCRIPTOR lpsd,
    412    PSID owner,
    413    BOOLEAN ownerdefaulted);
     421        PSECURITY_DESCRIPTOR lpsd,
     422        PSID owner,
     423        BOOLEAN ownerdefaulted);
    414424
    415425NTSTATUS WINAPI RtlSetGroupSecurityDescriptor (
    416    PSECURITY_DESCRIPTOR lpsd,
    417    PSID group,
    418    BOOLEAN groupdefaulted);
     426        PSECURITY_DESCRIPTOR lpsd,
     427        PSID group,
     428        BOOLEAN groupdefaulted);
    419429
    420430NTSTATUS WINAPI RtlGetGroupSecurityDescriptor(
    421    PSECURITY_DESCRIPTOR SecurityDescriptor,
    422    PSID *Group,
    423    PBOOLEAN GroupDefaulted);
    424 
    425 /* ##############################
    426    ######   ACL FUNCTIONS                ######
    427    ##############################
     431        PSECURITY_DESCRIPTOR SecurityDescriptor,
     432        PSID *Group,
     433        PBOOLEAN GroupDefaulted);
     434
     435/*      ##############################
     436        ######  ACL FUNCTIONS   ######
     437        ##############################
    428438*/
    429439
    … …  
    431441
    432442BOOLEAN WINAPI RtlFirstFreeAce(
    433    PACL acl,
    434    PACE_HEADER *x);
     443        PACL acl,
     444        PACE_HEADER *x);
    435445
    436446NTSTATUS WINAPI RtlAddAce(
    437    PACL acl,
    438    DWORD rev,
    439    DWORD xnrofaces,
    440    PACE_HEADER acestart,
    441    DWORD acelen);
    442 
     447        PACL acl,
     448        DWORD rev,
     449        DWORD xnrofaces,
     450        PACE_HEADER acestart,
     451        DWORD acelen);
     452       
    443453DWORD WINAPI RtlAddAccessAllowedAce(DWORD x1,DWORD x2,DWORD x3,DWORD x4);
    444454DWORD WINAPI RtlGetAce(PACL pAcl,DWORD dwAceIndex,LPVOID *pAce );
    445455
    446456/*
    447  * string functions
     457 *      string functions
    448458 */
    449459
    … …  
    468478
    469479/*
    470  * resource functions
     480 *      resource functions
    471481 */
    472482
    473483typedef struct _RTL_RWLOCK {
    474    CRITICAL_SECTION                      rtlCS;
    475    HANDLE      hSharedReleaseSemaphore;
    476    UINT        uSharedWaiters;
    477    HANDLE      hExclusiveReleaseSemaphore;
    478    UINT        uExclusiveWaiters;
    479    INT         iNumberActive;
    480    HANDLE      hOwningThreadId;
    481    DWORD       dwTimeoutBoost;
    482    PVOID       pDebugInfo;
     484        CRITICAL_SECTION        rtlCS;
     485        HANDLE          hSharedReleaseSemaphore;
     486        UINT                    uSharedWaiters;
     487        HANDLE          hExclusiveReleaseSemaphore;
     488        UINT                    uExclusiveWaiters;
     489        INT                     iNumberActive;
     490        HANDLE          hOwningThreadId;
     491        DWORD                   dwTimeoutBoost;
     492        PVOID                   pDebugInfo;
    483493} RTL_RWLOCK, *LPRTL_RWLOCK;
    484494
    485495VOID   WINAPI RtlInitializeResource(
    486    LPRTL_RWLOCK);
    487 
     496        LPRTL_RWLOCK);
     497       
    488498VOID   WINAPI RtlDeleteResource(
    489    LPRTL_RWLOCK);
    490 
     499        LPRTL_RWLOCK);
     500       
    491501BYTE   WINAPI RtlAcquireResourceExclusive(
    492    LPRTL_RWLOCK, BYTE fWait);
    493 
     502        LPRTL_RWLOCK, BYTE fWait);
     503       
    494504BYTE   WINAPI RtlAcquireResourceShared(
    495    LPRTL_RWLOCK, BYTE fWait);
    496 
     505        LPRTL_RWLOCK, BYTE fWait);
     506       
    497507VOID   WINAPI RtlReleaseResource(
    498    LPRTL_RWLOCK);
    499 
     508        LPRTL_RWLOCK);
     509       
    500510VOID   WINAPI RtlDumpResource(
    501    LPRTL_RWLOCK);
    502 
    503 /*
    504    time functions
    505  */
    506 
    507 typedef struct _TIME_FIELDS
     511        LPRTL_RWLOCK);
     512
     513/*
     514        time functions
     515 */
     516
     517typedef struct _TIME_FIELDS 
    508518{   CSHORT Year;
    509519    CSHORT Month;
    … …  
    519529
    520530VOID WINAPI RtlSystemTimeToLocalTime(
    521    IN  PLARGE_INTEGER SystemTime,
    522    OUT PLARGE_INTEGER LocalTime);
     531        IN  PLARGE_INTEGER SystemTime,
     532        OUT PLARGE_INTEGER LocalTime);
    523533
    524534VOID WINAPI RtlTimeToTimeFields(
    525    PLARGE_INTEGER liTime,
    526    PTIME_FIELDS TimeFields);
     535        PLARGE_INTEGER liTime,
     536        PTIME_FIELDS TimeFields);
    527537
    528538BOOLEAN WINAPI RtlTimeFieldsToTime(
    529    PTIME_FIELDS tfTimeFields,
    530    PLARGE_INTEGER Time);
    531 
     539        PTIME_FIELDS tfTimeFields,
     540        PLARGE_INTEGER Time);
     541       
    532542VOID WINAPI RtlTimeToElapsedTimeFields(
    533    PLARGE_INTEGER liTime,
    534    PTIME_FIELDS TimeFields);
    535 
     543        PLARGE_INTEGER liTime,
     544        PTIME_FIELDS TimeFields);
     545       
    536546BOOLEAN WINAPI RtlTimeToSecondsSince1980(
    537    LPFILETIME ft,
    538    LPDWORD timeret);
     547        LPFILETIME ft,
     548        LPDWORD timeret);
    539549
    540550BOOLEAN WINAPI RtlTimeToSecondsSince1970(
    541    LPFILETIME ft,
    542    LPDWORD timeret);
    543 
    544 /*
    545    heap functions
     551        LPFILETIME ft,
     552        LPDWORD timeret);
     553
     554/*
     555        heap functions
    546556*/
    547557
    … …  
    551561
    552562typedef struct
    553 {  ULONG Length;                         /* = sizeof(RTL_HEAP_DEFINITION) */
    554    ULONG Unknown[11];
     563{       ULONG   Length;         /* = sizeof(RTL_HEAP_DEFINITION) */
     564        ULONG   Unknown[11];
    555565} RTL_HEAP_DEFINITION, *PRTL_HEAP_DEFINITION;
    556566
    557567HANDLE WINAPI RtlCreateHeap(
    558    ULONG Flags,
    559    PVOID BaseAddress,
    560    ULONG SizeToReserve,
    561    ULONG SizeToCommit,
    562    PVOID Unknown,
    563    PRTL_HEAP_DEFINITION Definition);
     568        ULONG Flags,
     569        PVOID BaseAddress,
     570        ULONG SizeToReserve,
     571        ULONG SizeToCommit,
     572        PVOID Unknown,
     573        PRTL_HEAP_DEFINITION Definition);
    564574
    565575PVOID WINAPI RtlAllocateHeap(
    566    HANDLE Heap,
    567    ULONG Flags,
    568    ULONG Size);
     576        HANDLE Heap,
     577        ULONG Flags,
     578        ULONG Size);
    569579
    570580
    571581BOOLEAN WINAPI RtlFreeHeap(
    572    HANDLE Heap,
    573    ULONG Flags,
    574    PVOID Address);
    575 
    576 /*
    577  * misc
    578  */
    579 void __cdecl DbgPrint(LPCSTR fmt,LPVOID args);
    580 DWORD NtRaiseException ( DWORD dwExceptionCode, DWORD dwExceptionFlags, DWORD nNumberOfArguments,CONST ULONG_PTR *lpArguments);
    581 DWORD RtlRaiseException ( DWORD x);
     582        HANDLE Heap,
     583        ULONG Flags,
     584        PVOID Address);
     585
     586/*
     587 *      misc
     588 */
     589void WINAPIV DbgPrint(LPCSTR fmt, ...);
     590void WINAPI NtRaiseException(PEXCEPTION_RECORD,PCONTEXT,BOOL);
     591void WINAPI RtlRaiseException(PEXCEPTION_RECORD);
     592void WINAPI RtlRaiseStatus(NTSTATUS);
     593void WINAPI RtlUnwind(PEXCEPTION_FRAME,LPVOID,PEXCEPTION_RECORD,DWORD);
    582594VOID WINAPI RtlAcquirePebLock(void);
    583595VOID WINAPI RtlReleasePebLock(void);
    … …  
    591603BOOLEAN WINAPI RtlGetNtProductType(LPDWORD type);
    592604INT WINAPI RtlExtendedLargeIntegerDivide(LARGE_INTEGER dividend, DWORD divisor, LPDWORD rest);
    593 long long WINAPI RtlExtendedIntegerMultiply(LARGE_INTEGER factor1,INT factor2);
    594 DWORD WINAPI RtlFormatCurrentUserKeyPath(DWORD x);
     605LARGE_INTEGER WINAPI RtlExtendedIntegerMultiply(LARGE_INTEGER factor1,INT factor2);
     606DWORD WINAPI RtlFormatCurrentUserKeyPath(PUNICODE_STRING String);
    595607DWORD WINAPI RtlOpenCurrentUser(DWORD x1, DWORD *x2);
    596608BOOLEAN WINAPI RtlDosPathNameToNtPathName_U( LPWSTR from,PUNICODE_STRING us,DWORD x2,DWORD x3);

  • trunk/include/win/windef.h

    r1251 r1890  
    1 /* $Id: windef.h,v 1.15 1999-10-11 20:15:48 sandervl Exp $ */
     1/* $Id: windef.h,v 1.16 1999-11-30 19:38:23 sandervl Exp $ */
    22
    33/*
    … …  
    6363/* Calling conventions definitions */
    6464
     65#ifndef __WIN32OS2__
    6566#ifdef __i386__
    6667# if defined(__GNUC__) && (__GNUC__ == 2) && (__GNUC_MINOR__ >= 7)
    … …  
    7273# endif  /* __GNUC__ */
    7374#else  /* __i386__ */
    74 #ifndef __WIN32OS2__
    7575# define __stdcall
    7676# define __cdecl
    7777# define __RESTORE_ES
    78 #endif
    7978#endif  /* __i386__ */
     79#endif
    8080
    8181
    … …  
    183183typedef unsigned long   ULONG_PTR;
    184184typedef double          DOUBLE;
    185 typedef double          LONGLONG_W;
    186 typedef double          ULONGLONG_W;
     185typedef double          LONGLONG;
     186typedef double          ULONGLONG;
    187187
    188188/* FIXME: Wine does not compile with strict on, therefore strict
    … …  
    658658          ULONG Mid32;
    659659      } c;
    660       ULONGLONG_W Lo64;
     660      ULONGLONG Lo64;
    661661    } d;
    662662} DECIMAL;

  • trunk/include/win/winnt.h

    r1251 r1890  
    1 /* $Id: winnt.h,v 1.2 1999-10-11 20:15:48 sandervl Exp $ */
    2 
    31/*
    42 * Win32 definitions for Windows NT
    … …  
    2321
    2422/* u.x.wProcessorArchitecture (NT) */
    25 #define PROCESSOR_ARCHITECTURE_INTEL    0
    26 #define PROCESSOR_ARCHITECTURE_MIPS     1
    27 #define PROCESSOR_ARCHITECTURE_ALPHA    2
    28 #define PROCESSOR_ARCHITECTURE_PPC      3
    29 #define PROCESSOR_ARCHITECTURE_UNKNOWN  0xFFFF
     23#define PROCESSOR_ARCHITECTURE_INTEL    0
     24#define PROCESSOR_ARCHITECTURE_MIPS     1
     25#define PROCESSOR_ARCHITECTURE_ALPHA    2
     26#define PROCESSOR_ARCHITECTURE_PPC      3
     27#define PROCESSOR_ARCHITECTURE_SHX      4
     28#define PROCESSOR_ARCHITECTURE_ARM      5
     29#define PROCESSOR_ARCHITECTURE_UNKNOWN  0xFFFF
    3030
    3131/* dwProcessorType */
    32 #define PROCESSOR_INTEL_386     386
    33 #define PROCESSOR_INTEL_486     486
    34 #define PROCESSOR_INTEL_PENTIUM 586
    35 #define PROCESSOR_MIPS_R4000    4000
    36 #define PROCESSOR_ALPHA_21064   21064
    37 
     32#define PROCESSOR_INTEL_386      386
     33#define PROCESSOR_INTEL_486      486
     34#define PROCESSOR_INTEL_PENTIUM  586
     35#define PROCESSOR_INTEL_860      860
     36#define PROCESSOR_MIPS_R2000     2000
     37#define PROCESSOR_MIPS_R3000     3000
     38#define PROCESSOR_MIPS_R4000     4000
     39#define PROCESSOR_ALPHA_21064    21064
     40#define PROCESSOR_PPC_601        601
     41#define PROCESSOR_PPC_603        603
     42#define PROCESSOR_PPC_604        604
     43#define PROCESSOR_PPC_620        620
     44#define PROCESSOR_HITACHI_SH3    10003
     45#define PROCESSOR_HITACHI_SH3E   10004
     46#define PROCESSOR_HITACHI_SH4    10005
     47#define PROCESSOR_MOTOROLA_821   821
     48#define PROCESSOR_SHx_SH3        103
     49#define PROCESSOR_SHx_SH4        104
     50#define PROCESSOR_STRONGARM      2577
     51#define PROCESSOR_ARM720         1824    /* 0x720 */
     52#define PROCESSOR_ARM820         2080    /* 0x820 */
     53#define PROCESSOR_ARM920         2336    /* 0x920 */
     54#define PROCESSOR_ARM_7TDMI      70001
    3855
    3956#define ANYSIZE_ARRAY 1
    … …  
    5673
    5774/* Types */
     75
     76/* TCHAR data types definitions for Winelib. */
     77/* These types are _not_ defined for the emulator, because they */
     78/* depend on the UNICODE macro that only exists in user's code. */
     79
     80#ifndef __WINE__
     81# ifdef UNICODE
     82typedef LPWSTR LPTSTR;
     83typedef LPCWSTR LPCTSTR;
     84#define __TEXT(string) L##string /*probably wrong */
     85# else  /* UNICODE */
     86typedef LPSTR LPTSTR;
     87typedef LPCSTR LPCTSTR;
     88#define __TEXT(string) string
     89# endif /* UNICODE */
     90#endif   /* __WINE__ */
     91#define TEXT(quote) __TEXT(quote)
    5892
    5993typedef BYTE     BOOLEAN;
    … …  
    96130/* The Win32 register context */
    97131
    98 #define CONTEXT_i386      0x00010000
    99 #define CONTEXT_i486      CONTEXT_i386
    100 #define CONTEXT_CONTROL   (CONTEXT_i386 | 0x0001) /* SS:SP, CS:IP, FLAGS, BP */
    101 #define CONTEXT_INTEGER   (CONTEXT_i386 | 0x0002) /* AX, BX, CX, DX, SI, DI */
    102 #define CONTEXT_SEGMENTS  (CONTEXT_i386 | 0x0004) /* DS, ES, FS, GS */
    103 #define CONTEXT_FLOATING_POINT  (CONTEXT_i386 | 0x0008L) /* 387 state */
    104 #define CONTEXT_DEBUG_REGISTERS (CONTEXT_i386 | 0x0010L) /* DB 0-3,6,7 */
    105 #define CONTEXT_FULL (CONTEXT_CONTROL | CONTEXT_INTEGER | CONTEXT_SEGMENTS)
     132/* CONTEXT is the CPU-dependent context; it should be used        */
     133/* wherever a platform-specific context is needed (e.g. exception */
     134/* handling, Win32 register functions). */
     135
     136/* CONTEXT86 is the i386-specific context; it should be used    */
     137/* wherever only a 386 context makes sense (e.g. DOS interrupts, */
     138/* Win16 register functions), so that this code can be compiled */
     139/* on all platforms. */
    106140
    107141#define SIZE_OF_80387_REGISTERS      80
    108142
    109 typedef struct
     143typedef struct _FLOATING_SAVE_AREA
    110144{
    111145    DWORD   ControlWord;
    … …  
    118152    BYTE    RegisterArea[SIZE_OF_80387_REGISTERS];
    119153    DWORD   Cr0NpxState;
    120 } FLOATING_SAVE_AREA;
    121 
    122 typedef struct
     154} FLOATING_SAVE_AREA, *PFLOATING_SAVE_AREA;
     155
     156typedef struct _CONTEXT86
    123157{
    124158    DWORD   ContextFlags;
    … …  
    156190    DWORD   Esp;
    157191    DWORD   SegSs;
    158 } CONTEXT, *PCONTEXT;
    159 
     192} CONTEXT86;
     193
     194#define CONTEXT_X86       0x00010000
     195#define CONTEXT_i386      CONTEXT_X86
     196#define CONTEXT_i486      CONTEXT_X86
     197
     198#define CONTEXT86_CONTROL   (CONTEXT_i386 | 0x0001) /* SS:SP, CS:IP, FLAGS, BP */
     199#define CONTEXT86_INTEGER   (CONTEXT_i386 | 0x0002) /* AX, BX, CX, DX, SI, DI */
     200#define CONTEXT86_SEGMENTS  (CONTEXT_i386 | 0x0004) /* DS, ES, FS, GS */
     201#define CONTEXT86_FLOATING_POINT  (CONTEXT_i386 | 0x0008L) /* 387 state */
     202#define CONTEXT86_DEBUG_REGISTERS (CONTEXT_i386 | 0x0010L) /* DB 0-3,6,7 */
     203#define CONTEXT86_FULL (CONTEXT86_CONTROL | CONTEXT86_INTEGER | CONTEXT86_SEGMENTS)
     204
     205/* i386 context definitions */
     206#ifdef __i386__
     207
     208#define CONTEXT_CONTROL         CONTEXT86_CONTROL
     209#define CONTEXT_INTEGER         CONTEXT86_INTEGER
     210#define CONTEXT_SEGMENTS        CONTEXT86_SEGMENTS
     211#define CONTEXT_FLOATING_POINT  CONTEXT86_FLOATING_POINT
     212#define CONTEXT_DEBUG_REGISTERS CONTEXT86_DEBUG_REGISTERS
     213#define CONTEXT_FULL            CONTEXT86_FULL
     214
     215typedef CONTEXT86 CONTEXT;
     216
     217#endif  /* __i386__ */
     218
     219/* Alpha context definitions */
     220#ifdef _ALPHA_
     221
     222#define CONTEXT_ALPHA   0x00020000
     223 
     224#define CONTEXT_CONTROL         (CONTEXT_ALPHA | 0x00000001L)
     225#define CONTEXT_FLOATING_POINT  (CONTEXT_ALPHA | 0x00000002L)
     226#define CONTEXT_INTEGER         (CONTEXT_ALPHA | 0x00000004L)
     227#define CONTEXT_FULL  (CONTEXT_CONTROL | CONTEXT_FLOATING_POINT | CONTEXT_INTEGER)
     228
     229typedef struct _CONTEXT
     230{
     231    /* selected by CONTEXT_FLOATING_POINT */
     232    ULONGLONG FltF0;
     233    ULONGLONG FltF1;
     234    ULONGLONG FltF2;
     235    ULONGLONG FltF3;
     236    ULONGLONG FltF4;
     237    ULONGLONG FltF5;
     238    ULONGLONG FltF6;
     239    ULONGLONG FltF7;
     240    ULONGLONG FltF8;
     241    ULONGLONG FltF9;
     242    ULONGLONG FltF10;
     243    ULONGLONG FltF11;
     244    ULONGLONG FltF12;
     245    ULONGLONG FltF13;
     246    ULONGLONG FltF14;
     247    ULONGLONG FltF15;
     248    ULONGLONG FltF16;
     249    ULONGLONG FltF17;
     250    ULONGLONG FltF18;
     251    ULONGLONG FltF19;
     252    ULONGLONG FltF20;
     253    ULONGLONG FltF21;
     254    ULONGLONG FltF22;
     255    ULONGLONG FltF23;
     256    ULONGLONG FltF24;
     257    ULONGLONG FltF25;
     258    ULONGLONG FltF26;
     259    ULONGLONG FltF27;
     260    ULONGLONG FltF28;
     261    ULONGLONG FltF29;
     262    ULONGLONG FltF30;
     263    ULONGLONG FltF31;
     264
     265    /* selected by CONTEXT_INTEGER */
     266    ULONGLONG IntV0;
     267    ULONGLONG IntT0;
     268    ULONGLONG IntT1;
     269    ULONGLONG IntT2;
     270    ULONGLONG IntT3;
     271    ULONGLONG IntT4;
     272    ULONGLONG IntT5;
     273    ULONGLONG IntT6;
     274    ULONGLONG IntT7;
     275    ULONGLONG IntS0;
     276    ULONGLONG IntS1;
     277    ULONGLONG IntS2;
     278    ULONGLONG IntS3;
     279    ULONGLONG IntS4;
     280    ULONGLONG IntS5;
     281    ULONGLONG IntFp;
     282    ULONGLONG IntA0;
     283    ULONGLONG IntA1;
     284    ULONGLONG IntA2;
     285    ULONGLONG IntA3;
     286    ULONGLONG IntA4;
     287    ULONGLONG IntA5;
     288    ULONGLONG IntT8;
     289    ULONGLONG IntT9;
     290    ULONGLONG IntT10;
     291    ULONGLONG IntT11;
     292    ULONGLONG IntRa;
     293    ULONGLONG IntT12;
     294    ULONGLONG IntAt;
     295    ULONGLONG IntGp;
     296    ULONGLONG IntSp;
     297    ULONGLONG IntZero;
     298
     299    /* selected by CONTEXT_FLOATING_POINT */
     300    ULONGLONG Fpcr;
     301    ULONGLONG SoftFpcr;
     302
     303    /* selected by CONTEXT_CONTROL */
     304    ULONGLONG Fir;
     305    DWORD Psr;
     306    DWORD ContextFlags;
     307    DWORD Fill[4];
     308} CONTEXT;
     309
     310#define _QUAD_PSR_OFFSET   HighSoftFpcr
     311#define _QUAD_FLAGS_OFFSET HighFir
     312
     313#endif  /* _ALPHA_ */
     314
     315/* Mips context definitions */
     316#ifdef _MIPS_
     317
     318#define CONTEXT_R4000   0x00010000
     319
     320#define CONTEXT_CONTROL         (CONTEXT_R4000 | 0x00000001)
     321#define CONTEXT_FLOATING_POINT  (CONTEXT_R4000 | 0x00000002)
     322#define CONTEXT_INTEGER         (CONTEXT_R4000 | 0x00000004)
     323
     324#define CONTEXT_FULL (CONTEXT_CONTROL | CONTEXT_FLOATING_POINT | CONTEXT_INTEGER)
     325
     326typedef struct _CONTEXT
     327{
     328    DWORD Argument[4];
     329    /* These are selected by CONTEXT_FLOATING_POINT */
     330    DWORD FltF0;
     331    DWORD FltF1;
     332    DWORD FltF2;
     333    DWORD FltF3;
     334    DWORD FltF4;
     335    DWORD FltF5;
     336    DWORD FltF6;
     337    DWORD FltF7;
     338    DWORD FltF8;
     339    DWORD FltF9;
     340    DWORD FltF10;
     341    DWORD FltF11;
     342    DWORD FltF12;
     343    DWORD FltF13;
     344    DWORD FltF14;
     345    DWORD FltF15;
     346    DWORD FltF16;
     347    DWORD FltF17;
     348    DWORD FltF18;
     349    DWORD FltF19;
     350    DWORD FltF20;
     351    DWORD FltF21;
     352    DWORD FltF22;
     353    DWORD FltF23;
     354    DWORD FltF24;
     355    DWORD FltF25;
     356    DWORD FltF26;
     357    DWORD FltF27;
     358    DWORD FltF28;
     359    DWORD FltF29;
     360    DWORD FltF30;
     361    DWORD FltF31;
     362
     363    /* These are selected by CONTEXT_INTEGER */
     364    DWORD IntZero;
     365    DWORD IntAt;
     366    DWORD IntV0;
     367    DWORD IntV1;
     368    DWORD IntA0;
     369    DWORD IntA1;
     370    DWORD IntA2;
     371    DWORD IntA3;
     372    DWORD IntT0;
     373    DWORD IntT1;
     374    DWORD IntT2;
     375    DWORD IntT3;
     376    DWORD IntT4;
     377    DWORD IntT5;
     378    DWORD IntT6;
     379    DWORD IntT7;
     380    DWORD IntS0;
     381    DWORD IntS1;
     382    DWORD IntS2;
     383    DWORD IntS3;
     384    DWORD IntS4;
     385    DWORD IntS5;
     386    DWORD IntS6;
     387    DWORD IntS7;
     388    DWORD IntT8;
     389    DWORD IntT9;
     390    DWORD IntK0;
     391    DWORD IntK1;
     392    DWORD IntGp;
     393    DWORD IntSp;
     394    DWORD IntS8;
     395    DWORD IntRa;
     396    DWORD IntLo;
     397    DWORD IntHi;
     398
     399    /* These are selected by CONTEXT_FLOATING_POINT */
     400    DWORD Fsr;
     401
     402    /* These are selected by CONTEXT_CONTROL */
     403    DWORD Fir;
     404    DWORD Psr;
     405
     406    DWORD ContextFlags;
     407    DWORD Fill[2];
     408} CONTEXT;
     409
     410#endif  /* _MIPS_ */
     411
     412/* PowerPC context definitions */
     413#ifdef __PPC__
     414
     415#define CONTEXT_CONTROL         0x0001
     416#define CONTEXT_FLOATING_POINT  0x0002
     417#define CONTEXT_INTEGER         0x0004
     418#define CONTEXT_DEBUG_REGISTERS 0x0008
     419#define CONTEXT_FULL (CONTEXT_CONTROL | CONTEXT_FLOATING_POINT | CONTEXT_INTEGER)
     420
     421typedef struct
     422{
     423    /* These are selected by CONTEXT_FLOATING_POINT */
     424    double Fpr0;
     425    double Fpr1;
     426    double Fpr2;
     427    double Fpr3;
     428    double Fpr4;
     429    double Fpr5;
     430    double Fpr6;
     431    double Fpr7;
     432    double Fpr8;
     433    double Fpr9;
     434    double Fpr10;
     435    double Fpr11;
     436    double Fpr12;
     437    double Fpr13;
     438    double Fpr14;
     439    double Fpr15;
     440    double Fpr16;
     441    double Fpr17;
     442    double Fpr18;
     443    double Fpr19;
     444    double Fpr20;
     445    double Fpr21;
     446    double Fpr22;
     447    double Fpr23;
     448    double Fpr24;
     449    double Fpr25;
     450    double Fpr26;
     451    double Fpr27;
     452    double Fpr28;
     453    double Fpr29;
     454    double Fpr30;
     455    double Fpr31;
     456    double Fpscr;
     457
     458    /* These are selected by CONTEXT_INTEGER */
     459    DWORD Gpr0;
     460    DWORD Gpr1;
     461    DWORD Gpr2;
     462    DWORD Gpr3;
     463    DWORD Gpr4;
     464    DWORD Gpr5;
     465    DWORD Gpr6;
     466    DWORD Gpr7;
     467    DWORD Gpr8;
     468    DWORD Gpr9;
     469    DWORD Gpr10;
     470    DWORD Gpr11;
     471    DWORD Gpr12;
     472    DWORD Gpr13;
     473    DWORD Gpr14;
     474    DWORD Gpr15;
     475    DWORD Gpr16;
     476    DWORD Gpr17;
     477    DWORD Gpr18;
     478    DWORD Gpr19;
     479    DWORD Gpr20;
     480    DWORD Gpr21;
     481    DWORD Gpr22;
     482    DWORD Gpr23;
     483    DWORD Gpr24;
     484    DWORD Gpr25;
     485    DWORD Gpr26;
     486    DWORD Gpr27;
     487    DWORD Gpr28;
     488    DWORD Gpr29;
     489    DWORD Gpr30;
     490    DWORD Gpr31;
     491
     492    DWORD Cr;
     493    DWORD Xer;
     494
     495    /* These are selected by CONTEXT_CONTROL */
     496    DWORD Msr;
     497    DWORD Iar;
     498    DWORD Lr;
     499    DWORD Ctr;
     500
     501    DWORD ContextFlags;
     502    DWORD Fill[3];
     503
     504    /* These are selected by CONTEXT_DEBUG_REGISTERS */
     505    DWORD Dr0;
     506    DWORD Dr1;
     507    DWORD Dr2;
     508    DWORD Dr3;
     509    DWORD Dr4;
     510    DWORD Dr5;
     511    DWORD Dr6;
     512    DWORD Dr7;
     513} CONTEXT;
     514
     515typedef struct _STACK_FRAME_HEADER
     516{
     517    DWORD BackChain;
     518    DWORD GlueSaved1;
     519    DWORD GlueSaved2;
     520    DWORD Reserved1;
     521    DWORD Spare1;
     522    DWORD Spare2;
     523
     524    DWORD Parameter0;
     525    DWORD Parameter1;
     526    DWORD Parameter2;
     527    DWORD Parameter3;
     528    DWORD Parameter4;
     529    DWORD Parameter5;
     530    DWORD Parameter6;
     531    DWORD Parameter7;
     532} STACK_FRAME_HEADER,*PSTACK_FRAME_HEADER;
     533
     534#endif  /* __PPC__ */
     535
     536#ifdef __sparc__
     537
     538/*
     539 * FIXME: 
     540 *
     541 * There is no official CONTEXT structure defined for the SPARC
     542 * architecture, so I just made one up.
     543 *
     544 * This structure is valid only for 32-bit SPARC architectures,
     545 * not for 64-bit SPARC.
     546 *
     547 * Note that this structure contains only the 'top-level' registers;
     548 * the rest of the register window chain is not visible.
     549 *
     550 * The layout follows the Solaris 'prgregset_t' structure.
     551 *
     552 */
     553
     554#define CONTEXT_SPARC            0x10000000
     555
     556#define CONTEXT_CONTROL         (CONTEXT_SPARC | 0x00000001)
     557#define CONTEXT_FLOATING_POINT  (CONTEXT_SPARC | 0x00000002)
     558#define CONTEXT_INTEGER         (CONTEXT_SPARC | 0x00000004)
     559
     560#define CONTEXT_FULL (CONTEXT_CONTROL | CONTEXT_FLOATING_POINT | CONTEXT_INTEGER)
     561
     562typedef struct _CONTEXT
     563{
     564    DWORD ContextFlags;
     565
     566    /* These are selected by CONTEXT_INTEGER */
     567    DWORD g0;
     568    DWORD g1;
     569    DWORD g2;
     570    DWORD g3;
     571    DWORD g4;
     572    DWORD g5;
     573    DWORD g6;
     574    DWORD g7;
     575    DWORD o0;
     576    DWORD o1;
     577    DWORD o2;
     578    DWORD o3;
     579    DWORD o4;
     580    DWORD o5;
     581    DWORD o6;
     582    DWORD o7;
     583    DWORD l0;
     584    DWORD l1;
     585    DWORD l2;
     586    DWORD l3;
     587    DWORD l4;
     588    DWORD l5;
     589    DWORD l6;
     590    DWORD l7;
     591    DWORD i0;
     592    DWORD i1;
     593    DWORD i2;
     594    DWORD i3;
     595    DWORD i4;
     596    DWORD i5;
     597    DWORD i6;
     598    DWORD i7;
     599
     600    /* These are selected by CONTEXT_CONTROL */
     601    DWORD psr;
     602    DWORD pc;
     603    DWORD npc;
     604    DWORD y;
     605    DWORD wim;
     606    DWORD tbr;
     607
     608    /* FIXME: floating point registers missing */
     609
     610} CONTEXT;
     611
     612#endif
     613
     614#if !defined(CONTEXT_FULL) && !defined(RC_INVOKED)
     615#error You need to define a CONTEXT for your CPU
     616#endif
     617
     618typedef CONTEXT *PCONTEXT;
    160619typedef HANDLE *PHANDLE;
    161620
    162621#ifdef __WINE__
    163622
    164 /* Macros for easier access to context registers */
     623/* Macros for easier access to i386 context registers */
    165624
    166625#define EAX_reg(context)     ((context)->Eax)
    … …  
    200659#define DH_reg(context)      (*((BYTE*)&EDX_reg(context)+1))
    201660                           
    202 #define IP_reg(context)      (*(WORD*)&EIP_reg(context))
    203 #define SP_reg(context)      (*(WORD*)&ESP_reg(context))
    204                            
    205 #define FL_reg(context)      (*(WORD*)&EFL_reg(context))
    206 
    207661#define SET_CFLAG(context)   (EFL_reg(context) |= 0x0001)
    208662#define RESET_CFLAG(context) (EFL_reg(context) &= ~0x0001)
    … …  
    213667#define V86BASE(context)     ((context)->Dr7) /* ugly */
    214668
     669
     670/* Macros to retrieve the current context */
     671
     672#ifdef __i386__
     673#define _DEFINE_REGS_ENTRYPOINT( name, fn, args ) \
     674  __asm__(".align 4\n\t"                         \
     675          ".globl " #name "\n\t"                 \
     676          ".type " #name ",@function\n\t"        \
     677          #name ":\n\t"                          \
     678          "call CALL32_Regs\n\t"                 \
     679          ".long " #fn "\n\t"                    \
     680          ".byte " #args ", " #args "\n\t");
     681
     682#define DEFINE_REGS_ENTRYPOINT_0( name, fn ) \
     683  _DEFINE_REGS_ENTRYPOINT( name, fn, 0 )
     684#define DEFINE_REGS_ENTRYPOINT_1( name, fn, t1 ) \
     685  _DEFINE_REGS_ENTRYPOINT( name, fn, 4 )
     686#define DEFINE_REGS_ENTRYPOINT_2( name, fn, t1, t2 ) \
     687  _DEFINE_REGS_ENTRYPOINT( name, fn, 8 )
     688#define DEFINE_REGS_ENTRYPOINT_3( name, fn, t1, t2, t3 ) \
     689  _DEFINE_REGS_ENTRYPOINT( name, fn, 12 )
     690#define DEFINE_REGS_ENTRYPOINT_4( name, fn, t1, t2, t3, t4 ) \
     691  _DEFINE_REGS_ENTRYPOINT( name, fn, 16 )
     692
     693#endif  /* __i386__ */
     694
     695#ifdef __sparc__
     696/* FIXME: use getcontext() to retrieve full context */
     697#define _GET_CONTEXT \
     698    CONTEXT context;   \
     699    do { memset(&context, 0, sizeof(CONTEXT));            \
     700         context.ContextFlags = CONTEXT_CONTROL;          \
     701         context.pc = (DWORD)__builtin_return_address(0); \
     702       } while (0)
     703
     704#define DEFINE_REGS_ENTRYPOINT_0( name, fn ) \
     705  void WINAPI name ( void ) \
     706  { _GET_CONTEXT; fn( &context ); }
     707#define DEFINE_REGS_ENTRYPOINT_1( name, fn, t1 ) \
     708  void WINAPI name ( t1 a1 ) \
     709  { _GET_CONTEXT; fn( a1, &context ); }
     710#define DEFINE_REGS_ENTRYPOINT_2( name, fn, t1, t2 ) \
     711  void WINAPI name ( t1 a1, t2 a2 ) \
     712  { _GET_CONTEXT; fn( a1, a2, &context ); }
     713#define DEFINE_REGS_ENTRYPOINT_3( name, fn, t1, t2, t3 ) \
     714  void WINAPI name ( t1 a1, t2 a2, t3 a3 ) \
     715  { _GET_CONTEXT; fn( a1, a2, a3, &context ); }
     716#define DEFINE_REGS_ENTRYPOINT_4( name, fn, t1, t2, t3, t4 ) \
     717  void WINAPI name ( t1 a1, t2 a2, t3 a3, t4 a4 ) \
     718  { _GET_CONTEXT; fn( a1, a2, a3, a4, &context ); }
     719
     720#endif /* __sparc__ */
     721
     722#ifndef DEFINE_REGS_ENTRYPOINT_0
     723#error You need to define DEFINE_REGS_ENTRYPOINT macros for your CPU
     724#endif
     725
     726#ifdef __i386__
     727# define GET_IP(context) ((LPVOID)(context)->Eip)
     728#endif
     729#ifdef __sparc__
     730# define GET_IP(context) ((LPVOID)(context)->pc)
     731#endif
     732 
     733#if !defined(GET_IP) && !defined(RC_INVOKED)
     734# error You must define GET_IP for this CPU
     735#endif
     736
    215737#endif  /* __WINE__ */
    216738
    … …  
    219741 */
    220742 
     743#define STATUS_SUCCESS                   0x00000000
    221744#define STATUS_WAIT_0                    0x00000000
    222745#define STATUS_ABANDONED_WAIT_0          0x00000080
    … …  
    224747#define STATUS_TIMEOUT                   0x00000102
    225748#define STATUS_PENDING                   0x00000103
     749#define STATUS_GUARD_PAGE_VIOLATION      0x80000001   
    226750#define STATUS_DATATYPE_MISALIGNMENT     0x80000002
    227751#define STATUS_BREAKPOINT                0x80000003
    228752#define STATUS_SINGLE_STEP               0x80000004
     753#define STATUS_BUFFER_OVERFLOW           0x80000005
     754#define STATUS_UNSUCCESSFUL              0xC0000001
    229755#define STATUS_ACCESS_VIOLATION          0xC0000005
    230756#define STATUS_IN_PAGE_ERROR             0xC0000006
     757#define STATUS_INVALID_PARAMETER         0xC000000D
    231758#define STATUS_NO_MEMORY                 0xC0000017
     759#define STATUS_CONFLICTING_ADDRESSES     0xC0000018
    232760#define STATUS_ILLEGAL_INSTRUCTION       0xC000001D
     761#define STATUS_BUFFER_TOO_SMALL          0xC0000023
    233762#define STATUS_NONCONTINUABLE_EXCEPTION  0xC0000025
    234763#define STATUS_INVALID_DISPOSITION       0xC0000026
     764#define STATUS_UNWIND                    0xC0000027
     765#define STATUS_BAD_STACK                 0xC0000028
     766#define STATUS_INVALID_UNWIND_TARGET     0xC0000029
     767#define STATUS_UNKNOWN_REVISION          0xC0000058
     768#define STATUS_INVALID_SECURITY_DESCR    0xC0000079
    235769#define STATUS_ARRAY_BOUNDS_EXCEEDED     0xC000008C
    236770#define STATUS_FLOAT_DENORMAL_OPERAND    0xC000008D
    … …  
    244778#define STATUS_INTEGER_OVERFLOW          0xC0000095
    245779#define STATUS_PRIVILEGED_INSTRUCTION    0xC0000096
     780#define STATUS_INVALID_PARAMETER_2       0xC00000F0
    246781#define STATUS_STACK_OVERFLOW            0xC00000FD
    247782#define STATUS_CONTROL_C_EXIT            0xC000013A
    248 
    249 #define EXCEPTION_ACCESS_VIOLATION          STATUS_ACCESS_VIOLATION
    250 #define EXCEPTION_DATATYPE_MISALIGNMENT     STATUS_DATATYPE_MISALIGNMENT
    251 #define EXCEPTION_BREAKPOINT                STATUS_BREAKPOINT
    252 #define EXCEPTION_SINGLE_STEP               STATUS_SINGLE_STEP
    253 #define EXCEPTION_ARRAY_BOUNDS_EXCEEDED     STATUS_ARRAY_BOUNDS_EXCEEDED
    254 #define EXCEPTION_FLT_DENORMAL_OPERAND      STATUS_FLOAT_DENORMAL_OPERAND
    255 #define EXCEPTION_FLT_DIVIDE_BY_ZERO        STATUS_FLOAT_DIVIDE_BY_ZERO
    256 #define EXCEPTION_FLT_INEXACT_RESULT        STATUS_FLOAT_INEXACT_RESULT
    257 #define EXCEPTION_FLT_INVALID_OPERATION     STATUS_FLOAT_INVALID_OPERATION
    258 #define EXCEPTION_FLT_OVERFLOW              STATUS_FLOAT_OVERFLOW
    259 #define EXCEPTION_FLT_STACK_CHECK           STATUS_FLOAT_STACK_CHECK
    260 #define EXCEPTION_FLT_UNDERFLOW             STATUS_FLOAT_UNDERFLOW
    261 #define EXCEPTION_INT_DIVIDE_BY_ZERO        STATUS_INTEGER_DIVIDE_BY_ZERO
    262 #define EXCEPTION_INT_OVERFLOW              STATUS_INTEGER_OVERFLOW
    263 #define EXCEPTION_PRIV_INSTRUCTION          STATUS_PRIVILEGED_INSTRUCTION
    264 #define EXCEPTION_IN_PAGE_ERROR             STATUS_IN_PAGE_ERROR
    265 #define EXCEPTION_ILLEGAL_INSTRUCTION       STATUS_ILLEGAL_INSTRUCTION
    266 #define EXCEPTION_NONCONTINUABLE_EXCEPTION  STATUS_NONCONTINUABLE_EXCEPTION
    267 #define EXCEPTION_STACK_OVERFLOW            STATUS_STACK_OVERFLOW
    268 #define EXCEPTION_INVALID_DISPOSITION       STATUS_INVALID_DISPOSITION
    269 #define EXCEPTION_GUARD_PAGE                STATUS_GUARD_PAGE_VIOLATION
    270 #define EXCEPTION_INVALID_HANDLE            STATUS_INVALID_HANDLE
    271 #define CONTROL_C_EXIT                      STATUS_CONTROL_C_EXIT
    272783
    273784#define MAXIMUM_WAIT_OBJECTS 64
    … …  
    335846} EXCEPTION_POINTERS, *PEXCEPTION_POINTERS;
    336847
     848
     849/*
     850 * The exception frame, used for registering exception handlers
     851 * Win32 cares only about this, but compilers generally emit
     852 * larger exception frames for their own use.
     853 */
     854
     855struct __EXCEPTION_FRAME;
     856
     857typedef DWORD (*PEXCEPTION_HANDLER)(PEXCEPTION_RECORD,struct __EXCEPTION_FRAME*,
     858                                    PCONTEXT,struct __EXCEPTION_FRAME **);
     859
     860typedef struct __EXCEPTION_FRAME
     861{
     862  struct __EXCEPTION_FRAME *Prev;
     863  PEXCEPTION_HANDLER       Handler;
     864} EXCEPTION_FRAME, *PEXCEPTION_FRAME;
     865
    337866#include "poppack.h"
    338867
    … …  
    341870 */
    342871
    343 typedef LONG (* CALLBACK PTOP_LEVEL_EXCEPTION_FILTER)(PEXCEPTION_POINTERS ExceptionInfo);
     872typedef LONG (CALLBACK *PTOP_LEVEL_EXCEPTION_FILTER)(PEXCEPTION_POINTERS ExceptionInfo);
    344873typedef PTOP_LEVEL_EXCEPTION_FILTER LPTOP_LEVEL_EXCEPTION_FILTER;
    345874
    … …  
    347876LPTOP_LEVEL_EXCEPTION_FILTER
    348877WINAPI SetUnhandledExceptionFilter( LPTOP_LEVEL_EXCEPTION_FILTER filter );
     878
     879/* status values for ContinueDebugEvent */
     880#define DBG_CONTINUE                0x00010002
     881#define DBG_TERMINATE_THREAD        0x40010003
     882#define DBG_TERMINATE_PROCESS       0x40010004
     883#define DBG_CONTROL_C               0x40010005
     884#define DBG_CONTROL_BREAK           0x40010008
     885#define DBG_EXCEPTION_NOT_HANDLED   0x80010001
     886
     887struct _TEB;
     888
     889#ifdef __WINE__
     890
     891#ifndef __WIN32OS2__
     892#if defined(__i386__)
     893static inline struct _TEB * WINE_UNUSED __get_teb(void)
     894{
     895    struct _TEB *teb;
     896    __asm__(".byte 0x64\n\tmovl (0x18),%0" : "=r" (teb));
     897    return teb;
     898}
     899#elif defined(HAVE__LWP_CREATE)
     900extern void *_lwp_getprivate(void);
     901static inline struct _TEB * WINE_UNUSED __get_teb(void)
     902{
     903    return (struct _TEB *)_lwp_getprivate();
     904}
     905#else
     906#error NtCurrentTeb() not defined for this architecture!
     907#endif
     908
     909#define NtCurrentTeb() __get_teb()
     910
     911#else /* __WINE__ */
     912extern struct _TEB * WINAPI NtCurrentTeb(void);
     913#endif
     914#endif //__WIN32OS2__
    349915
    350916/*
    … …  
    383949#include "pshpack1.h"
    384950
     951typedef DWORD ACCESS_MASK, *PACCESS_MASK;
     952
     953typedef struct _GENERIC_MAPPING {
     954    ACCESS_MASK GenericRead;
     955    ACCESS_MASK GenericWrite;
     956    ACCESS_MASK GenericExecute;
     957    ACCESS_MASK GenericAll;
     958} GENERIC_MAPPING, *PGENERIC_MAPPING;
     959
     960#ifndef SID_IDENTIFIER_AUTHORITY_DEFINED
     961#define SID_IDENTIFIER_AUTHORITY_DEFINED
    385962typedef struct {
    386963    BYTE Value[6];
    387964} SID_IDENTIFIER_AUTHORITY,*PSID_IDENTIFIER_AUTHORITY,*LPSID_IDENTIFIER_AUTHORITY;
    388 
     965#endif /* !defined(SID_IDENTIFIER_AUTHORITY_DEFINED) */
     966
     967#ifndef SID_DEFINED
     968#define SID_DEFINED
    389969typedef struct _SID {
    390970    BYTE Revision;
    … …  
    393973    DWORD SubAuthority[1];
    394974} SID,*PSID;
     975#endif /* !defined(SID_DEFINED) */
    395976
    396977#define SID_REVISION                    (1)     /* Current revision */
    … …  
    4241005#define SE_SELF_RELATIVE        0x8000
    4251006
    426 typedef DWORD SECURITY_INFORMATION;
    427 typedef WORD SECURITY_DESCRIPTOR_CONTROL;
     1007typedef DWORD SECURITY_INFORMATION, *PSECURITY_INFORMATION;
     1008typedef WORD SECURITY_DESCRIPTOR_CONTROL, *PSECURITY_DESCRIPTOR_CONTROL;
    4281009
    4291010/* The security descriptor structure */
    … …  
    4361017    PACL Sacl;
    4371018    PACL Dacl;
    438 } SECURITY_DESCRIPTOR, *PSECURITY_DESCRIPTOR, *LPSECURITY_DESCRIPTOR;
     1019} SECURITY_DESCRIPTOR, *PSECURITY_DESCRIPTOR;
    4391020
    4401021#define SECURITY_DESCRIPTOR_MIN_LENGTH   (sizeof(SECURITY_DESCRIPTOR))
    … …  
    4761057 */
    4771058
    478 typedef struct _LARGE_INTEGER
    479 {
    480     DWORD    LowPart;
    481     LONG     HighPart;
     1059typedef union _LARGE_INTEGER {
     1060    struct {
     1061        DWORD    LowPart;
     1062        LONG     HighPart;
     1063    } DUMMYSTRUCTNAME;
     1064    LONGLONG QuadPart;
    4821065} LARGE_INTEGER, *LPLARGE_INTEGER, *PLARGE_INTEGER;
    4831066
    484 typedef struct _ULARGE_INTEGER
    485 {
    486     DWORD    LowPart;
    487     DWORD    HighPart;
     1067typedef union _ULARGE_INTEGER {
     1068    struct {
     1069        DWORD    LowPart;
     1070        LONG     HighPart;
     1071    } DUMMYSTRUCTNAME;
     1072    LONGLONG QuadPart;
    4881073} ULARGE_INTEGER, *LPULARGE_INTEGER, *PULARGE_INTEGER;
    4891074
    … …  
    4981083  DWORD  Attributes;
    4991084} LUID_AND_ATTRIBUTES;
     1085
     1086/*
     1087 * PRIVILEGE_SET
     1088 */
     1089
     1090typedef struct _PRIVILEGE_SET {
     1091    DWORD PrivilegeCount;
     1092    DWORD Control;
     1093    LUID_AND_ATTRIBUTES Privilege[ANYSIZE_ARRAY];
     1094} PRIVILEGE_SET, *PPRIVILEGE_SET;
    5001095
    5011096/*
    … …  
    5601155  SecurityImpersonation,
    5611156  SecurityDelegation
    562 } SECURITY_IMPERSONATION_LEVEL;
     1157} SECURITY_IMPERSONATION_LEVEL, *PSECURITY_IMPERSONATION_LEVEL;
    5631158
    5641159
    … …  
    6891284#define GENERIC_EXECUTE            0x20000000
    6901285#define GENERIC_ALL                0x10000000
     1286
     1287#define MAXIMUM_ALLOWED            0x02000000
     1288#define ACCESS_SYSTEM_SECURITY     0x01000000
    6911289
    6921290#define EVENT_MODIFY_STATE         0x0002
    … …  
    7911389#define SACL_SECURITY_INFORMATION   0x00000008
    7921390
    793 #define UNREFERENCED_PARAMETER(P)          (P)
    794 
    7951391#include "poppack.h"
    7961392

  • trunk/include/win/winprocess.h

    r1887 r1890  
    1 /* $Id: winprocess.h,v 1.4 1999-11-30 14:32:34 sandervl Exp $ */
     1/* $Id: winprocess.h,v 1.5 1999-11-30 19:38:24 sandervl Exp $ */
    22/*
    33 * Process definitions
    … …  
    9898    WORD            winver;            /*    Windows version figured out by VERSION_GetVersion */
    9999    struct _SERVICETABLE *service_table; /*  Service table for service thread */
     100#ifdef __WIN32OS2__
     101    DWORD           hInstance;         //instance handle of executable
     102#endif
    100103} PDB;
    101104

  • trunk/include/win/wtypes.h

    r805 r1890  
    164164#endif
    165165    } u;
    166     LONGLONG_W int64;
     166    LONGLONG int64;
    167167} CY;
    168168#endif /* _tagCY_DEFINED */
Note: See TracChangeset for help on using the changeset viewer.