Fix indentation and coding style. No code changes.
authorEric Kohl <eric.kohl@reactos.org>
Sat, 9 Jan 2010 20:51:33 +0000 (20:51 +0000)
committerEric Kohl <eric.kohl@reactos.org>
Sat, 9 Jan 2010 20:51:33 +0000 (20:51 +0000)
svn path=/trunk/; revision=45018

14 files changed:
reactos/dll/win32/kernel32/process/cmdline.c
reactos/dll/win32/kernel32/process/job.c
reactos/dll/win32/kernel32/process/proc.c
reactos/dll/win32/kernel32/process/procsup.c
reactos/dll/win32/kernel32/process/session.c
reactos/dll/win32/kernel32/synch/critical.c
reactos/dll/win32/kernel32/synch/event.c
reactos/dll/win32/kernel32/synch/mutex.c
reactos/dll/win32/kernel32/synch/sem.c
reactos/dll/win32/kernel32/synch/timer.c
reactos/dll/win32/kernel32/synch/wait.c
reactos/dll/win32/kernel32/thread/fiber.c
reactos/dll/win32/kernel32/thread/fls.c
reactos/dll/win32/kernel32/thread/tls.c

index 0301de1..9b84ab9 100644 (file)
@@ -27,80 +27,85 @@ static BOOL bCommandLineInitialized = FALSE;
 
 /* FUNCTIONS ****************************************************************/
 
-static VOID
-InitCommandLines (VOID)
+static
+VOID
+InitCommandLines(VOID)
 {
-       PRTL_USER_PROCESS_PARAMETERS Params;
-
-        /* FIXME - not thread-safe! */
-
-       // get command line
-       Params = NtCurrentPeb()->ProcessParameters;
-       RtlNormalizeProcessParams (Params);
-
-       // initialize command line buffers
-       CommandLineStringW.Length = Params->CommandLine.Length;
-       CommandLineStringW.MaximumLength = CommandLineStringW.Length + sizeof(WCHAR);
-       CommandLineStringW.Buffer = RtlAllocateHeap(GetProcessHeap(),
-                                                   HEAP_GENERATE_EXCEPTIONS|HEAP_ZERO_MEMORY,
-                                                   CommandLineStringW.MaximumLength);
-        if (CommandLineStringW.Buffer == NULL)
-        {
-            return;
-        }
-
-       RtlInitAnsiString(&CommandLineStringA, NULL);
-
-       // copy command line
-       RtlCopyUnicodeString (&CommandLineStringW,
-                             &(Params->CommandLine));
-       CommandLineStringW.Buffer[CommandLineStringW.Length / sizeof(WCHAR)] = 0;
-
-       /* convert unicode string to ansi (or oem) */
-       if (bIsFileApiAnsi)
-           RtlUnicodeStringToAnsiString (&CommandLineStringA,
-                                         &CommandLineStringW,
-                                         TRUE);
-       else
-           RtlUnicodeStringToOemString (&CommandLineStringA,
-                                        &CommandLineStringW,
-                                        TRUE);
-
-       CommandLineStringA.Buffer[CommandLineStringA.Length] = 0;
-
-       bCommandLineInitialized = TRUE;
+    PRTL_USER_PROCESS_PARAMETERS Params;
+
+    /* FIXME - not thread-safe! */
+
+    // get command line
+    Params = NtCurrentPeb()->ProcessParameters;
+    RtlNormalizeProcessParams (Params);
+
+    // initialize command line buffers
+    CommandLineStringW.Length = Params->CommandLine.Length;
+    CommandLineStringW.MaximumLength = CommandLineStringW.Length + sizeof(WCHAR);
+    CommandLineStringW.Buffer = RtlAllocateHeap(GetProcessHeap(),
+                                                HEAP_GENERATE_EXCEPTIONS | HEAP_ZERO_MEMORY,
+                                                CommandLineStringW.MaximumLength);
+    if (CommandLineStringW.Buffer == NULL)
+    {
+        return;
+    }
+
+    RtlInitAnsiString(&CommandLineStringA, NULL);
+
+    /* Copy command line */
+    RtlCopyUnicodeString(&CommandLineStringW,
+                         &(Params->CommandLine));
+    CommandLineStringW.Buffer[CommandLineStringW.Length / sizeof(WCHAR)] = 0;
+
+    /* convert unicode string to ansi (or oem) */
+    if (bIsFileApiAnsi)
+        RtlUnicodeStringToAnsiString(&CommandLineStringA,
+                                     &CommandLineStringW,
+                                     TRUE);
+    else
+        RtlUnicodeStringToOemString(&CommandLineStringA,
+                                    &CommandLineStringW,
+                                    TRUE);
+
+    CommandLineStringA.Buffer[CommandLineStringA.Length] = 0;
+
+    bCommandLineInitialized = TRUE;
 }
 
 
 /*
  * @implemented
  */
-LPSTR WINAPI GetCommandLineA(VOID)
+LPSTR
+WINAPI
+GetCommandLineA(VOID)
 {
-       if (bCommandLineInitialized == FALSE)
-       {
-               InitCommandLines ();
-       }
+    if (bCommandLineInitialized == FALSE)
+    {
+        InitCommandLines();
+    }
 
-       DPRINT ("CommandLine \'%s\'\n", CommandLineStringA.Buffer);
+    DPRINT("CommandLine \'%s\'\n", CommandLineStringA.Buffer);
 
-       return(CommandLineStringA.Buffer);
+    return CommandLineStringA.Buffer;
 }
 
 
 /*
  * @implemented
  */
-LPWSTR WINAPI GetCommandLineW (VOID)
+LPWSTR
+WINAPI
+GetCommandLineW(VOID)
 {
-       if (bCommandLineInitialized == FALSE)
-       {
-               InitCommandLines ();
-       }
+    if (bCommandLineInitialized == FALSE)
+    {
+        InitCommandLines();
+    }
 
-       DPRINT ("CommandLine \'%S\'\n", CommandLineStringW.Buffer);
+    DPRINT("CommandLine \'%S\'\n", CommandLineStringW.Buffer);
 
-       return(CommandLineStringW.Buffer);
+    return CommandLineStringW.Buffer;
 }
 
 /* EOF */
index 4a066ef..43a77c9 100644 (file)
@@ -27,31 +27,32 @@ WINAPI
 CreateJobObjectA(LPSECURITY_ATTRIBUTES lpJobAttributes,
                  LPCSTR lpName)
 {
-  HANDLE hJob;
-  ANSI_STRING AnsiName;
-  UNICODE_STRING UnicodeName;
+    HANDLE hJob;
+    ANSI_STRING AnsiName;
+    UNICODE_STRING UnicodeName;
 
-  if(lpName != NULL)
-  {
-    NTSTATUS Status;
-
-    RtlInitAnsiString(&AnsiName, lpName);
-    Status = RtlAnsiStringToUnicodeString(&UnicodeName, &AnsiName, TRUE);
-    if(!NT_SUCCESS(Status))
+    if (lpName != NULL)
     {
-      SetLastErrorByStatus(Status);
-      return FALSE;
+        NTSTATUS Status;
+
+        RtlInitAnsiString(&AnsiName, lpName);
+        Status = RtlAnsiStringToUnicodeString(&UnicodeName, &AnsiName, TRUE);
+        if (!NT_SUCCESS(Status))
+        {
+            SetLastErrorByStatus(Status);
+            return FALSE;
+        }
     }
-  }
 
-  hJob = CreateJobObjectW(lpJobAttributes,
-                          ((lpName != NULL) ? UnicodeName.Buffer : NULL));
+    hJob = CreateJobObjectW(lpJobAttributes,
+                            ((lpName != NULL) ? UnicodeName.Buffer : NULL));
 
-  if(lpName != NULL)
-  {
-    RtlFreeUnicodeString(&UnicodeName);
-  }
-  return hJob;
+    if (lpName != NULL)
+    {
+        RtlFreeUnicodeString(&UnicodeName);
+    }
+
+    return hJob;
 }
 
 
@@ -63,47 +64,48 @@ WINAPI
 CreateJobObjectW(LPSECURITY_ATTRIBUTES lpJobAttributes,
                  LPCWSTR lpName)
 {
-  UNICODE_STRING JobName;
-  OBJECT_ATTRIBUTES ObjectAttributes;
-  ULONG Attributes = 0;
-  PVOID SecurityDescriptor;
-  HANDLE hJob;
-  NTSTATUS Status;
-
-  if(lpName != NULL)
-  {
-    RtlInitUnicodeString(&JobName, lpName);
-  }
+    UNICODE_STRING JobName;
+    OBJECT_ATTRIBUTES ObjectAttributes;
+    ULONG Attributes = 0;
+    PVOID SecurityDescriptor;
+    HANDLE hJob;
+    NTSTATUS Status;
 
-  if(lpJobAttributes != NULL)
-  {
-    if(lpJobAttributes->bInheritHandle)
+    if (lpName != NULL)
     {
-      Attributes |= OBJ_INHERIT;
+        RtlInitUnicodeString(&JobName, lpName);
     }
-    SecurityDescriptor = lpJobAttributes->lpSecurityDescriptor;
-  }
-  else
-  {
-    SecurityDescriptor = NULL;
-  }
-
-  InitializeObjectAttributes(&ObjectAttributes,
-                             ((lpName != NULL) ? &JobName : NULL),
-                             Attributes,
-                             NULL,
-                             SecurityDescriptor);
-
-  Status = NtCreateJobObject(&hJob,
-                             JOB_OBJECT_ALL_ACCESS,
-                             &ObjectAttributes);
-  if(!NT_SUCCESS(Status))
-  {
-    SetLastErrorByStatus(Status);
-    return NULL;
-  }
 
-  return hJob;
+    if (lpJobAttributes != NULL)
+    {
+        if (lpJobAttributes->bInheritHandle)
+        {
+            Attributes |= OBJ_INHERIT;
+        }
+
+        SecurityDescriptor = lpJobAttributes->lpSecurityDescriptor;
+    }
+    else
+    {
+        SecurityDescriptor = NULL;
+    }
+
+    InitializeObjectAttributes(&ObjectAttributes,
+                               ((lpName != NULL) ? &JobName : NULL),
+                               Attributes,
+                               NULL,
+                               SecurityDescriptor);
+
+    Status = NtCreateJobObject(&hJob,
+                               JOB_OBJECT_ALL_ACCESS,
+                               &ObjectAttributes);
+    if (!NT_SUCCESS(Status))
+    {
+        SetLastErrorByStatus(Status);
+        return NULL;
+    }
+
+    return hJob;
 }
 
 
@@ -116,36 +118,35 @@ OpenJobObjectW(DWORD dwDesiredAccess,
                BOOL bInheritHandle,
                LPCWSTR lpName)
 {
-  OBJECT_ATTRIBUTES ObjectAttributes;
-  UNICODE_STRING JobName;
-  HANDLE hJob;
-  NTSTATUS Status;
-
-  if(lpName == NULL)
-  {
-    SetLastError(ERROR_INVALID_PARAMETER);
-    return NULL;
-  }
-
-  RtlInitUnicodeString(&JobName, lpName);
-
-  InitializeObjectAttributes(&ObjectAttributes,
-                             &JobName,
-                             (bInheritHandle ? OBJ_INHERIT : 0),
-                             NULL,
-                             NULL);
-
-  Status = NtOpenJobObject(&hJob,
-                           dwDesiredAccess,
-                           &ObjectAttributes);
-
-  if(!NT_SUCCESS(Status))
-  {
-    SetLastErrorByStatus(Status);
-    return NULL;
-  }
+    OBJECT_ATTRIBUTES ObjectAttributes;
+    UNICODE_STRING JobName;
+    HANDLE hJob;
+    NTSTATUS Status;
 
-  return hJob;
+    if (lpName == NULL)
+    {
+        SetLastError(ERROR_INVALID_PARAMETER);
+        return NULL;
+    }
+
+    RtlInitUnicodeString(&JobName, lpName);
+
+    InitializeObjectAttributes(&ObjectAttributes,
+                               &JobName,
+                               (bInheritHandle ? OBJ_INHERIT : 0),
+                               NULL,
+                               NULL);
+
+    Status = NtOpenJobObject(&hJob,
+                             dwDesiredAccess,
+                             &ObjectAttributes);
+    if (!NT_SUCCESS(Status))
+    {
+        SetLastErrorByStatus(Status);
+        return NULL;
+    }
+
+    return hJob;
 }
 
 
@@ -158,31 +159,31 @@ OpenJobObjectA(DWORD dwDesiredAccess,
                BOOL bInheritHandle,
                LPCSTR lpName)
 {
-  ANSI_STRING AnsiName;
-  UNICODE_STRING UnicodeName;
-  HANDLE hJob;
-  NTSTATUS Status;
-
-  if(lpName == NULL)
-  {
-    SetLastError(ERROR_INVALID_PARAMETER);
-    return NULL;
-  }
-
-  RtlInitAnsiString(&AnsiName, lpName);
-  Status = RtlAnsiStringToUnicodeString(&UnicodeName, &AnsiName, TRUE);
-  if(!NT_SUCCESS(Status))
-  {
-    SetLastErrorByStatus(Status);
-    return FALSE;
-  }
+    ANSI_STRING AnsiName;
+    UNICODE_STRING UnicodeName;
+    HANDLE hJob;
+    NTSTATUS Status;
 
-  hJob = OpenJobObjectW(dwDesiredAccess,
-                        bInheritHandle,
-                        UnicodeName.Buffer);
+    if (lpName == NULL)
+    {
+        SetLastError(ERROR_INVALID_PARAMETER);
+        return NULL;
+    }
+
+    RtlInitAnsiString(&AnsiName, lpName);
+    Status = RtlAnsiStringToUnicodeString(&UnicodeName, &AnsiName, TRUE);
+    if (!NT_SUCCESS(Status))
+    {
+        SetLastErrorByStatus(Status);
+        return FALSE;
+    }
+
+    hJob = OpenJobObjectW(dwDesiredAccess,
+                          bInheritHandle,
+                          UnicodeName.Buffer);
 
-  RtlFreeUnicodeString(&UnicodeName);
-  return hJob;
+    RtlFreeUnicodeString(&UnicodeName);
+    return hJob;
 }
 
 
@@ -195,17 +196,17 @@ IsProcessInJob(HANDLE ProcessHandle,
                HANDLE JobHandle,
                PBOOL Result)
 {
-  NTSTATUS Status;
+    NTSTATUS Status;
 
-  Status = NtIsProcessInJob(ProcessHandle, JobHandle);
-  if(NT_SUCCESS(Status))
-  {
-    *Result = (Status == STATUS_PROCESS_IN_JOB);
-    return TRUE;
-  }
+    Status = NtIsProcessInJob(ProcessHandle, JobHandle);
+    if (NT_SUCCESS(Status))
+    {
+        *Result = (Status == STATUS_PROCESS_IN_JOB);
+        return TRUE;
+    }
 
-  SetLastErrorByStatus(Status);
-  return FALSE;
+    SetLastErrorByStatus(Status);
+    return FALSE;
 }
 
 
@@ -217,15 +218,16 @@ WINAPI
 AssignProcessToJobObject(HANDLE hJob,
                          HANDLE hProcess)
 {
-  NTSTATUS Status;
+    NTSTATUS Status;
 
-  Status = NtAssignProcessToJobObject(hJob, hProcess);
-  if(!NT_SUCCESS(Status))
-  {
-    SetLastErrorByStatus(Status);
-    return FALSE;
-  }
-  return TRUE;
+    Status = NtAssignProcessToJobObject(hJob, hProcess);
+    if (!NT_SUCCESS(Status))
+    {
+        SetLastErrorByStatus(Status);
+        return FALSE;
+    }
+
+    return TRUE;
 }
 
 
@@ -240,66 +242,74 @@ QueryInformationJobObject(HANDLE hJob,
                           DWORD cbJobObjectInformationLength,
                           LPDWORD lpReturnLength)
 {
-  NTSTATUS Status;
-
-  Status = NtQueryInformationJobObject(hJob,
-                                       JobObjectInformationClass,
-                                       lpJobObjectInformation,
-                                       cbJobObjectInformationLength,
-                                       lpReturnLength);
-  if(NT_SUCCESS(Status))
-  {
-    PJOBOBJECT_BASIC_LIMIT_INFORMATION BasicInfo;
-    switch(JobObjectInformationClass)
-    {
-      case JobObjectBasicLimitInformation:
-        BasicInfo = (PJOBOBJECT_BASIC_LIMIT_INFORMATION)lpJobObjectInformation;
-        break;
-      case JobObjectExtendedLimitInformation:
-        BasicInfo = &((PJOBOBJECT_EXTENDED_LIMIT_INFORMATION)lpJobObjectInformation)->BasicLimitInformation;
-        break;
-
-      default:
-        BasicInfo = NULL;
-        break;
-    }
+    NTSTATUS Status;
 
-    if(BasicInfo != NULL)
+    Status = NtQueryInformationJobObject(hJob,
+                                         JobObjectInformationClass,
+                                         lpJobObjectInformation,
+                                         cbJobObjectInformationLength,
+                                         lpReturnLength);
+    if (NT_SUCCESS(Status))
     {
-      /* we need to convert the process priority classes in the
-         JOBOBJECT_BASIC_LIMIT_INFORMATION structure the same way as
-         GetPriorityClass() converts it! */
-      switch(BasicInfo->PriorityClass)
-      {
-        case PROCESS_PRIORITY_CLASS_IDLE:
-          BasicInfo->PriorityClass = IDLE_PRIORITY_CLASS;
-          break;
-        case PROCESS_PRIORITY_CLASS_BELOW_NORMAL:
-          BasicInfo->PriorityClass = BELOW_NORMAL_PRIORITY_CLASS;
-          break;
-        case PROCESS_PRIORITY_CLASS_NORMAL:
-          BasicInfo->PriorityClass = NORMAL_PRIORITY_CLASS;
-          break;
-        case PROCESS_PRIORITY_CLASS_ABOVE_NORMAL:
-          BasicInfo->PriorityClass = ABOVE_NORMAL_PRIORITY_CLASS;
-          break;
-        case PROCESS_PRIORITY_CLASS_HIGH:
-          BasicInfo->PriorityClass = HIGH_PRIORITY_CLASS;
-          break;
-        case PROCESS_PRIORITY_CLASS_REALTIME:
-          BasicInfo->PriorityClass = REALTIME_PRIORITY_CLASS;
-          break;
-        default:
-          BasicInfo->PriorityClass = NORMAL_PRIORITY_CLASS;
-          break;
-      }
+        PJOBOBJECT_BASIC_LIMIT_INFORMATION BasicInfo;
+
+        switch (JobObjectInformationClass)
+        {
+            case JobObjectBasicLimitInformation:
+                BasicInfo = (PJOBOBJECT_BASIC_LIMIT_INFORMATION)lpJobObjectInformation;
+                break;
+
+            case JobObjectExtendedLimitInformation:
+                BasicInfo = &((PJOBOBJECT_EXTENDED_LIMIT_INFORMATION)lpJobObjectInformation)->BasicLimitInformation;
+                break;
+
+            default:
+                BasicInfo = NULL;
+                break;
+        }
+
+        if (BasicInfo != NULL)
+        {
+            /* we need to convert the process priority classes in the
+               JOBOBJECT_BASIC_LIMIT_INFORMATION structure the same way as
+               GetPriorityClass() converts it! */
+            switch (BasicInfo->PriorityClass)
+            {
+                case PROCESS_PRIORITY_CLASS_IDLE:
+                    BasicInfo->PriorityClass = IDLE_PRIORITY_CLASS;
+                    break;
+
+                case PROCESS_PRIORITY_CLASS_BELOW_NORMAL:
+                    BasicInfo->PriorityClass = BELOW_NORMAL_PRIORITY_CLASS;
+                    break;
+
+                case PROCESS_PRIORITY_CLASS_NORMAL:
+                    BasicInfo->PriorityClass = NORMAL_PRIORITY_CLASS;
+                    break;
+
+                case PROCESS_PRIORITY_CLASS_ABOVE_NORMAL:
+                    BasicInfo->PriorityClass = ABOVE_NORMAL_PRIORITY_CLASS;
+                    break;
+
+                case PROCESS_PRIORITY_CLASS_HIGH:
+                    BasicInfo->PriorityClass = HIGH_PRIORITY_CLASS;
+                    break;
+
+                case PROCESS_PRIORITY_CLASS_REALTIME:
+                    BasicInfo->PriorityClass = REALTIME_PRIORITY_CLASS;
+                    break;
+
+                default:
+                    BasicInfo->PriorityClass = NORMAL_PRIORITY_CLASS;
+                    break;
+            }
+        }
+
+        return TRUE;
     }
 
-    return TRUE;
-  }
-
-  SetLastErrorByStatus(Status);
-  return FALSE;
+    SetLastErrorByStatus(Status);
+    return FALSE;
 }
 
 
@@ -313,83 +323,91 @@ SetInformationJobObject(HANDLE hJob,
                         LPVOID lpJobObjectInformation,
                         DWORD cbJobObjectInformationLength)
 {
-  JOBOBJECT_EXTENDED_LIMIT_INFORMATION ExtendedLimitInfo;
-  PJOBOBJECT_BASIC_LIMIT_INFORMATION BasicInfo;
-  PVOID ObjectInfo;
-  NTSTATUS Status;
-
-  switch(JobObjectInformationClass)
-  {
-    case JobObjectBasicLimitInformation:
-      if(cbJobObjectInformationLength != sizeof(JOBOBJECT_BASIC_LIMIT_INFORMATION))
-      {
-        SetLastError(ERROR_BAD_LENGTH);
-        return FALSE;
-      }
-      ObjectInfo = &ExtendedLimitInfo.BasicLimitInformation;
-      BasicInfo = (PJOBOBJECT_BASIC_LIMIT_INFORMATION)ObjectInfo;
-      RtlCopyMemory(ObjectInfo, lpJobObjectInformation, cbJobObjectInformationLength);
-      break;
-
-    case JobObjectExtendedLimitInformation:
-      if(cbJobObjectInformationLength != sizeof(JOBOBJECT_EXTENDED_LIMIT_INFORMATION))
-      {
-        SetLastError(ERROR_BAD_LENGTH);
-        return FALSE;
-      }
-      ObjectInfo = &ExtendedLimitInfo;
-      BasicInfo = &ExtendedLimitInfo.BasicLimitInformation;
-      RtlCopyMemory(ObjectInfo, lpJobObjectInformation, cbJobObjectInformationLength);
-      break;
-
-    default:
-      ObjectInfo = lpJobObjectInformation;
-      BasicInfo = NULL;
-      break;
-  }
-
-  if(BasicInfo != NULL)
-  {
-    /* we need to convert the process priority classes in the
-       JOBOBJECT_BASIC_LIMIT_INFORMATION structure the same way as
-       SetPriorityClass() converts it! */
-    switch(BasicInfo->PriorityClass)
+    JOBOBJECT_EXTENDED_LIMIT_INFORMATION ExtendedLimitInfo;
+    PJOBOBJECT_BASIC_LIMIT_INFORMATION BasicInfo;
+    PVOID ObjectInfo;
+    NTSTATUS Status;
+
+    switch (JobObjectInformationClass)
     {
-      case IDLE_PRIORITY_CLASS:
-        BasicInfo->PriorityClass = PROCESS_PRIORITY_CLASS_IDLE;
-        break;
-      case BELOW_NORMAL_PRIORITY_CLASS:
-        BasicInfo->PriorityClass = PROCESS_PRIORITY_CLASS_BELOW_NORMAL;
-        break;
-      case NORMAL_PRIORITY_CLASS:
-        BasicInfo->PriorityClass = PROCESS_PRIORITY_CLASS_NORMAL;
-        break;
-      case ABOVE_NORMAL_PRIORITY_CLASS:
-        BasicInfo->PriorityClass = PROCESS_PRIORITY_CLASS_ABOVE_NORMAL;
-        break;
-      case HIGH_PRIORITY_CLASS:
-        BasicInfo->PriorityClass = PROCESS_PRIORITY_CLASS_HIGH;
-        break;
-      case REALTIME_PRIORITY_CLASS:
-        BasicInfo->PriorityClass = PROCESS_PRIORITY_CLASS_REALTIME;
-        break;
-      default:
-        BasicInfo->PriorityClass = PROCESS_PRIORITY_CLASS_NORMAL;
-        break;
+        case JobObjectBasicLimitInformation:
+            if (cbJobObjectInformationLength != sizeof(JOBOBJECT_BASIC_LIMIT_INFORMATION))
+            {
+                SetLastError(ERROR_BAD_LENGTH);
+                return FALSE;
+            }
+
+            ObjectInfo = &ExtendedLimitInfo.BasicLimitInformation;
+            BasicInfo = (PJOBOBJECT_BASIC_LIMIT_INFORMATION)ObjectInfo;
+            RtlCopyMemory(ObjectInfo, lpJobObjectInformation, cbJobObjectInformationLength);
+            break;
+
+        case JobObjectExtendedLimitInformation:
+            if (cbJobObjectInformationLength != sizeof(JOBOBJECT_EXTENDED_LIMIT_INFORMATION))
+            {
+                SetLastError(ERROR_BAD_LENGTH);
+                return FALSE;
+            }
+
+            ObjectInfo = &ExtendedLimitInfo;
+            BasicInfo = &ExtendedLimitInfo.BasicLimitInformation;
+            RtlCopyMemory(ObjectInfo, lpJobObjectInformation, cbJobObjectInformationLength);
+            break;
+
+        default:
+            ObjectInfo = lpJobObjectInformation;
+            BasicInfo = NULL;
+            break;
+    }
+
+    if (BasicInfo != NULL)
+    {
+        /* we need to convert the process priority classes in the
+           JOBOBJECT_BASIC_LIMIT_INFORMATION structure the same way as
+           SetPriorityClass() converts it! */
+        switch(BasicInfo->PriorityClass)
+        {
+            case IDLE_PRIORITY_CLASS:
+                BasicInfo->PriorityClass = PROCESS_PRIORITY_CLASS_IDLE;
+                break;
+
+            case BELOW_NORMAL_PRIORITY_CLASS:
+                BasicInfo->PriorityClass = PROCESS_PRIORITY_CLASS_BELOW_NORMAL;
+                break;
+
+            case NORMAL_PRIORITY_CLASS:
+                BasicInfo->PriorityClass = PROCESS_PRIORITY_CLASS_NORMAL;
+                break;
+
+            case ABOVE_NORMAL_PRIORITY_CLASS:
+                BasicInfo->PriorityClass = PROCESS_PRIORITY_CLASS_ABOVE_NORMAL;
+                break;
+
+            case HIGH_PRIORITY_CLASS:
+                BasicInfo->PriorityClass = PROCESS_PRIORITY_CLASS_HIGH;
+                break;
+
+            case REALTIME_PRIORITY_CLASS:
+                BasicInfo->PriorityClass = PROCESS_PRIORITY_CLASS_REALTIME;
+                break;
+
+            default:
+                BasicInfo->PriorityClass = PROCESS_PRIORITY_CLASS_NORMAL;
+                break;
+        }
+    }
+
+    Status = NtSetInformationJobObject(hJob,
+                                       JobObjectInformationClass,
+                                       ObjectInfo,
+                                       cbJobObjectInformationLength);
+    if (!NT_SUCCESS(Status))
+    {
+        SetLastErrorByStatus(Status);
+        return FALSE;
     }
-  }
-
-  Status = NtSetInformationJobObject(hJob,
-                                     JobObjectInformationClass,
-                                     ObjectInfo,
-                                     cbJobObjectInformationLength);
-  if(!NT_SUCCESS(Status))
-  {
-    SetLastErrorByStatus(Status);
-    return FALSE;
-  }
 
-  return TRUE;
+    return TRUE;
 }
 
 
@@ -401,17 +419,16 @@ WINAPI
 TerminateJobObject(HANDLE hJob,
                    UINT uExitCode)
 {
-  NTSTATUS Status;
+    NTSTATUS Status;
 
-  Status = NtTerminateJobObject(hJob, uExitCode);
-  if(!NT_SUCCESS(Status))
-  {
-    SetLastErrorByStatus(Status);
-    return FALSE;
-  }
+    Status = NtTerminateJobObject(hJob, uExitCode);
+    if (!NT_SUCCESS(Status))
+    {
+        SetLastErrorByStatus(Status);
+        return FALSE;
+    }
 
-  return TRUE;
+    return TRUE;
 }
 
-
 /* EOF */
index 65fd6bb..d6055a6 100644 (file)
@@ -33,275 +33,286 @@ RegisterWaitForInputIdle(WaitForInputIdleType lpfnRegisterWaitForInputIdle);
 /*
  * @implemented
  */
-BOOL WINAPI
-GetProcessAffinityMask (HANDLE hProcess,
-                       LPDWORD lpProcessAffinityMask,
-                       LPDWORD lpSystemAffinityMask)
+BOOL
+WINAPI
+GetProcessAffinityMask(HANDLE hProcess,
+                       LPDWORD lpProcessAffinityMask,
+                       LPDWORD lpSystemAffinityMask)
 {
-  PROCESS_BASIC_INFORMATION ProcessInfo;
-  SYSTEM_BASIC_INFORMATION SystemInfo;
-  NTSTATUS Status;
+    PROCESS_BASIC_INFORMATION ProcessInfo;
+    SYSTEM_BASIC_INFORMATION SystemInfo;
+    NTSTATUS Status;
 
-  Status = NtQuerySystemInformation(SystemBasicInformation,
-                                    &SystemInfo,
-                                    sizeof(SystemInfo),
-                                    NULL);
-  if (!NT_SUCCESS(Status))
+    Status = NtQuerySystemInformation(SystemBasicInformation,
+                                      &SystemInfo,
+                                      sizeof(SystemInfo),
+                                      NULL);
+    if (!NT_SUCCESS(Status))
     {
-      SetLastErrorByStatus (Status);
-      return FALSE;
+        SetLastErrorByStatus(Status);
+        return FALSE;
     }
 
-  Status = NtQueryInformationProcess (hProcess,
-                                     ProcessBasicInformation,
-                                     (PVOID)&ProcessInfo,
-                                     sizeof(PROCESS_BASIC_INFORMATION),
-                                     NULL);
-  if (!NT_SUCCESS(Status))
+    Status = NtQueryInformationProcess(hProcess,
+                                       ProcessBasicInformation,
+                                       (PVOID)&ProcessInfo,
+                                       sizeof(PROCESS_BASIC_INFORMATION),
+                                       NULL);
+    if (!NT_SUCCESS(Status))
     {
-      SetLastErrorByStatus (Status);
-      return FALSE;
+        SetLastErrorByStatus(Status);
+        return FALSE;
     }
 
-  *lpProcessAffinityMask = (DWORD)ProcessInfo.AffinityMask;
-  *lpSystemAffinityMask = (DWORD)SystemInfo.ActiveProcessorsAffinityMask;
+    *lpProcessAffinityMask = (DWORD)ProcessInfo.AffinityMask;
+    *lpSystemAffinityMask = (DWORD)SystemInfo.ActiveProcessorsAffinityMask;
 
-  return TRUE;
+    return TRUE;
 }
 
 
 /*
  * @implemented
  */
-BOOL WINAPI
-SetProcessAffinityMask (HANDLE hProcess,
-                       DWORD dwProcessAffinityMask)
+BOOL
+WINAPI
+SetProcessAffinityMask(HANDLE hProcess,
+                       DWORD dwProcessAffinityMask)
 {
-  NTSTATUS Status;
+    NTSTATUS Status;
 
-  Status = NtSetInformationProcess (hProcess,
-                                   ProcessAffinityMask,
-                                   (PVOID)&dwProcessAffinityMask,
-                                   sizeof(DWORD));
-  if (!NT_SUCCESS(Status))
+    Status = NtSetInformationProcess(hProcess,
+                                     ProcessAffinityMask,
+                                     (PVOID)&dwProcessAffinityMask,
+                                     sizeof(DWORD));
+    if (!NT_SUCCESS(Status))
     {
-      SetLastErrorByStatus (Status);
-      return FALSE;
+        SetLastErrorByStatus(Status);
+        return FALSE;
     }
 
-  return TRUE;
+    return TRUE;
 }
 
 
 /*
  * @implemented
  */
-BOOL WINAPI
-GetProcessShutdownParameters (LPDWORD lpdwLevel,
-                             LPDWORD lpdwFlags)
+BOOL
+WINAPI
+GetProcessShutdownParameters(LPDWORD lpdwLevel,
+                             LPDWORD lpdwFlags)
 {
-  CSR_API_MESSAGE CsrRequest;
-  ULONG Request;
-  NTSTATUS Status;
+    CSR_API_MESSAGE CsrRequest;
+    ULONG Request;
+    NTSTATUS Status;
 
-  Request = GET_SHUTDOWN_PARAMETERS;
-  Status = CsrClientCallServer(&CsrRequest,
-                              NULL,
-                   MAKE_CSR_API(Request, CSR_NATIVE),
-                              sizeof(CSR_API_MESSAGE));
-  if (!NT_SUCCESS(Status) || !NT_SUCCESS(CsrRequest.Status))
+    Request = GET_SHUTDOWN_PARAMETERS;
+    Status = CsrClientCallServer(&CsrRequest,
+                                 NULL,
+                                 MAKE_CSR_API(Request, CSR_NATIVE),
+                                 sizeof(CSR_API_MESSAGE));
+    if (!NT_SUCCESS(Status) || !NT_SUCCESS(CsrRequest.Status))
     {
-      SetLastErrorByStatus (Status);
-      return(FALSE);
+        SetLastErrorByStatus(Status);
+        return FALSE;
     }
 
-  *lpdwLevel = CsrRequest.Data.GetShutdownParametersRequest.Level;
-  *lpdwFlags = CsrRequest.Data.GetShutdownParametersRequest.Flags;
+    *lpdwLevel = CsrRequest.Data.GetShutdownParametersRequest.Level;
+    *lpdwFlags = CsrRequest.Data.GetShutdownParametersRequest.Flags;
 
-  return(TRUE);
+    return TRUE;
 }
 
 
 /*
  * @implemented
  */
-BOOL WINAPI
-SetProcessShutdownParameters (DWORD dwLevel,
-                             DWORD dwFlags)
+BOOL
+WINAPI
+SetProcessShutdownParameters(DWORD dwLevel,
+                             DWORD dwFlags)
 {
-  CSR_API_MESSAGE CsrRequest;
-  ULONG Request;
-  NTSTATUS Status;
+    CSR_API_MESSAGE CsrRequest;
+    ULONG Request;
+    NTSTATUS Status;
 
-  CsrRequest.Data.SetShutdownParametersRequest.Level = dwLevel;
-  CsrRequest.Data.SetShutdownParametersRequest.Flags = dwFlags;
+    CsrRequest.Data.SetShutdownParametersRequest.Level = dwLevel;
+    CsrRequest.Data.SetShutdownParametersRequest.Flags = dwFlags;
 
-  Request = SET_SHUTDOWN_PARAMETERS;
-  Status = CsrClientCallServer(&CsrRequest,
-                              NULL,
-                              MAKE_CSR_API(Request, CSR_NATIVE),
-                              sizeof(CSR_API_MESSAGE));
-  if (!NT_SUCCESS(Status) || !NT_SUCCESS(CsrRequest.Status))
+    Request = SET_SHUTDOWN_PARAMETERS;
+    Status = CsrClientCallServer(&CsrRequest,
+                                 NULL,
+                                 MAKE_CSR_API(Request, CSR_NATIVE),
+                                 sizeof(CSR_API_MESSAGE));
+    if (!NT_SUCCESS(Status) || !NT_SUCCESS(CsrRequest.Status))
     {
-      SetLastErrorByStatus (Status);
-      return(FALSE);
+        SetLastErrorByStatus(Status);
+        return FALSE;
     }
 
-  return(TRUE);
+    return TRUE;
 }
 
 
 /*
  * @implemented
  */
-BOOL WINAPI
-GetProcessWorkingSetSize (HANDLE hProcess,
-                         PSIZE_T lpMinimumWorkingSetSize,
-                         PSIZE_T lpMaximumWorkingSetSize)
+BOOL
+WINAPI
+GetProcessWorkingSetSize(HANDLE hProcess,
+                         PSIZE_T lpMinimumWorkingSetSize,
+                         PSIZE_T lpMaximumWorkingSetSize)
 {
-  QUOTA_LIMITS QuotaLimits;
-  NTSTATUS Status;
+    QUOTA_LIMITS QuotaLimits;
+    NTSTATUS Status;
 
-  Status = NtQueryInformationProcess(hProcess,
-                                    ProcessQuotaLimits,
-                                    &QuotaLimits,
-                                    sizeof(QUOTA_LIMITS),
-                                    NULL);
-  if (!NT_SUCCESS(Status))
+    Status = NtQueryInformationProcess(hProcess,
+                                       ProcessQuotaLimits,
+                                       &QuotaLimits,
+                                       sizeof(QUOTA_LIMITS),
+                                       NULL);
+    if (!NT_SUCCESS(Status))
     {
-      SetLastErrorByStatus(Status);
-      return(FALSE);
+        SetLastErrorByStatus(Status);
+        return FALSE;
     }
 
-  *lpMinimumWorkingSetSize = QuotaLimits.MinimumWorkingSetSize;
-  *lpMaximumWorkingSetSize = QuotaLimits.MaximumWorkingSetSize;
+    *lpMinimumWorkingSetSize = QuotaLimits.MinimumWorkingSetSize;
+    *lpMaximumWorkingSetSize = QuotaLimits.MaximumWorkingSetSize;
 
-  return(TRUE);
+    return TRUE;
 }
 
 
 /*
  * @implemented
  */
-BOOL WINAPI
+BOOL
+WINAPI
 SetProcessWorkingSetSize(HANDLE hProcess,
-                        SIZE_T dwMinimumWorkingSetSize,
-                        SIZE_T dwMaximumWorkingSetSize)
+                         SIZE_T dwMinimumWorkingSetSize,
+                         SIZE_T dwMaximumWorkingSetSize)
 {
-  QUOTA_LIMITS QuotaLimits;
-  NTSTATUS Status;
+    QUOTA_LIMITS QuotaLimits;
+    NTSTATUS Status;
 
-  QuotaLimits.MinimumWorkingSetSize = dwMinimumWorkingSetSize;
-  QuotaLimits.MaximumWorkingSetSize = dwMaximumWorkingSetSize;
+    QuotaLimits.MinimumWorkingSetSize = dwMinimumWorkingSetSize;
+    QuotaLimits.MaximumWorkingSetSize = dwMaximumWorkingSetSize;
 
-  Status = NtSetInformationProcess(hProcess,
-                                  ProcessQuotaLimits,
-                                  &QuotaLimits,
-                                  sizeof(QUOTA_LIMITS));
-  if (!NT_SUCCESS(Status))
+    Status = NtSetInformationProcess(hProcess,
+                                     ProcessQuotaLimits,
+                                     &QuotaLimits,
+                                     sizeof(QUOTA_LIMITS));
+    if (!NT_SUCCESS(Status))
     {
-      SetLastErrorByStatus(Status);
-      return(FALSE);
+        SetLastErrorByStatus(Status);
+        return FALSE;
     }
 
-  return(TRUE);
+    return TRUE;
 }
 
 
 /*
  * @implemented
  */
-BOOL WINAPI
+BOOL
+WINAPI
 GetProcessTimes(HANDLE hProcess,
-               LPFILETIME lpCreationTime,
-               LPFILETIME lpExitTime,
-               LPFILETIME lpKernelTime,
-               LPFILETIME lpUserTime)
+                LPFILETIME lpCreationTime,
+                LPFILETIME lpExitTime,
+                LPFILETIME lpKernelTime,
+                LPFILETIME lpUserTime)
 {
-  KERNEL_USER_TIMES Kut;
-  NTSTATUS Status;
+    KERNEL_USER_TIMES Kut;
+    NTSTATUS Status;
 
-  Status = NtQueryInformationProcess(hProcess,
-                                    ProcessTimes,
-                                    &Kut,
-                                    sizeof(Kut),
-                                    NULL);
-  if (!NT_SUCCESS(Status))
+    Status = NtQueryInformationProcess(hProcess,
+                                       ProcessTimes,
+                                       &Kut,
+                                       sizeof(Kut),
+                                       NULL);
+    if (!NT_SUCCESS(Status))
     {
-      SetLastErrorByStatus(Status);
-      return(FALSE);
+        SetLastErrorByStatus(Status);
+        return FALSE;
     }
 
-  lpCreationTime->dwLowDateTime = Kut.CreateTime.u.LowPart;
-  lpCreationTime->dwHighDateTime = Kut.CreateTime.u.HighPart;
+    lpCreationTime->dwLowDateTime = Kut.CreateTime.u.LowPart;
+    lpCreationTime->dwHighDateTime = Kut.CreateTime.u.HighPart;
 
-  lpExitTime->dwLowDateTime = Kut.ExitTime.u.LowPart;
-  lpExitTime->dwHighDateTime = Kut.ExitTime.u.HighPart;
+    lpExitTime->dwLowDateTime = Kut.ExitTime.u.LowPart;
+    lpExitTime->dwHighDateTime = Kut.ExitTime.u.HighPart;
 
-  lpKernelTime->dwLowDateTime = Kut.KernelTime.u.LowPart;
-  lpKernelTime->dwHighDateTime = Kut.KernelTime.u.HighPart;
+    lpKernelTime->dwLowDateTime = Kut.KernelTime.u.LowPart;
+    lpKernelTime->dwHighDateTime = Kut.KernelTime.u.HighPart;
 
-  lpUserTime->dwLowDateTime = Kut.UserTime.u.LowPart;
-  lpUserTime->dwHighDateTime = Kut.UserTime.u.HighPart;
+    lpUserTime->dwLowDateTime = Kut.UserTime.u.LowPart;
+    lpUserTime->dwHighDateTime = Kut.UserTime.u.HighPart;
 
-  return(TRUE);
+    return TRUE;
 }
 
 
 /*
  * @implemented
  */
-HANDLE WINAPI
+HANDLE
+WINAPI
 GetCurrentProcess(VOID)
 {
-  return((HANDLE)NtCurrentProcess());
+    return (HANDLE)NtCurrentProcess();
 }
 
 
 /*
  * @implemented
  */
-HANDLE WINAPI
+HANDLE
+WINAPI
 GetCurrentThread(VOID)
 {
-  return((HANDLE)NtCurrentThread());
+    return (HANDLE)NtCurrentThread();
 }
 
 
 /*
  * @implemented
  */
-DWORD WINAPI
+DWORD
+WINAPI
 GetCurrentProcessId(VOID)
 {
-  return((DWORD)GetTeb()->ClientId.UniqueProcess);
+    return (DWORD)GetTeb()->ClientId.UniqueProcess;
 }
 
 
 /*
  * @implemented
  */
-BOOL WINAPI
+BOOL
+WINAPI
 GetExitCodeProcess(HANDLE hProcess,
-                  LPDWORD lpExitCode)
+                   LPDWORD lpExitCode)
 {
-  PROCESS_BASIC_INFORMATION ProcessBasic;
-  NTSTATUS Status;
+    PROCESS_BASIC_INFORMATION ProcessBasic;
+    NTSTATUS Status;
 
-  Status = NtQueryInformationProcess(hProcess,
-                                    ProcessBasicInformation,
-                                    &ProcessBasic,
-                                    sizeof(PROCESS_BASIC_INFORMATION),
-                                    NULL);
-  if (!NT_SUCCESS(Status))
+    Status = NtQueryInformationProcess(hProcess,
+                                       ProcessBasicInformation,
+                                       &ProcessBasic,
+                                       sizeof(PROCESS_BASIC_INFORMATION),
+                                       NULL);
+    if (!NT_SUCCESS(Status))
     {
-      SetLastErrorByStatus(Status);
-      return(FALSE);
-     }
+        SetLastErrorByStatus(Status);
+        return FALSE;
+    }
 
-  *lpExitCode = (DWORD)ProcessBasic.ExitStatus;
+    *lpExitCode = (DWORD)ProcessBasic.ExitStatus;
 
-  return(TRUE);
+    return TRUE;
 }
 
 
@@ -312,226 +323,230 @@ DWORD
 WINAPI
 GetProcessId(HANDLE Process)
 {
-  PROCESS_BASIC_INFORMATION ProcessBasic;
-  NTSTATUS Status;
+    PROCESS_BASIC_INFORMATION ProcessBasic;
+    NTSTATUS Status;
 
-  Status = NtQueryInformationProcess(Process,
-                                    ProcessBasicInformation,
-                                    &ProcessBasic,
-                                    sizeof(PROCESS_BASIC_INFORMATION),
-                                    NULL);
-  if (!NT_SUCCESS(Status))
-  {
-    SetLastErrorByStatus(Status);
-    return 0;
-  }
+    Status = NtQueryInformationProcess(Process,
+                                       ProcessBasicInformation,
+                                       &ProcessBasic,
+                                       sizeof(PROCESS_BASIC_INFORMATION),
+                                       NULL);
+    if (!NT_SUCCESS(Status))
+    {
+        SetLastErrorByStatus(Status);
+        return 0;
+    }
 
-  return (DWORD)ProcessBasic.UniqueProcessId;
+    return (DWORD)ProcessBasic.UniqueProcessId;
 }
 
 
 /*
  * @implemented
  */
-HANDLE WINAPI
+HANDLE
+WINAPI
 OpenProcess(DWORD dwDesiredAccess,
-           BOOL bInheritHandle,
-           DWORD dwProcessId)
+            BOOL bInheritHandle,
+            DWORD dwProcessId)
 {
-   NTSTATUS errCode;
-   HANDLE ProcessHandle;
-   OBJECT_ATTRIBUTES ObjectAttributes;
-   CLIENT_ID ClientId;
-
-   ClientId.UniqueProcess = (HANDLE)dwProcessId;
-   ClientId.UniqueThread = 0;
-
-   InitializeObjectAttributes(&ObjectAttributes,
-                              NULL,
-                              (bInheritHandle ? OBJ_INHERIT : 0),
-                              NULL,
-                              NULL);
-
-   errCode = NtOpenProcess(&ProcessHandle,
-                          dwDesiredAccess,
-                          &ObjectAttributes,
-                          &ClientId);
-   if (!NT_SUCCESS(errCode))
-     {
-       SetLastErrorByStatus (errCode);
-       return NULL;
-     }
-   return ProcessHandle;
+    NTSTATUS errCode;
+    HANDLE ProcessHandle;
+    OBJECT_ATTRIBUTES ObjectAttributes;
+    CLIENT_ID ClientId;
+
+    ClientId.UniqueProcess = (HANDLE)dwProcessId;
+    ClientId.UniqueThread = 0;
+
+    InitializeObjectAttributes(&ObjectAttributes,
+                               NULL,
+                               (bInheritHandle ? OBJ_INHERIT : 0),
+                               NULL,
+                               NULL);
+
+    errCode = NtOpenProcess(&ProcessHandle,
+                            dwDesiredAccess,
+                            &ObjectAttributes,
+                            &ClientId);
+    if (!NT_SUCCESS(errCode))
+    {
+        SetLastErrorByStatus(errCode);
+        return NULL;
+    }
+
+    return ProcessHandle;
 }
 
 
 /*
  * @implemented
  */
-UINT WINAPI
+UINT
+WINAPI
 WinExec(LPCSTR lpCmdLine,
-       UINT uCmdShow)
+        UINT uCmdShow)
 {
-   STARTUPINFOA StartupInfo;
-   PROCESS_INFORMATION  ProcessInformation;
-   DWORD dosErr;
-
-   RtlZeroMemory(&StartupInfo, sizeof(StartupInfo));
-   StartupInfo.cb = sizeof(STARTUPINFOA);
-   StartupInfo.wShowWindow = (WORD)uCmdShow;
-   StartupInfo.dwFlags = 0;
-
-   if (! CreateProcessA(NULL,
-                       (PVOID)lpCmdLine,
-                       NULL,
-                       NULL,
-                       FALSE,
-                       0,
-                       NULL,
-                       NULL,
-                       &StartupInfo,
-                       &ProcessInformation))
-     {
-       dosErr = GetLastError();
-       return dosErr < 32 ? dosErr : ERROR_BAD_FORMAT;
-     }
-   if (NULL != lpfnGlobalRegisterWaitForInputIdle)
-     {
-       lpfnGlobalRegisterWaitForInputIdle (
-         ProcessInformation.hProcess,
-          10000
-       );
-     }
-   NtClose(ProcessInformation.hProcess);
-   NtClose(ProcessInformation.hThread);
-
-   return 33; /* Something bigger than 31 means success. */
+    STARTUPINFOA StartupInfo;
+    PROCESS_INFORMATION  ProcessInformation;
+    DWORD dosErr;
+
+    RtlZeroMemory(&StartupInfo, sizeof(StartupInfo));
+    StartupInfo.cb = sizeof(STARTUPINFOA);
+    StartupInfo.wShowWindow = (WORD)uCmdShow;
+    StartupInfo.dwFlags = 0;
+
+    if (!CreateProcessA(NULL,
+                        (PVOID)lpCmdLine,
+                        NULL,
+                        NULL,
+                        FALSE,
+                        0,
+                        NULL,
+                        NULL,
+                        &StartupInfo,
+                        &ProcessInformation))
+    {
+        dosErr = GetLastError();
+        return dosErr < 32 ? dosErr : ERROR_BAD_FORMAT;
+    }
+
+    if (NULL != lpfnGlobalRegisterWaitForInputIdle)
+    {
+        lpfnGlobalRegisterWaitForInputIdle(ProcessInformation.hProcess,
+                                           10000);
+    }
+
+    NtClose(ProcessInformation.hProcess);
+    NtClose(ProcessInformation.hThread);
+
+    return 33; /* Something bigger than 31 means success. */
 }
 
 
 /*
  * @implemented
  */
-VOID WINAPI
-RegisterWaitForInputIdle (
-       WaitForInputIdleType    lpfnRegisterWaitForInputIdle
-       )
+VOID
+WINAPI
+RegisterWaitForInputIdle(WaitForInputIdleType lpfnRegisterWaitForInputIdle)
 {
-       lpfnGlobalRegisterWaitForInputIdle = lpfnRegisterWaitForInputIdle;
-       return;
+    lpfnGlobalRegisterWaitForInputIdle = lpfnRegisterWaitForInputIdle;
+    return;
 }
 
 /*
  * @implemented
  */
-VOID WINAPI
+VOID
+WINAPI
 GetStartupInfoW(LPSTARTUPINFOW lpStartupInfo)
 {
-  PRTL_USER_PROCESS_PARAMETERS Params;
+    PRTL_USER_PROCESS_PARAMETERS Params;
 
-  if (lpStartupInfo == NULL)
+    if (lpStartupInfo == NULL)
     {
-      SetLastError(ERROR_INVALID_PARAMETER);
-      return;
+        SetLastError(ERROR_INVALID_PARAMETER);
+        return;
     }
 
-  Params = NtCurrentPeb()->ProcessParameters;
-
-  lpStartupInfo->cb = sizeof(STARTUPINFOW);
-  lpStartupInfo->lpDesktop = Params->DesktopInfo.Buffer;
-  lpStartupInfo->lpTitle = Params->WindowTitle.Buffer;
-  lpStartupInfo->dwX = Params->StartingX;
-  lpStartupInfo->dwY = Params->StartingY;
-  lpStartupInfo->dwXSize = Params->CountX;
-  lpStartupInfo->dwYSize = Params->CountY;
-  lpStartupInfo->dwXCountChars = Params->CountCharsX;
-  lpStartupInfo->dwYCountChars = Params->CountCharsY;
-  lpStartupInfo->dwFillAttribute = Params->FillAttribute;
-  lpStartupInfo->dwFlags = Params->WindowFlags;
-  lpStartupInfo->wShowWindow = (WORD)Params->ShowWindowFlags;
-  lpStartupInfo->cbReserved2 = Params->RuntimeData.Length;
-  lpStartupInfo->lpReserved2 = (LPBYTE)Params->RuntimeData.Buffer;
-  
-  lpStartupInfo->hStdInput = Params->StandardInput;
-  lpStartupInfo->hStdOutput = Params->StandardOutput;
-  lpStartupInfo->hStdError = Params->StandardError;
+    Params = NtCurrentPeb()->ProcessParameters;
+
+    lpStartupInfo->cb = sizeof(STARTUPINFOW);
+    lpStartupInfo->lpDesktop = Params->DesktopInfo.Buffer;
+    lpStartupInfo->lpTitle = Params->WindowTitle.Buffer;
+    lpStartupInfo->dwX = Params->StartingX;
+    lpStartupInfo->dwY = Params->StartingY;
+    lpStartupInfo->dwXSize = Params->CountX;
+    lpStartupInfo->dwYSize = Params->CountY;
+    lpStartupInfo->dwXCountChars = Params->CountCharsX;
+    lpStartupInfo->dwYCountChars = Params->CountCharsY;
+    lpStartupInfo->dwFillAttribute = Params->FillAttribute;
+    lpStartupInfo->dwFlags = Params->WindowFlags;
+    lpStartupInfo->wShowWindow = (WORD)Params->ShowWindowFlags;
+    lpStartupInfo->cbReserved2 = Params->RuntimeData.Length;
+    lpStartupInfo->lpReserved2 = (LPBYTE)Params->RuntimeData.Buffer;
+
+    lpStartupInfo->hStdInput = Params->StandardInput;
+    lpStartupInfo->hStdOutput = Params->StandardOutput;
+    lpStartupInfo->hStdError = Params->StandardError;
 }
 
 
 /*
  * @implemented
  */
-VOID WINAPI
+VOID
+WINAPI
 GetStartupInfoA(LPSTARTUPINFOA lpStartupInfo)
 {
-  PRTL_USER_PROCESS_PARAMETERS Params;
-  ANSI_STRING AnsiString;
+    PRTL_USER_PROCESS_PARAMETERS Params;
+    ANSI_STRING AnsiString;
 
-  if (lpStartupInfo == NULL)
+    if (lpStartupInfo == NULL)
     {
-       SetLastError(ERROR_INVALID_PARAMETER);
-       return;
+        SetLastError(ERROR_INVALID_PARAMETER);
+        return;
     }
 
-  Params = NtCurrentPeb ()->ProcessParameters;
+    Params = NtCurrentPeb ()->ProcessParameters;
 
-  RtlAcquirePebLock ();
+    RtlAcquirePebLock ();
 
-  /* FIXME - not thread-safe */
-  if (lpLocalStartupInfo == NULL)
+    /* FIXME - not thread-safe */
+    if (lpLocalStartupInfo == NULL)
     {
-       /* create new local startup info (ansi) */
-       lpLocalStartupInfo = RtlAllocateHeap (RtlGetProcessHeap (),
-                                             0,
-                                             sizeof(STARTUPINFOA));
+        /* create new local startup info (ansi) */
+        lpLocalStartupInfo = RtlAllocateHeap(RtlGetProcessHeap(),
+                                             0,
+                                             sizeof(STARTUPINFOA));
         if (lpLocalStartupInfo == NULL)
         {
-            RtlReleasePebLock ();
+            RtlReleasePebLock();
             SetLastError(ERROR_NOT_ENOUGH_MEMORY);
             return;
         }
 
-       lpLocalStartupInfo->cb = sizeof(STARTUPINFOA);
-
-       /* copy window title string */
-       RtlUnicodeStringToAnsiString (&AnsiString,
-                                     &Params->WindowTitle,
-                                     TRUE);
-       lpLocalStartupInfo->lpTitle = AnsiString.Buffer;
-
-       /* copy desktop info string */
-       RtlUnicodeStringToAnsiString (&AnsiString,
-                                     &Params->DesktopInfo,
-                                     TRUE);
-       lpLocalStartupInfo->lpDesktop = AnsiString.Buffer;
-
-       /* copy shell info string */
-       RtlUnicodeStringToAnsiString (&AnsiString,
-                                     &Params->ShellInfo,
-                                     TRUE);
-       lpLocalStartupInfo->lpReserved = AnsiString.Buffer;
-
-       lpLocalStartupInfo->dwX = Params->StartingX;
-       lpLocalStartupInfo->dwY = Params->StartingY;
-       lpLocalStartupInfo->dwXSize = Params->CountX;
-       lpLocalStartupInfo->dwYSize = Params->CountY;
-       lpLocalStartupInfo->dwXCountChars = Params->CountCharsX;
-       lpLocalStartupInfo->dwYCountChars = Params->CountCharsY;
-       lpLocalStartupInfo->dwFillAttribute = Params->FillAttribute;
-       lpLocalStartupInfo->dwFlags = Params->WindowFlags;
-       lpLocalStartupInfo->wShowWindow = (WORD)Params->ShowWindowFlags;
-       lpLocalStartupInfo->cbReserved2 = Params->RuntimeData.Length;
-       lpLocalStartupInfo->lpReserved2 = (LPBYTE)Params->RuntimeData.Buffer;
-
-       lpLocalStartupInfo->hStdInput = Params->StandardInput;
-       lpLocalStartupInfo->hStdOutput = Params->StandardOutput;
-       lpLocalStartupInfo->hStdError = Params->StandardError;
-     }
-
-   RtlReleasePebLock ();
-
-   /* copy local startup info data to external startup info */
-   memcpy (lpStartupInfo,
+        lpLocalStartupInfo->cb = sizeof(STARTUPINFOA);
+
+        /* copy window title string */
+        RtlUnicodeStringToAnsiString(&AnsiString,
+                                     &Params->WindowTitle,
+                                     TRUE);
+        lpLocalStartupInfo->lpTitle = AnsiString.Buffer;
+
+        /* copy desktop info string */
+        RtlUnicodeStringToAnsiString(&AnsiString,
+                                     &Params->DesktopInfo,
+                                     TRUE);
+        lpLocalStartupInfo->lpDesktop = AnsiString.Buffer;
+
+        /* copy shell info string */
+        RtlUnicodeStringToAnsiString(&AnsiString,
+                                     &Params->ShellInfo,
+                                     TRUE);
+        lpLocalStartupInfo->lpReserved = AnsiString.Buffer;
+
+        lpLocalStartupInfo->dwX = Params->StartingX;
+        lpLocalStartupInfo->dwY = Params->StartingY;
+        lpLocalStartupInfo->dwXSize = Params->CountX;
+        lpLocalStartupInfo->dwYSize = Params->CountY;
+        lpLocalStartupInfo->dwXCountChars = Params->CountCharsX;
+        lpLocalStartupInfo->dwYCountChars = Params->CountCharsY;
+        lpLocalStartupInfo->dwFillAttribute = Params->FillAttribute;
+        lpLocalStartupInfo->dwFlags = Params->WindowFlags;
+        lpLocalStartupInfo->wShowWindow = (WORD)Params->ShowWindowFlags;
+        lpLocalStartupInfo->cbReserved2 = Params->RuntimeData.Length;
+        lpLocalStartupInfo->lpReserved2 = (LPBYTE)Params->RuntimeData.Buffer;
+
+        lpLocalStartupInfo->hStdInput = Params->StandardInput;
+        lpLocalStartupInfo->hStdOutput = Params->StandardOutput;
+        lpLocalStartupInfo->hStdError = Params->StandardError;
+    }
+
+    RtlReleasePebLock();
+
+    /* copy local startup info data to external startup info */
+    memcpy(lpStartupInfo,
            lpLocalStartupInfo,
            sizeof(STARTUPINFOA));
 }
@@ -540,112 +555,118 @@ GetStartupInfoA(LPSTARTUPINFOA lpStartupInfo)
 /*
  * @implemented
  */
-BOOL WINAPI
-FlushInstructionCache (HANDLE  hProcess,
-                      LPCVOID  lpBaseAddress,
-                      DWORD    dwSize)
+BOOL
+WINAPI
+FlushInstructionCache(HANDLE hProcess,
+                      LPCVOID lpBaseAddress,
+                      DWORD dwSize)
 {
-  NTSTATUS Status;
+    NTSTATUS Status;
 
-  Status = NtFlushInstructionCache(hProcess,
-                                  (PVOID)lpBaseAddress,
-                                  dwSize);
-  if (!NT_SUCCESS(Status))
+    Status = NtFlushInstructionCache(hProcess,
+                                     (PVOID)lpBaseAddress,
+                                     dwSize);
+    if (!NT_SUCCESS(Status))
     {
-      SetLastErrorByStatus(Status);
-      return FALSE;
+        SetLastErrorByStatus(Status);
+        return FALSE;
     }
-  return TRUE;
+
+    return TRUE;
 }
 
 
 /*
  * @implemented
  */
-VOID WINAPI
+VOID
+WINAPI
 ExitProcess(UINT uExitCode)
 {
-  CSR_API_MESSAGE CsrRequest;
-  ULONG Request;
-  NTSTATUS Status;
+    CSR_API_MESSAGE CsrRequest;
+    ULONG Request;
+    NTSTATUS Status;
 
-  /* kill sibling threads ... we want to be alone at this point */
-  NtTerminateProcess (NULL, 0);
+    /* kill sibling threads ... we want to be alone at this point */
+    NtTerminateProcess(NULL, 0);
 
-  /* unload all dll's */
-  LdrShutdownProcess ();
+    /* unload all dll's */
+    LdrShutdownProcess();
 
-  /* notify csrss of process termination */
-  Request = TERMINATE_PROCESS;
-  Status = CsrClientCallServer(&CsrRequest,
-                              NULL,
-                   MAKE_CSR_API(Request, CSR_NATIVE),
-                              sizeof(CSR_API_MESSAGE));
-  if (!NT_SUCCESS(Status) || !NT_SUCCESS(CsrRequest.Status))
+    /* notify csrss of process termination */
+    Request = TERMINATE_PROCESS;
+    Status = CsrClientCallServer(&CsrRequest,
+                                 NULL,
+                                 MAKE_CSR_API(Request, CSR_NATIVE),
+                                 sizeof(CSR_API_MESSAGE));
+    if (!NT_SUCCESS(Status) || !NT_SUCCESS(CsrRequest.Status))
     {
-      DPRINT("Failed to tell csrss about terminating process\n");
+        DPRINT("Failed to tell csrss about terminating process\n");
     }
 
+    NtTerminateProcess(NtCurrentProcess (),
+                       uExitCode);
 
-  NtTerminateProcess (NtCurrentProcess (),
-                     uExitCode);
-
-  /* should never get here */
-  ASSERT(0);
-  while(1);
+    /* should never get here */
+    ASSERT(0);
+    while(1);
 }
 
 
 /*
  * @implemented
  */
-BOOL WINAPI
-TerminateProcess (HANDLE       hProcess,
-                 UINT  uExitCode)
+BOOL
+WINAPI
+TerminateProcess(HANDLE hProcess,
+                 UINT uExitCode)
 {
-  NTSTATUS Status;
+    NTSTATUS Status;
 
-  if (hProcess == NULL)
+    if (hProcess == NULL)
     {
       return FALSE;
     }
 
-  Status = NtTerminateProcess (hProcess, uExitCode);
-  if (NT_SUCCESS(Status))
+    Status = NtTerminateProcess(hProcess, uExitCode);
+    if (NT_SUCCESS(Status))
     {
-      return TRUE;
+        return TRUE;
     }
-  SetLastErrorByStatus (Status);
-  return FALSE;
+
+    SetLastErrorByStatus(Status);
+    return FALSE;
 }
 
 
 /*
  * @unimplemented
  */
-VOID WINAPI
+VOID
+WINAPI
 FatalAppExitA(UINT uAction,
-                 LPCSTR lpMessageText)
+              LPCSTR lpMessageText)
 {
-  UNICODE_STRING MessageTextU;
-  ANSI_STRING MessageText;
+    UNICODE_STRING MessageTextU;
+    ANSI_STRING MessageText;
 
-  RtlInitAnsiString (&MessageText, (LPSTR) lpMessageText);
+    RtlInitAnsiString(&MessageText, (LPSTR)lpMessageText);
 
-  RtlAnsiStringToUnicodeString (&MessageTextU,
-                               &MessageText,
-                               TRUE);
+    RtlAnsiStringToUnicodeString(&MessageTextU,
+                                 &MessageText,
+                                 TRUE);
 
-  FatalAppExitW (uAction, MessageTextU.Buffer);
+    FatalAppExitW(uAction, MessageTextU.Buffer);
 
-  RtlFreeUnicodeString (&MessageTextU);
+    RtlFreeUnicodeString(&MessageTextU);
 }
 
 
 /*
  * @unimplemented
  */
-VOID WINAPI
+VOID
+WINAPI
 FatalAppExitW(UINT uAction,
               LPCWSTR lpMessageText)
 {
@@ -657,7 +678,7 @@ FatalAppExitW(UINT uAction,
     DPRINT1("AppExit\n");
 
     if (hModule)
-        pMessageBoxW = (MessageBoxW_Proc) GetProcAddress(hModule, "MessageBoxW");
+        pMessageBoxW = (MessageBoxW_Proc)GetProcAddress(hModule, "MessageBoxW");
 
     if (pMessageBoxW)
         pMessageBoxW(0, lpMessageText, NULL, MB_SYSTEMMODAL | MB_OK);
@@ -671,18 +692,20 @@ FatalAppExitW(UINT uAction,
 /*
  * @implemented
  */
-VOID WINAPI
-FatalExit (int ExitCode)
+VOID
+WINAPI
+FatalExit(int ExitCode)
 {
-  ExitProcess(ExitCode);
+    ExitProcess(ExitCode);
 }
 
 
 /*
  * @implemented
  */
-DWORD WINAPI
-GetPriorityClass (HANDLE hProcess)
+DWORD
+WINAPI
+GetPriorityClass(HANDLE hProcess)
 {
   NTSTATUS Status;
   PROCESS_PRIORITY_CLASS PriorityClass;
@@ -727,65 +750,66 @@ GetPriorityClass (HANDLE hProcess)
 /*
  * @implemented
  */
-BOOL WINAPI
-SetPriorityClass (HANDLE hProcess,
-                 DWORD dwPriorityClass)
+BOOL
+WINAPI
+SetPriorityClass(HANDLE hProcess,
+                 DWORD dwPriorityClass)
 {
-  NTSTATUS Status;
-  PROCESS_PRIORITY_CLASS PriorityClass;
-
-  switch(dwPriorityClass)
-  {
-    case IDLE_PRIORITY_CLASS:
-      PriorityClass.PriorityClass = PROCESS_PRIORITY_CLASS_IDLE;
-      break;
+    NTSTATUS Status;
+    PROCESS_PRIORITY_CLASS PriorityClass;
 
-    case BELOW_NORMAL_PRIORITY_CLASS:
-      PriorityClass.PriorityClass = PROCESS_PRIORITY_CLASS_BELOW_NORMAL;
-      break;
+    switch (dwPriorityClass)
+    {
+        case IDLE_PRIORITY_CLASS:
+            PriorityClass.PriorityClass = PROCESS_PRIORITY_CLASS_IDLE;
+            break;
 
-    case NORMAL_PRIORITY_CLASS:
-      PriorityClass.PriorityClass = PROCESS_PRIORITY_CLASS_NORMAL;
-      break;
+        case BELOW_NORMAL_PRIORITY_CLASS:
+            PriorityClass.PriorityClass = PROCESS_PRIORITY_CLASS_BELOW_NORMAL;
+            break;
 
-    case ABOVE_NORMAL_PRIORITY_CLASS:
-      PriorityClass.PriorityClass = PROCESS_PRIORITY_CLASS_ABOVE_NORMAL;
-      break;
+        case NORMAL_PRIORITY_CLASS:
+            PriorityClass.PriorityClass = PROCESS_PRIORITY_CLASS_NORMAL;
+            break;
 
-    case HIGH_PRIORITY_CLASS:
-      PriorityClass.PriorityClass = PROCESS_PRIORITY_CLASS_HIGH;
-      break;
+        case ABOVE_NORMAL_PRIORITY_CLASS:
+            PriorityClass.PriorityClass = PROCESS_PRIORITY_CLASS_ABOVE_NORMAL;
+            break;
 
-    case REALTIME_PRIORITY_CLASS:
-      PriorityClass.PriorityClass = PROCESS_PRIORITY_CLASS_REALTIME;
-      break;
+        case HIGH_PRIORITY_CLASS:
+            PriorityClass.PriorityClass = PROCESS_PRIORITY_CLASS_HIGH;
+            break;
 
-    default:
-      SetLastError(ERROR_INVALID_PARAMETER);
-      return FALSE;
-  }
+        case REALTIME_PRIORITY_CLASS:
+            PriorityClass.PriorityClass = PROCESS_PRIORITY_CLASS_REALTIME;
+            break;
 
-  PriorityClass.Foreground = FALSE;
+        default:
+            SetLastError(ERROR_INVALID_PARAMETER);
+            return FALSE;
+    }
 
-  Status = NtSetInformationProcess(hProcess,
-                                   ProcessPriorityClass,
-                                   &PriorityClass,
-                                   sizeof(PROCESS_PRIORITY_CLASS));
+    PriorityClass.Foreground = FALSE;
 
-  if(!NT_SUCCESS(Status))
-  {
-    SetLastErrorByStatus(Status);
-    return FALSE;
-  }
+    Status = NtSetInformationProcess(hProcess,
+                                     ProcessPriorityClass,
+                                     &PriorityClass,
+                                     sizeof(PROCESS_PRIORITY_CLASS));
+    if (!NT_SUCCESS(Status))
+    {
+        SetLastErrorByStatus(Status);
+        return FALSE;
+    }
 
-  return TRUE;
+    return TRUE;
 }
 
 
 /*
  * @implemented
  */
-DWORD WINAPI
+DWORD
+WINAPI
 GetProcessVersion(DWORD ProcessId)
 {
     DWORD Version = 0;
@@ -801,17 +825,18 @@ GetProcessVersion(DWORD ProcessId)
 
     _SEH2_TRY
     {
-        /* Caller's */
         if (0 == ProcessId || GetCurrentProcessId() == ProcessId)
         {
+            /* Caller's */
             BaseAddress = (PVOID) NtCurrentPeb()->ImageBaseAddress;
             NtHeader = RtlImageNtHeader(BaseAddress);
 
             Version = (NtHeader->OptionalHeader.MajorOperatingSystemVersion << 16) |
                       (NtHeader->OptionalHeader.MinorOperatingSystemVersion);
         }
-        else /* other process */
+        else
         {
+            /* Other process */
             ProcessHandle = OpenProcess(PROCESS_VM_READ | PROCESS_QUERY_INFORMATION,
                                         FALSE,
                                         ProcessId);
@@ -823,14 +848,16 @@ GetProcessVersion(DWORD ProcessId)
                                                &ProcessBasicInfo,
                                                sizeof(ProcessBasicInfo),
                                                NULL);
-            if (!NT_SUCCESS(Status)) goto Error;
+            if (!NT_SUCCESS(Status))
+                goto Error;
 
             Status = NtReadVirtualMemory(ProcessHandle,
                                          ProcessBasicInfo.PebBaseAddress,
                                          &Peb,
                                          sizeof(Peb),
                                          &Count);
-            if (!NT_SUCCESS(Status) || Count != sizeof(Peb)) goto Error;
+            if (!NT_SUCCESS(Status) || Count != sizeof(Peb))
+                goto Error;
 
             memset(&DosHeader, 0, sizeof(DosHeader));
             Status = NtReadVirtualMemory(ProcessHandle,
@@ -839,8 +866,11 @@ GetProcessVersion(DWORD ProcessId)
                                          sizeof(DosHeader),
                                          &Count);
 
-            if (!NT_SUCCESS(Status) || Count != sizeof(DosHeader)) goto Error;
-            if (DosHeader.e_magic != IMAGE_DOS_SIGNATURE) goto Error;
+            if (!NT_SUCCESS(Status) || Count != sizeof(DosHeader))
+                goto Error;
+
+            if (DosHeader.e_magic != IMAGE_DOS_SIGNATURE)
+                goto Error;
 
             memset(&NtHeaders, 0, sizeof(NtHeaders));
             Status = NtReadVirtualMemory(ProcessHandle,
@@ -849,8 +879,11 @@ GetProcessVersion(DWORD ProcessId)
                                          sizeof(NtHeaders),
                                          &Count);
 
-            if (!NT_SUCCESS(Status) || Count != sizeof(NtHeaders)) goto Error;
-            if (NtHeaders.Signature != IMAGE_NT_SIGNATURE) goto Error;
+            if (!NT_SUCCESS(Status) || Count != sizeof(NtHeaders))
+                goto Error;
+
+            if (NtHeaders.Signature != IMAGE_NT_SIGNATURE)
+                goto Error;
 
             Version = MAKELONG(NtHeaders.OptionalHeader.MinorSubsystemVersion,
                                NtHeaders.OptionalHeader.MajorSubsystemVersion);
@@ -864,7 +897,8 @@ Error:
     }
     _SEH2_FINALLY
     {
-        if (ProcessHandle) CloseHandle(ProcessHandle);
+        if (ProcessHandle)
+            CloseHandle(ProcessHandle);
     }
     _SEH2_END;
 
@@ -877,24 +911,23 @@ Error:
  */
 BOOL
 WINAPI
-GetProcessIoCounters(
-  HANDLE hProcess,
-  PIO_COUNTERS lpIoCounters)
+GetProcessIoCounters(HANDLE hProcess,
+                     PIO_COUNTERS lpIoCounters)
 {
-  NTSTATUS Status;
+    NTSTATUS Status;
 
-  Status = NtQueryInformationProcess(hProcess,
-                                    ProcessIoCounters,
-                                    lpIoCounters,
-                                    sizeof(IO_COUNTERS),
-                                    NULL);
-  if (!NT_SUCCESS(Status))
+    Status = NtQueryInformationProcess(hProcess,
+                                       ProcessIoCounters,
+                                       lpIoCounters,
+                                       sizeof(IO_COUNTERS),
+                                       NULL);
+    if (!NT_SUCCESS(Status))
     {
-      SetLastErrorByStatus(Status);
-      return(FALSE);
+        SetLastErrorByStatus(Status);
+        return FALSE;
     }
 
-  return TRUE;
+    return TRUE;
 }
 
 
@@ -906,22 +939,22 @@ WINAPI
 GetProcessPriorityBoost(HANDLE hProcess,
                         PBOOL pDisablePriorityBoost)
 {
-  NTSTATUS Status;
-  ULONG PriorityBoost;
+    NTSTATUS Status;
+    ULONG PriorityBoost;
 
-  Status = NtQueryInformationProcess(hProcess,
-                                    ProcessPriorityBoost,
-                                    &PriorityBoost,
-                                    sizeof(ULONG),
-                                    NULL);
-  if (NT_SUCCESS(Status))
+    Status = NtQueryInformationProcess(hProcess,
+                                       ProcessPriorityBoost,
+                                       &PriorityBoost,
+                                       sizeof(ULONG),
+                                       NULL);
+    if (NT_SUCCESS(Status))
     {
-      *pDisablePriorityBoost = PriorityBoost;
-      return TRUE;
+        *pDisablePriorityBoost = PriorityBoost;
+        return TRUE;
     }
 
-  SetLastErrorByStatus(Status);
-  return FALSE;
+    SetLastErrorByStatus(Status);
+    return FALSE;
 }
 
 
@@ -933,20 +966,20 @@ WINAPI
 SetProcessPriorityBoost(HANDLE hProcess,
                         BOOL bDisablePriorityBoost)
 {
-  NTSTATUS Status;
-  ULONG PriorityBoost = (bDisablePriorityBoost ? TRUE : FALSE); /* prevent setting values other than 1 and 0 */
+    NTSTATUS Status;
+    ULONG PriorityBoost = (bDisablePriorityBoost ? TRUE : FALSE); /* prevent setting values other than 1 and 0 */
 
-  Status = NtSetInformationProcess(hProcess,
-                                  ProcessPriorityBoost,
-                                  &PriorityBoost,
-                                  sizeof(ULONG));
-  if (!NT_SUCCESS(Status))
+    Status = NtSetInformationProcess(hProcess,
+                                     ProcessPriorityBoost,
+                                     &PriorityBoost,
+                                     sizeof(ULONG));
+    if (!NT_SUCCESS(Status))
     {
-      SetLastErrorByStatus(Status);
-      return FALSE;
+        SetLastErrorByStatus(Status);
+        return FALSE;
     }
 
-  return TRUE;
+    return TRUE;
 }
 
 
@@ -982,10 +1015,8 @@ GetProcessHandleCount(HANDLE hProcess,
  */
 BOOL
 WINAPI
-IsWow64Process(
-    HANDLE hProcess,
-    PBOOL Wow64Process
-    )
+IsWow64Process(HANDLE hProcess,
+               PBOOL Wow64Process)
 {
     ULONG pbi;
     NTSTATUS Status;
@@ -995,7 +1026,6 @@ IsWow64Process(
                                        &pbi,
                                        sizeof(pbi),
                                        NULL);
-
     if (!NT_SUCCESS(Status))
     {
         SetLastError(RtlNtStatusToDosError(Status));
@@ -1003,6 +1033,7 @@ IsWow64Process(
     }
 
     *Wow64Process = (pbi != 0);
+
     return TRUE;
 }
 
@@ -1044,9 +1075,11 @@ QueryFullProcessImageNameW(HANDLE hProcess,
                                            &Needed);
         Result = DynamicBuffer;
     }
-    else Result = (PUNICODE_STRING)Buffer;
+    else
+        Result = (PUNICODE_STRING)Buffer;
 
-    if (!NT_SUCCESS(Status)) goto Cleanup;
+    if (!NT_SUCCESS(Status))
+        goto Cleanup;
 
     if (Result->Length / sizeof(WCHAR) + 1 > *pdwSize)
     {
@@ -1065,6 +1098,7 @@ Cleanup:
     {
         SetLastErrorByStatus(Status);
     }
+
     return !Status;
 }
 
@@ -1101,6 +1135,7 @@ QueryFullProcessImageNameA(HANDLE hProcess,
                                            lpExeName,
                                            *pdwSize,
                                            NULL, NULL));
+
     if (Result)
         *pdwSize = strlen(lpExeName);
 
index 843dc1f..137b4a9 100644 (file)
@@ -294,7 +294,8 @@ BasepDuplicateAndWriteHandle(IN HANDLE ProcessHandle,
            "Address: %p\n", ProcessHandle, StandardHandle, Address);
 
     /* Don't touch Console Handles */
-    if (IsConsoleHandle(StandardHandle)) return;
+    if (IsConsoleHandle(StandardHandle))
+        return;
 
     /* Duplicate the handle */
     Status = NtDuplicateObject(NtCurrentProcess(),
@@ -1017,7 +1018,8 @@ GetAppName:
             CmdLineLength = wcslen(CMD_STRING) + wcslen(lpCommandLine) + 1;
 
             /* If we found quotes, then add them into the length size */
-            if (CmdLineIsAppName || FoundQuotes) CmdLineLength += 2;
+            if (CmdLineIsAppName || FoundQuotes)
+                CmdLineLength += 2;
             CmdLineLength *= sizeof(WCHAR);
 
             /* Allocate space for the new command line */
@@ -1177,7 +1179,7 @@ GetAppName:
                              hSection,
                              hDebug,
                              NULL);
-    if(!NT_SUCCESS(Status))
+    if (!NT_SUCCESS(Status))
     {
         DPRINT1("Unable to create process, status 0x%x\n", Status);
         SetLastErrorByStatus(Status);
@@ -1311,7 +1313,8 @@ GetAppName:
     if(lpEnvironment && !(dwCreationFlags & CREATE_UNICODE_ENVIRONMENT))
     {
         lpEnvironment = BasepConvertUnicodeEnvironment(&EnvSize, lpEnvironment);
-        if (!lpEnvironment) goto Cleanup;
+        if (!lpEnvironment)
+            goto Cleanup;
     }
 
     /* Create Process Environment */
@@ -1419,21 +1422,31 @@ GetAppName:
 
 Cleanup:
     /* De-allocate heap strings */
-    if (NameBuffer) RtlFreeHeap(RtlGetProcessHeap(), 0, NameBuffer);
+    if (NameBuffer)
+        RtlFreeHeap(RtlGetProcessHeap(), 0, NameBuffer);
+
     if (ApplicationName.Buffer)
         RtlFreeHeap(RtlGetProcessHeap(), 0, ApplicationName.Buffer);
-    if (CurrentDirectory) RtlFreeHeap(RtlGetProcessHeap(), 0, CurrentDirectory);
-    if (QuotedCmdLine) RtlFreeHeap(RtlGetProcessHeap(), 0, QuotedCmdLine);
+
+    if (CurrentDirectory)
+        RtlFreeHeap(RtlGetProcessHeap(), 0, CurrentDirectory);
+
+    if (QuotedCmdLine)
+        RtlFreeHeap(RtlGetProcessHeap(), 0, QuotedCmdLine);
 
     /* Kill any handles still alive */
-    if (hSection) NtClose(hSection);
+    if (hSection)
+        NtClose(hSection);
+
     if (hThread)
     {
         /* We don't know any more details then this */
         NtTerminateProcess(hProcess, STATUS_UNSUCCESSFUL);
         NtClose(hThread);
     }
-    if (hProcess) NtClose(hProcess);
+
+    if (hProcess)
+        NtClose(hProcess);
 
     /* Return Success */
     return Ret;
index 75959b5..b006e3c 100644 (file)
@@ -19,11 +19,14 @@ DWORD ActiveConsoleSessionId = 0;
 /*
  * @unimplemented
  */
-DWORD WINAPI
-DosPathToSessionPathW (DWORD SessionID, LPWSTR InPath, LPWSTR * OutPath)
+DWORD
+WINAPI
+DosPathToSessionPathW(DWORD SessionID,
+                      LPWSTR InPath,
+                      LPWSTR *OutPath)
 {
     UNIMPLEMENTED;
-       return 0;
+    return 0;
 }
 
 /*
@@ -39,68 +42,74 @@ DosPathToSessionPathW (DWORD SessionID, LPWSTR InPath, LPWSTR * OutPath)
  *
  * @unimplemented
  */
-DWORD WINAPI
-DosPathToSessionPathA (DWORD SessionId, LPSTR InPath, LPSTR * OutPath)
+DWORD
+WINAPI
+DosPathToSessionPathA(DWORD SessionId,
+                      LPSTR InPath,
+                      LPSTR *OutPath)
 {
-       //DosPathToSessionPathW (SessionId,InPathW,OutPathW);
+    //DosPathToSessionPathW (SessionId,InPathW,OutPathW);
     UNIMPLEMENTED;
-       return 0;
+    return 0;
 }
 
 /*
  * @implemented
  */
-BOOL WINAPI ProcessIdToSessionId (IN  DWORD dwProcessId,
-                                  OUT DWORD* pSessionId)
+BOOL
+WINAPI
+ProcessIdToSessionId(IN DWORD dwProcessId,
+                     OUT DWORD *pSessionId)
 {
-  PROCESS_SESSION_INFORMATION SessionInformation;
-  OBJECT_ATTRIBUTES ObjectAttributes;
-  CLIENT_ID ClientId;
-  HANDLE ProcessHandle;
-  NTSTATUS Status;
+    PROCESS_SESSION_INFORMATION SessionInformation;
+    OBJECT_ATTRIBUTES ObjectAttributes;
+    CLIENT_ID ClientId;
+    HANDLE ProcessHandle;
+    NTSTATUS Status;
 
-  if(IsBadWritePtr(pSessionId, sizeof(DWORD)))
-  {
-    SetLastError(ERROR_INVALID_PARAMETER);
-    return FALSE;
-  }
-
-  ClientId.UniqueProcess = (HANDLE)dwProcessId;
-  ClientId.UniqueThread = 0;
+    if (IsBadWritePtr(pSessionId, sizeof(DWORD)))
+    {
+        SetLastError(ERROR_INVALID_PARAMETER);
+        return FALSE;
+    }
 
-  InitializeObjectAttributes(&ObjectAttributes, NULL, 0, NULL, NULL);
+    ClientId.UniqueProcess = (HANDLE)dwProcessId;
+    ClientId.UniqueThread = 0;
 
-  Status = NtOpenProcess(&ProcessHandle,
-                         PROCESS_QUERY_INFORMATION,
-                         &ObjectAttributes,
-                         &ClientId);
-  if(NT_SUCCESS(Status))
-  {
-    Status = NtQueryInformationProcess(ProcessHandle,
-                                       ProcessSessionInformation,
-                                       &SessionInformation,
-                                       sizeof(SessionInformation),
-                                       NULL);
-    NtClose(ProcessHandle);
+    InitializeObjectAttributes(&ObjectAttributes, NULL, 0, NULL, NULL);
 
-    if(NT_SUCCESS(Status))
+    Status = NtOpenProcess(&ProcessHandle,
+                           PROCESS_QUERY_INFORMATION,
+                           &ObjectAttributes,
+                           &ClientId);
+    if (NT_SUCCESS(Status))
     {
-      *pSessionId = SessionInformation.SessionId;
-      return TRUE;
+        Status = NtQueryInformationProcess(ProcessHandle,
+                                           ProcessSessionInformation,
+                                           &SessionInformation,
+                                           sizeof(SessionInformation),
+                                           NULL);
+        NtClose(ProcessHandle);
+
+        if (NT_SUCCESS(Status))
+        {
+            *pSessionId = SessionInformation.SessionId;
+            return TRUE;
+        }
     }
-  }
 
-  SetLastErrorByStatus(Status);
-  return FALSE;
+    SetLastErrorByStatus(Status);
+    return FALSE;
 }
 
 /*
  * @implemented
  */
-DWORD WINAPI
-WTSGetActiveConsoleSessionId (VOID)
+DWORD
+WINAPI
+WTSGetActiveConsoleSessionId(VOID)
 {
-       return ActiveConsoleSessionId;
+    return ActiveConsoleSessionId;
 }
 
 /* EOF */
index 474a5d6..4335a3f 100644 (file)
@@ -26,8 +26,9 @@ InitializeCriticalSection(OUT LPCRITICAL_SECTION lpCriticalSection)
 
     /* Initialize the critical section and raise an exception if we failed */
     Status = RtlInitializeCriticalSection(
-        (PRTL_CRITICAL_SECTION)lpCriticalSection);
-    if (!NT_SUCCESS(Status)) RtlRaiseStatus(Status);
+       (PRTL_CRITICAL_SECTION)lpCriticalSection);
+    if (!NT_SUCCESS(Status))
+        RtlRaiseStatus(Status);
 }
 
 /*
index d39c0aa..3f1d795 100644 (file)
@@ -72,10 +72,10 @@ CreateEventExW(IN LPSECURITY_ATTRIBUTES lpEventAttributes  OPTIONAL,
     /* Now check if we got a name */
     if (lpName) RtlInitUnicodeString(&ObjectName, lpName);
 
-       /* Check for invalid flags */
+    /* Check for invalid flags */
     if (dwFlags & ~(CREATE_EVENT_INITIAL_SET | CREATE_EVENT_MANUAL_RESET))
     {
-           /* Fail */
+        /* Fail */
         SetLastError(ERROR_INVALID_PARAMETER);
         return NULL;
     }
index 69dca56..2708fe5 100644 (file)
@@ -75,7 +75,8 @@ CreateMutexExW(IN LPSECURITY_ATTRIBUTES lpMutexAttributes  OPTIONAL,
     BOOLEAN InitialOwner;
 
     /* Now check if we got a name */
-    if (lpName) RtlInitUnicodeString(&ObjectName, lpName);
+    if (lpName)
+        RtlInitUnicodeString(&ObjectName, lpName);
 
     if (dwFlags & ~(CREATE_MUTEX_INITIAL_OWNER))
     {
@@ -257,7 +258,8 @@ ReleaseMutex(IN HANDLE hMutex)
 
     /* Release the mutant */
     Status = NtReleaseMutant(hMutex, NULL);
-    if (NT_SUCCESS(Status)) return TRUE;
+    if (NT_SUCCESS(Status))
+        return TRUE;
 
     /* If we got here, then we failed */
     SetLastErrorByStatus(Status);
index 6b85931..f1ceb53 100644 (file)
@@ -80,7 +80,8 @@ CreateSemaphoreExW(IN LPSECURITY_ATTRIBUTES lpSemaphoreAttributes  OPTIONAL,
     UNICODE_STRING ObjectName;
 
     /* Now check if we got a name */
-    if (lpName) RtlInitUnicodeString(&ObjectName, lpName);
+    if (lpName)
+        RtlInitUnicodeString(&ObjectName, lpName);
 
     if (dwFlags != 0)
     {
@@ -260,7 +261,8 @@ ReleaseSemaphore(IN HANDLE hSemaphore,
 
     /* Release the semaphore */
     Status = NtReleaseSemaphore(hSemaphore, lReleaseCount, lpPreviousCount);
-    if (NT_SUCCESS(Status)) return TRUE;
+    if (NT_SUCCESS(Status))
+        return TRUE;
 
     /* If we got here, then we failed */
     SetLastErrorByStatus(Status);
index fd21a1b..bf99ded 100644 (file)
@@ -75,7 +75,8 @@ CreateWaitableTimerExW(IN LPSECURITY_ATTRIBUTES lpTimerAttributes  OPTIONAL,
     TIMER_TYPE TimerType;
 
     /* Now check if we got a name */
-    if (lpTimerName) RtlInitUnicodeString(&ObjectName, lpTimerName);
+    if (lpTimerName)
+        RtlInitUnicodeString(&ObjectName, lpTimerName);
 
     if (dwFlags & ~(CREATE_WAITABLE_TIMER_MANUAL_RESET))
     {
@@ -268,7 +269,8 @@ SetWaitableTimer(IN HANDLE hTimer,
                         (BOOLEAN)fResume,
                         lPeriod,
                         NULL);
-    if (NT_SUCCESS(Status)) return TRUE;
+    if (NT_SUCCESS(Status))
+        return TRUE;
 
     /* If we got here, then we failed */
     SetLastErrorByStatus(Status);
@@ -286,7 +288,8 @@ CancelWaitableTimer(IN HANDLE hTimer)
 
     /* Cancel the timer */
     Status = NtCancelTimer(hTimer, NULL);
-    if (NT_SUCCESS(Status)) return TRUE;
+    if (NT_SUCCESS(Status))
+        return TRUE;
 
     /* If we got here, then we failed */
     SetLastErrorByStatus(Status);
index 6fea301..a471b83 100644 (file)
@@ -36,9 +36,9 @@ WaitForSingleObjectEx(IN HANDLE hHandle,
                       IN DWORD dwMilliseconds,
                       IN BOOL bAlertable)
 {
-  PLARGE_INTEGER TimePtr;
-  LARGE_INTEGER Time;
-  NTSTATUS Status;
+    PLARGE_INTEGER TimePtr;
+    LARGE_INTEGER Time;
+    NTSTATUS Status;
 
     /* Get real handle */
     hHandle = TranslateStdHandle(hHandle);
index cd516dd..6be7ad4 100644 (file)
@@ -37,7 +37,7 @@ ConvertFiberToThread(VOID)
     DPRINT1("Converting Fiber to Thread\n");
 
     /* the current thread isn't running a fiber: failure */
-    if(!pTeb->HasFiberData)
+    if (!pTeb->HasFiberData)
     {
         SetLastError(ERROR_INVALID_PARAMETER);
         return FALSE;
@@ -47,7 +47,7 @@ ConvertFiberToThread(VOID)
     pTeb->HasFiberData = FALSE;
 
     /* free the fiber */
-    if(pTeb->Tib.FiberData != NULL)
+    if (pTeb->Tib.FiberData != NULL)
     {
         RtlFreeHeap(GetProcessHeap(), 0, pTeb->Tib.FiberData);
     }
@@ -69,7 +69,8 @@ ConvertThreadToFiberEx(LPVOID lpParameter,
     DPRINT1("Converting Thread to Fiber\n");
 
     /* the current thread is already a fiber */
-    if(pTeb->HasFiberData && pTeb->Tib.FiberData) return pTeb->Tib.FiberData;
+    if (pTeb->HasFiberData && pTeb->Tib.FiberData)
+        return pTeb->Tib.FiberData;
 
     /* allocate the fiber */
     pfCurFiber = (PFIBER)RtlAllocateHeap(GetProcessHeap(), 
@@ -77,7 +78,7 @@ ConvertThreadToFiberEx(LPVOID lpParameter,
                                          sizeof(FIBER));
 
     /* failure */
-    if(pfCurFiber == NULL)
+    if (pfCurFiber == NULL)
     {
         SetLastError(ERROR_NOT_ENOUGH_MEMORY);
         return NULL;
@@ -93,7 +94,7 @@ ConvertThreadToFiberEx(LPVOID lpParameter,
     pfCurFiber->GuaranteedStackBytes = pTeb->GuaranteedStackBytes;
     pfCurFiber->ActivationContextStack = pTeb->ActivationContextStackPointer;
     pfCurFiber->Context.ContextFlags = CONTEXT_FULL;
-    
+
     /* Save FPU State if requsted */
     if (dwFlags & FIBER_FLAG_FLOAT_SWITCH)
     {
@@ -150,17 +151,17 @@ CreateFiberEx(SIZE_T dwStackCommitSize,
     PVOID ActivationContextStack = NULL;
     DPRINT1("Creating Fiber\n");
 
-    #ifdef SXS_SUPPORT_ENABLED
+#ifdef SXS_SUPPORT_ENABLED
     /* Allocate the Activation Context Stack */
     nErrCode = RtlAllocateActivationContextStack(&ActivationContextStack);
-    #endif
-    
+#endif
+
     /* Allocate the fiber */
     pfCurFiber = (PFIBER)RtlAllocateHeap(GetProcessHeap(), 
                                          0,
                                          sizeof(FIBER));
     /* Failure */
-    if(pfCurFiber == NULL)
+    if (pfCurFiber == NULL)
     {
         SetLastError(ERROR_NOT_ENOUGH_MEMORY);
         return NULL;
@@ -181,10 +182,10 @@ CreateFiberEx(SIZE_T dwStackCommitSize,
         SetLastErrorByStatus(nErrCode);
         return NULL;
     }
-    
+
     /* Clear the context */
     RtlZeroMemory(&pfCurFiber->Context, sizeof(CONTEXT));
-    
+
     /* copy the data into the fiber */
     pfCurFiber->StackBase = usFiberInitialTeb.StackBase;
     pfCurFiber->StackLimit = usFiberInitialTeb.StackLimit;
@@ -195,20 +196,20 @@ CreateFiberEx(SIZE_T dwStackCommitSize,
     pfCurFiber->FlsData = NULL;
     pfCurFiber->ActivationContextStack = ActivationContextStack;
     pfCurFiber->Context.ContextFlags = CONTEXT_FULL;
-    
+
     /* Save FPU State if requsted */
     if (dwFlags & FIBER_FLAG_FLOAT_SWITCH)
     {
         pfCurFiber->Context.ContextFlags |= CONTEXT_FLOATING_POINT;
     }
-    
+
     /* initialize the context for the fiber */
     BasepInitializeContext(&ctxFiberContext,
                            lpParameter,
                            lpStartAddress,
                            usFiberInitialTeb.StackBase,
                            2);
+
     /* Return the Fiber */ 
     return pfCurFiber;
 }
@@ -227,7 +228,8 @@ DeleteFiber(LPVOID lpFiber)
     RtlFreeHeap(GetProcessHeap(), 0, lpFiber);
 
     /* the fiber is deleting itself: let the system deallocate the stack */
-    if(NtCurrentTeb()->Tib.FiberData == lpFiber) ExitThread(1);
+    if (NtCurrentTeb()->Tib.FiberData == lpFiber)
+        ExitThread(1);
 
     /* deallocate the stack */
     NtFreeVirtualMemory(NtCurrentProcess(),
index 255707a..f538e84 100644 (file)
 /*
  * @unimplemented
  */
-DWORD WINAPI FlsAlloc(PFLS_CALLBACK_FUNCTION lpCallback)
+DWORD
+WINAPI
+FlsAlloc(PFLS_CALLBACK_FUNCTION lpCallback)
 {
- (void)lpCallback;
  (void)lpCallback;
 
- UNIMPLEMENTED;
- SetLastError(ERROR_CALL_NOT_IMPLEMENTED);
- return FLS_OUT_OF_INDEXES;
  UNIMPLEMENTED;
  SetLastError(ERROR_CALL_NOT_IMPLEMENTED);
  return FLS_OUT_OF_INDEXES;
 }
 
 
 /*
  * @unimplemented
  */
-BOOL WINAPI FlsFree(DWORD dwFlsIndex)
+BOOL
+WINAPI
+FlsFree(DWORD dwFlsIndex)
 {
- (void)dwFlsIndex;
   (void)dwFlsIndex;
 
- UNIMPLEMENTED;
- SetLastError(ERROR_CALL_NOT_IMPLEMENTED);
- return FALSE;
   UNIMPLEMENTED;
   SetLastError(ERROR_CALL_NOT_IMPLEMENTED);
   return FALSE;
 }
 
 
 /*
  * @implemented
  */
-PVOID WINAPI FlsGetValue(DWORD dwFlsIndex)
+PVOID
+WINAPI
+FlsGetValue(DWORD dwFlsIndex)
 {
PVOID * ppFlsSlots;
- PVOID pRetVal;
   PVOID *ppFlsSlots;
   PVOID pRetVal;
 
- if(dwFlsIndex >= 128) goto l_InvalidParam;
+    if (dwFlsIndex >= 128)
+        goto l_InvalidParam;
 
- ppFlsSlots = NtCurrentTeb()->FlsData;
   ppFlsSlots = NtCurrentTeb()->FlsData;
 
- if(ppFlsSlots == NULL) goto l_InvalidParam;
+    if (ppFlsSlots == NULL)
+        goto l_InvalidParam;
 
- SetLastError(0);
- pRetVal = ppFlsSlots[dwFlsIndex + 2];
   SetLastError(0);
   pRetVal = ppFlsSlots[dwFlsIndex + 2];
 
- return pRetVal;
   return pRetVal;
 
 l_InvalidParam:
- SetLastError(ERROR_INVALID_PARAMETER);
- return NULL;
   SetLastError(ERROR_INVALID_PARAMETER);
   return NULL;
 }
 
 
 /*
  * @implemented
  */
-BOOL WINAPI FlsSetValue(DWORD dwFlsIndex, PVOID lpFlsData)
+BOOL
+WINAPI
+FlsSetValue(DWORD dwFlsIndex, PVOID lpFlsData)
 {
PVOID * ppFlsSlots;
TEB * pTeb = NtCurrentTeb();
   PVOID *ppFlsSlots;
   TEB *pTeb = NtCurrentTeb();
 
- if(dwFlsIndex >= 128) goto l_InvalidParam;
+    if (dwFlsIndex >= 128)
+        goto l_InvalidParam;
 
- ppFlsSlots = pTeb->FlsData;
   ppFlsSlots = pTeb->FlsData;
 
if(ppFlsSlots == NULL)
- {
-  PEB * pPeb = pTeb->ProcessEnvironmentBlock;
   if (ppFlsSlots == NULL)
   {
+        PEB *pPeb = pTeb->ProcessEnvironmentBlock;
 
-  ppFlsSlots = RtlAllocateHeap
-  (
-   pPeb->ProcessHeap,
-   HEAP_ZERO_MEMORY,
-   (128 + 2) * sizeof(PVOID)
-  );
+        ppFlsSlots = RtlAllocateHeap(pPeb->ProcessHeap,
+                                     HEAP_ZERO_MEMORY,
+                                     (128 + 2) * sizeof(PVOID));
+        if (ppFlsSlots == NULL)
+            goto l_OutOfMemory;
 
-  if(ppFlsSlots == NULL) goto l_OutOfMemory;
+        pTeb->FlsData = ppFlsSlots;
 
-  pTeb->FlsData = ppFlsSlots;
+        RtlAcquirePebLock();
 
-  RtlAcquirePebLock();
+        /* TODO: initialization */
 
-  /* TODO: initialization */
+        RtlReleasePebLock();
+    }
 
-  RtlReleasePebLock();
- }
+    ppFlsSlots[dwFlsIndex + 2] = lpFlsData;
 
- ppFlsSlots[dwFlsIndex + 2] = lpFlsData;
-
- return TRUE;
+    return TRUE;
 
 l_OutOfMemory:
- SetLastError(ERROR_NOT_ENOUGH_MEMORY);
- goto l_Fail;
   SetLastError(ERROR_NOT_ENOUGH_MEMORY);
   goto l_Fail;
 
 l_InvalidParam:
- SetLastError(ERROR_INVALID_PARAMETER);
   SetLastError(ERROR_INVALID_PARAMETER);
 
 l_Fail:
- return FALSE;
   return FALSE;
 }
 
 /* EOF */
index b6fc73d..be7fa02 100644 (file)
@@ -82,7 +82,7 @@ WINAPI
 TlsFree(DWORD Index)
 {
     BOOL BitSet;
-   
+
     if (Index >= TLS_EXPANSION_SLOTS + TLS_MINIMUM_AVAILABLE)
     {
         SetLastErrorByStatus(STATUS_INVALID_PARAMETER);