[KERNEL32] Don't hardcode some types in sizeofs, and some flag values.

dll/win32/kernel32/client/file/npipe.c

···
 
         /* Restore the thread token */
         Status = NtSetInformationThread(NtCurrentThread(), ThreadImpersonationToken,
-                                        &hToken, sizeof(HANDLE));
+                                        &hToken, sizeof(hToken));
         /* We cannot fail closing the thread token! */
         if (!CloseHandle(hToken))
         {
···
 
     /* Create the named pipe */
     Status = NtCreateNamedPipeFile(&ReadPipeHandle,
-                                   GENERIC_READ |FILE_WRITE_ATTRIBUTES | SYNCHRONIZE,
+                                   GENERIC_READ | FILE_WRITE_ATTRIBUTES | SYNCHRONIZE,
                                    &ObjectAttributes,
                                    &StatusBlock,
                                    FILE_SHARE_READ | FILE_SHARE_WRITE,
···
 
     /* Always case insensitive, check if we got extra attributes */
     Attributes = OBJ_CASE_INSENSITIVE;
-    if(lpSecurityAttributes)
+    if (lpSecurityAttributes)
     {
         /* We did; get the security descriptor */
         SecurityDescriptor = lpSecurityAttributes->lpSecurityDescriptor;
···
 
         /* Set the Read Mode */
         Settings.ReadMode = (*lpMode & PIPE_READMODE_MESSAGE) ?
-                            FILE_PIPE_MESSAGE_MODE: FILE_PIPE_BYTE_STREAM_MODE;
+                            FILE_PIPE_MESSAGE_MODE : FILE_PIPE_BYTE_STREAM_MODE;
 
         /* Send the changes to the Driver */
         Status = NtSetInformationFile(hNamedPipe,
                                       &Iosb,
                                       &Settings,
-                                      sizeof(FILE_PIPE_INFORMATION),
+                                      sizeof(Settings),
                                       FilePipeInformation);
         if (!NT_SUCCESS(Status))
         {
···
             Status = NtQueryInformationFile(hNamedPipe,
                                             &Iosb,
                                             &RemoteSettings,
-                                            sizeof(FILE_PIPE_REMOTE_INFORMATION),
+                                            sizeof(RemoteSettings),
                                             FilePipeRemoteInformation);
             if (!NT_SUCCESS(Status))
             {
···
         Status = NtSetInformationFile(hNamedPipe,
                                       &Iosb,
                                       &RemoteSettings,
-                                      sizeof(FILE_PIPE_REMOTE_INFORMATION),
+                                      sizeof(RemoteSettings),
                                       FilePipeRemoteInformation);
         if (!NT_SUCCESS(Status))
         {
···
         Status = NtQueryInformationFile(hNamedPipe,
                                         &StatusBlock,
                                         &PipeInfo,
-                                        sizeof(FILE_PIPE_INFORMATION),
+                                        sizeof(PipeInfo),
                                         FilePipeInformation);
         if (!NT_SUCCESS(Status))
         {
···
         *lpState |= ((PipeInfo.ReadMode != FILE_PIPE_BYTE_STREAM_MODE) ? PIPE_READMODE_MESSAGE : PIPE_READMODE_BYTE);
     }
 
-    if(lpCurInstances != NULL)
+    if (lpCurInstances != NULL)
     {
         FILE_PIPE_LOCAL_INFORMATION LocalInfo;
 
         Status = NtQueryInformationFile(hNamedPipe,
                                         &StatusBlock,
                                         &LocalInfo,
-                                        sizeof(FILE_PIPE_LOCAL_INFORMATION),
+                                        sizeof(LocalInfo),
                                         FilePipeLocalInformation);
         if (!NT_SUCCESS(Status))
         {
···
         Status = NtQueryInformationFile(hNamedPipe,
                                         &StatusBlock,
                                         &RemoteInfo,
-                                        sizeof(FILE_PIPE_REMOTE_INFORMATION),
+                                        sizeof(RemoteInfo),
                                         FilePipeRemoteInformation);
         if (!NT_SUCCESS(Status))
         {
···
     ANSI_STRING UserNameA;
     BOOL Ret;
 
-    if(lpUserName != NULL)
+    if (lpUserName != NULL)
     {
         UserNameW.MaximumLength = (USHORT)nMaxUserNameSize * sizeof(WCHAR);
         UserNameW.Buffer = RtlAllocateHeap(RtlGetProcessHeap(), 0, UserNameW.MaximumLength);
···
     Status = NtQueryInformationFile(hNamedPipe,
                                     &StatusBlock,
                                     &PipeLocalInformation,
-                                    sizeof(FILE_PIPE_LOCAL_INFORMATION),
+                                    sizeof(PipeLocalInformation),
                                     FilePipeLocalInformation);
     if (!NT_SUCCESS(Status))
     {
···
     if (lpFlags != NULL)
     {
         *lpFlags = (PipeLocalInformation.NamedPipeEnd == FILE_PIPE_SERVER_END) ? PIPE_SERVER_END : PIPE_CLIENT_END;
-        *lpFlags |= (PipeLocalInformation.NamedPipeType == 1) ? PIPE_TYPE_MESSAGE : PIPE_TYPE_BYTE;
+        *lpFlags |= (PipeLocalInformation.NamedPipeType == FILE_PIPE_MESSAGE_TYPE) ? PIPE_TYPE_MESSAGE : PIPE_TYPE_BYTE;
     }
 
     if (lpOutBufferSize != NULL)

dll/win32/kernel32/client/loader.c

···
     if (NT_SUCCESS(Status)) return Module;
 
     /* If not, then the path should be computed */
-    DllPath = BaseComputeProcessDllPath(NULL, 0);
+    DllPath = BaseComputeProcessDllPath(NULL, NULL);
     if (!DllPath)
     {
         Status = STATUS_NO_MEMORY;