Ignore:
Timestamp:
Oct 19, 2011, 11:26:02 AM (14 years ago)
Author:
dmik
Message:

Replace "\" with "/" in include statements.

Location:
branches/gcc-kmk/src/kernel32
Files:
22 edited

Legend:

Unmodified
Added
Removed

  • branches/gcc-kmk/src/kernel32/HandleManager.cpp

    r21717 r21720  
    7070
    7171#include <vmutex.h>
    72 #include <win\thread.h>
     72#include <win/thread.h>
    7373
    7474#include <odinapi.h>

  • branches/gcc-kmk/src/kernel32/char.cpp

    r7886 r21720  
    2626
    2727#include <misc.h>
    28 #include <wine\unicode.h>
     28#include <wine/unicode.h>
    2929
    3030

  • branches/gcc-kmk/src/kernel32/directory.cpp

    r21302 r21720  
    66 * Copyright 1998 Sander van Leeuwen
    77 *
    8  * NOTE: Directory creation has to be done in install program (odin\win) 
     8 * NOTE: Directory creation has to be done in install program (odin\win)
    99 *
    1010 * Parts based on Wine code (991031) (files\directory.c)
    … …  
    1414 * Copyright 1995 Alexandre Julliard
    1515 *
    16  * TODO: 
     16 * TODO:
    1717 *  - System/window directories should be created by install program!
    1818 *
    … …  
    3434#include <options.h>
    3535#include "initterm.h"
    36 #include <win\file.h>
     36#include <win/file.h>
    3737#include <string.h>
    3838#include "oslibdos.h"
    … …  
    8080   len = strlen(DIR_System);
    8181   if(DIR_System[len-1] == '\\') {
    82         DIR_System[len-1] = 0; 
     82        DIR_System[len-1] = 0;
    8383   }
    8484   len = PROFILE_GetOdinIniString(ODINDIRECTORIES,"WINDOWS","",DIR_Windows,sizeof(DIR_Windows));
    8585   if (len > 2) {
    8686        if(DIR_Windows[len-1] == '\\') {
    87                 DIR_Windows[len-1] = 0; 
     87                DIR_Windows[len-1] = 0;
    8888        }
    8989   }
    … …  
    116116   len = strlen(DIR_System);
    117117   if(DIR_System[len-1] == '\\') {
    118         DIR_System[len-1] = 0; 
     118        DIR_System[len-1] = 0;
    119119   }
    120120   strcpy(DIR_Windows, szWindowsDir);
    121121   len = strlen(DIR_Windows);
    122122   if(DIR_Windows[len-1] == '\\') {
    123         DIR_Windows[len-1] = 0; 
     123        DIR_Windows[len-1] = 0;
    124124   }
    125125
    … …  
    146146  rc = OSLibDosQueryDir(nBufferLength, lpBuffer);
    147147  if(rc && rc < nBufferLength) {
    148        dprintf(("CurrentDirectory = %s (%d)", lpBuffer, rc)); 
    149   }
    150   else dprintf(("CurrentDirectory returned %d", rc)); 
     148       dprintf(("CurrentDirectory = %s (%d)", lpBuffer, rc));
     149  }
     150  else dprintf(("CurrentDirectory returned %d", rc));
    151151  return rc;
    152152}
    … …  
    196196    return FALSE;
    197197  }
    198  
     198
    199199  // cut off trailing backslashes
    200200  // not if a process wants to change to the root directory
    … …  
    264264
    265265  int len = strlen(lpstrDirectory);
    266  
     266
    267267  // cut off trailing backslashes
    268268  if ( (lpstrDirectory[len - 1] == '\\') ||
    … …  
    275275    lpstrDirectory = lpTemp;
    276276  }
    277  
     277
    278278  dprintf(("CreateDirectoryA %s", lpstrDirectory));
    279  
     279
    280280  // Creation of an existing directory will fail (verified in NT4 & XP)
    281281  DWORD dwAttr = GetFileAttributesA(lpstrDirectory);
    282   if(dwAttr != -1) 
     282  if(dwAttr != -1)
    283283  {
    284284      if (dwAttr & FILE_ATTRIBUTE_DIRECTORY)
    … …  
    287287          return FALSE;
    288288      }
    289   } 
     289  }
    290290  return(OSLibDosCreateDirectory(lpstrDirectory));
    291291}
    … …  
    437437    asciibuffer = (char *)alloca(uSize+1);
    438438
    439   if(lpBuffer && asciibuffer == NULL) 
     439  if(lpBuffer && asciibuffer == NULL)
    440440  {
    441441    DebugInt3();
    … …  
    445445  if(rc && asciibuffer)
    446446    AsciiToUnicode(asciibuffer, lpBuffer);
    447  
     447
    448448  return(rc);
    449449}
    … …  
    495495    asciibuffer = (char *)alloca(uSize+1);
    496496
    497   if(lpBuffer && asciibuffer == NULL) 
     497  if(lpBuffer && asciibuffer == NULL)
    498498  {
    499499    DebugInt3();
    … …  
    503503  if(rc && asciibuffer)
    504504    AsciiToUnicode(asciibuffer, lpBuffer);
    505  
     505
    506506  return(rc);
    507507}
    … …  
    524524{
    525525  int len = strlen(lpstrDirectory);
    526  
     526
    527527  if(lpstrDirectory == NULL) {
    528528     SetLastError(ERROR_INVALID_PARAMETER);
    … …  
    539539    lpstrDirectory = lpTemp;
    540540  }
    541  
     541
    542542  dprintf(("RemoveDirectory %s", lpstrDirectory));
    543543
    … …  
    619619       those (according to SDK docs) */
    620620    if ((path != NULL) && strchr(path, ';')) {
    621         ret = OSLibDosSearchPath(OSLIB_SEARCHDIR, (LPSTR)path, (LPSTR)name, 
     621        ret = OSLibDosSearchPath(OSLIB_SEARCHDIR, (LPSTR)path, (LPSTR)name,
    622622                                 full_name, MAX_PATHNAME_LEN);
    623623        goto done;
    … …  
    647647        name = tmp;
    648648    }
    649    
     649
    650650    /* If we have an explicit path, everything's easy */
    651651
    … …  
    704704 *             filename is returned.
    705705 *    Failure: Zero
    706  * 
     706 *
    707707 * NOTES
    708708 *    Should call SetLastError(but currently doesn't).
    … …  
    732732    LPSTR nameA = HEAP_strdupWtoA( GetProcessHeap(), 0, name );
    733733    LPSTR extA  = HEAP_strdupWtoA( GetProcessHeap(), 0, ext );
    734  
     734
    735735    dprintf(("SearchPathA %s %s %s", pathA, nameA, extA));
    736736    DWORD ret = DIR_SearchPath( pathA, nameA, extA, (LPSTR)full_name );
    737  
     737
    738738    if (NULL != extA)
    739739      HeapFree( GetProcessHeap(), 0, extA );
    740  
     740
    741741    if (NULL != nameA)
    742742      HeapFree( GetProcessHeap(), 0, nameA );
    743  
     743
    744744    if (NULL != pathA)
    745745      HeapFree( GetProcessHeap(), 0, pathA );
    746  
     746
    747747    if (!ret) return 0;
    748748

  • branches/gcc-kmk/src/kernel32/heapstring.cpp

    r21361 r21720  
    2727#include <wcstr.h>
    2828#include "heap.h"
    29 #include <wine\unicode.h>
     29#include <wine/unicode.h>
    3030#include "misc.h"
    3131#include "codepage.h"

  • branches/gcc-kmk/src/kernel32/hmdevio.cpp

    r21302 r21720  
    2525#include <win32api.h>
    2626#include <misc.h>
    27 #include <win\winioctl.h>
     27#include <win/winioctl.h>
    2828#include "hmdevio.h"
    2929#include "exceptutil.h"
    … …  
    4747 DWORD rc;
    4848
    49     for(int i=0;i<nrKnownDrivers;i++) 
     49    for(int i=0;i<nrKnownDrivers;i++)
    5050    {
    5151            driver = new HMDeviceDriver(knownDriver[i].szWin32Name,
    … …  
    101101                        if (rc != NO_ERROR)                                  /* check for errors */
    102102                          dprintf(("KERNEL32:RegisterDevices: registering %s failed with %u.\n", szDrvName, rc));
    103                      
     103
    104104                        // @@@PH
    105105                        // there should be an symbolic link:
    … …  
    109109                rc = 0;
    110110            }
    111         }   
     111        }
    112112        RegCloseKey(hkDrivers);
    113113    }
    … …  
    117117//******************************************************************************
    118118//******************************************************************************
    119 BOOL WIN32API RegisterCustomDriver(PFNDRVOPEN pfnDriverOpen, PFNDRVCLOSE pfnDriverClose, 
     119BOOL WIN32API RegisterCustomDriver(PFNDRVOPEN pfnDriverOpen, PFNDRVCLOSE pfnDriverClose,
    120120                                   PFNDRVIOCTL pfnDriverIOCtl, PFNDRVREAD pfnDriverRead,
    121121                                   PFNDRVWRITE pfnDriverWrite, PFNDRVCANCELIO pfnDriverCancelIo,
    … …  
    141141//******************************************************************************
    142142//******************************************************************************
    143 HMDeviceDriver::HMDeviceDriver(LPCSTR lpDeviceName, LPSTR lpOS2DevName, BOOL fCreate, 
     143HMDeviceDriver::HMDeviceDriver(LPCSTR lpDeviceName, LPSTR lpOS2DevName, BOOL fCreate,
    144144                               WINIOCTL pDevIOCtl)
    145145                : HMDeviceHandler(lpDeviceName)
    … …  
    215215  dprintf(("DosOpen %s returned %d\n", szOS2Name, rc));
    216216
    217   if(rc == NO_ERROR) 
     217  if(rc == NO_ERROR)
    218218  {
    219219    pHMHandleData->hHMHandle = hfFileHandle;
    220220    return (NO_ERROR);
    221221  }
    222   else 
     222  else
    223223    return(error2WinError(rc));
    224224}
    … …  
    259259//******************************************************************************
    260260//******************************************************************************
    261 HMCustomDriver::HMCustomDriver(PFNDRVOPEN pfnDriverOpen, PFNDRVCLOSE pfnDriverClose, 
     261HMCustomDriver::HMCustomDriver(PFNDRVOPEN pfnDriverOpen, PFNDRVCLOSE pfnDriverClose,
    262262                               PFNDRVIOCTL pfnDriverIOCtl, PFNDRVREAD pfnDriverRead,
    263263                               PFNDRVWRITE pfnDriverWrite, PFNDRVCANCELIO pfnDriverCancelIo,
    … …  
    461461        return FALSE;
    462462    }
    463     return pfnDriverGetOverlappedResult(lpDriverData, pHMHandleData->hHMHandle, pHMHandleData->dwFlags, 
     463    return pfnDriverGetOverlappedResult(lpDriverData, pHMHandleData->hHMHandle, pHMHandleData->dwFlags,
    464464                                        lpOverlapped, lpcbTransfer, fWait, (LPVOID)pHMHandleData->dwUserData);
    465465}

  • branches/gcc-kmk/src/kernel32/hmdisk.cpp

    r9911 r21720  
    1818#include "hmdisk.h"
    1919#include "mmap.h"
    20 #include <win\winioctl.h>
    21 #include <win\ntddscsi.h>
    22 #include <win\wnaspi32.h>
     20#include <win/winioctl.h>
     21#include <win/ntddscsi.h>
     22#include <win/wnaspi32.h>
    2323#include "oslibdos.h"
    2424#include "osliblvm.h"
    … …  
    4343typedef struct
    4444{
    45     BOOL      fCDIoSupported;   
     45    BOOL      fCDIoSupported;
    4646    ULONG     driveLetter;
    4747    ULONG     driveType;
    … …  
    163163    szDrive[2] = '\0';
    164164
    165     //if volume name, query 
    166     if(!strncmp(lpFileName, VOLUME_NAME_PREFIX, sizeof(VOLUME_NAME_PREFIX)-1)) 
     165    //if volume name, query
     166    if(!strncmp(lpFileName, VOLUME_NAME_PREFIX, sizeof(VOLUME_NAME_PREFIX)-1))
    167167    {
    168168        int length;
    … …  
    171171            return ERROR_FILE_NOT_FOUND;    //not allowed
    172172        }
    173         if(OSLibLVMStripVolumeName(lpFileName, szVolumeName, sizeof(szVolumeName))) 
     173        if(OSLibLVMStripVolumeName(lpFileName, szVolumeName, sizeof(szVolumeName)))
    174174        {
    175175            BOOL fLVMVolume;
    … …  
    184184                return ERROR_FILE_NOT_FOUND;    //not found
    185185            }
    186             if(szDrive[0] == 0) 
     186            if(szDrive[0] == 0)
    187187            {
    188188                //volume isn't mounted
    189                
     189
    190190                //Note: this only works on Warp 4.5 and up
    191                 sprintf(szDiskName, "\\\\.\\Physical_Disk%d", volext.Extents[0].DiskNumber+1); 
     191                sprintf(szDiskName, "\\\\.\\Physical_Disk%d", volext.Extents[0].DiskNumber+1);
    192192                fPhysicalDisk    = TRUE;
    193193                dwPhysicalDiskNr = volext.Extents[0].DiskNumber + 1;
    … …  
    211211        else return ERROR_FILE_NOT_FOUND;
    212212    }
    213     else 
    214     if(strncmp(lpFileName, "\\\\.\\PHYSICALDRIVE", 17) == 0) 
     213    else
     214    if(strncmp(lpFileName, "\\\\.\\PHYSICALDRIVE", 17) == 0)
    215215    {
    216216        if(!fPhysicalDiskAccess) {
    … …  
    304304        drvInfo->fLocked   = FALSE;
    305305
    306         //save volume start & length if volume must be accessed through the physical disk 
     306        //save volume start & length if volume must be accessed through the physical disk
    307307        //(no other choice for unmounted volumes)
    308308        drvInfo->fPhysicalDisk    = fPhysicalDisk;
    … …  
    348348        if(pHMHandleData->hHMHandle && drvInfo->dwShare == 0) {
    349349            dprintf(("Locking drive"));
    350             if(OSLibDosDevIOCtl(pHMHandleData->hHMHandle,IOCTL_DISK,DSK_LOCKDRIVE,0,0,0,0,0,0)) 
     350            if(OSLibDosDevIOCtl(pHMHandleData->hHMHandle,IOCTL_DISK,DSK_LOCKDRIVE,0,0,0,0,0,0))
    351351            {
    352352                dprintf(("Sharing violation while attempting to lock the drive"));
    … …  
    411411        if(hFile && drvInfo->dwShare == 0) {
    412412            dprintf(("Locking drive"));
    413             if(OSLibDosDevIOCtl(hFile,IOCTL_DISK,DSK_LOCKDRIVE,0,0,0,0,0,0)) 
     413            if(OSLibDosDevIOCtl(hFile,IOCTL_DISK,DSK_LOCKDRIVE,0,0,0,0,0,0))
    414414            {
    415415                dprintf(("Sharing violation while attempting to lock the drive"));
    … …  
    890890        //label has changed
    891891        //TODO: Find better way to determine if floppy was removed or switched
    892         if(drvInfo->driveType != DRIVE_FIXED) 
     892        if(drvInfo->driveType != DRIVE_FIXED)
    893893        {
    894894            rc = OSLibDosQueryVolumeSerialAndName(1 + drvInfo->driveLetter - 'A', &volumelabel, NULL, 0);
    … …  
    14391439        return (ret == ERROR_SUCCESS);
    14401440    }
    1441    
     1441
    14421442    case IOCTL_CDROM_RAW_READ:
    14431443    {
    14441444#pragma pack(1)
    1445        struct 
     1445       struct
    14461446       {
    14471447        ULONG       ID_code;
    … …  
    14971497
    14981498        if(lpBytesReturned) {
    1499             *lpBytesReturned = dwDataSize; 
     1499            *lpBytesReturned = dwDataSize;
    15001500        }
    15011501
    … …  
    16331633    case IOCTL_SCSI_GET_CAPABILITIES:
    16341634    {
    1635         PIO_SCSI_CAPABILITIES pPacket = (PIO_SCSI_CAPABILITIES)lpOutBuffer; 
     1635        PIO_SCSI_CAPABILITIES pPacket = (PIO_SCSI_CAPABILITIES)lpOutBuffer;
    16361636
    16371637        if(nOutBufferSize < sizeof(IO_SCSI_CAPABILITIES) ||
    … …  
    16771677            return FALSE;
    16781678        }
    1679        
     1679
    16801680        if(!drvInfo || drvInfo->fCDIoSupported == FALSE) {
    16811681            dprintf(("os2cdrom.dmd CD interface not supported!!"));
    … …  
    18421842        if((nNumberOfBytesToRead+offset) & 0xfff)
    18431843            nrpages++;
    1844    
     1844
    18451845        map->commitRange((ULONG)lpBuffer, offset & ~0xfff, TRUE, nrpages);
    18461846        map->Release();
    … …  
    21062106        if((nNumberOfBytesToWrite+offset) & 0xfff)
    21072107            nrpages++;
    2108    
     2108
    21092109        map->commitRange((ULONG)lpBuffer, offset & ~0xfff, TRUE, nrpages);
    21102110        map->Release();
    … …  
    22022202
    22032203    dprintf2(("KERNEL32: HMDeviceDiskClass::GetFileSize %s(%08xh,%08xh)\n",
    2204               lpHMDeviceName, pHMHandleData, lpdwFileSizeHigh)); 
     2204              lpHMDeviceName, pHMHandleData, lpdwFileSizeHigh));
    22052205
    22062206    //If we didn't get an OS/2 handle for the disk before, get one now

  • branches/gcc-kmk/src/kernel32/hmthread.cpp

    r21457 r21720  
    3434#include "oslibmem.h"
    3535
    36 #include <win\thread.h>
     36#include <win/thread.h>
    3737#include "thread.h"
    3838#include "asmutil.h"
    … …  
    6565    HANDLE       hThread = pHMHandleData->hHMHandle;
    6666
    67     if(lpIDThread == NULL) { 
     67    if(lpIDThread == NULL) {
    6868        lpIDThread = &threadid;
    6969    }
    … …  
    124124
    125125    *lpIDThread = MAKE_THREADID(O32_GetCurrentProcessId(), *lpIDThread);
    126    
     126
    127127    TEB *teb = GetTEBFromThreadHandle(hThread);
    128128    if(teb) {
    … …  
    134134
    135135    dprintf(("CreateThread created %08x, id %x", pHMHandleData->hHMHandle, *lpIDThread));
    136  
     136
    137137    return pHMHandleData->hHMHandle;
    138138}
    … …  
    603603           pHMHandleData->hHMHandle,
    604604           dwTimeout));
    605  
     605
    606606  //This doesn't work very well in Open32 (object's state never signaled)
    607607  if(threadobj && threadobj->dwState == THREAD_TERMINATED) {

  • branches/gcc-kmk/src/kernel32/lang.cpp

    r21302 r21720  
    1919#include <odinwrap.h>
    2020#include <heapstring.h>
    21 #include <win\winreg.h>
     21#include <win/winreg.h>
    2222#include <winos2def.h>
    2323#include "unicode.h"

  • branches/gcc-kmk/src/kernel32/mmap.cpp

    r21716 r21720  
    2828#include <stdlib.h>
    2929#include <string.h>
    30 #include <win\virtual.h>
     30#include <win/virtual.h>
    3131#include <odincrt.h>
    3232#include <handlemanager.h>

  • branches/gcc-kmk/src/kernel32/mmapdup.cpp

    r21716 r21720  
    2828#include <stdlib.h>
    2929#include <string.h>
    30 #include <win\virtual.h>
     30#include <win/virtual.h>
    3131#include <odincrt.h>
    3232#include <handlemanager.h>
    … …  
    3535#include "oslibmem.h"
    3636#include "winimagepeldr.h"
    37 #include <custombuild.h> 
     37#include <custombuild.h>
    3838
    3939#define DBG_LOCALLOG    DBG_mmapdup
    … …  
    4848//
    4949//******************************************************************************
    50 Win32MemMapDup::Win32MemMapDup(Win32MemMap *parent, HANDLE hFile, ULONG size, 
     50Win32MemMapDup::Win32MemMapDup(Win32MemMap *parent, HANDLE hFile, ULONG size,
    5151                               ULONG fdwProtect, LPSTR lpszName) :
    5252          Win32MemMap(hFile, size, fdwProtect, lpszName)
    … …  
    123123    if((fdwAccess & FILE_MAP_READ) && !(mProtFlags & (PAGE_READWRITE|PAGE_READONLY)))
    124124        goto parmfail;
    125    
     125
    126126    if (fdwAccess != FILE_MAP_ALL_ACCESS)
    127127        if((fdwAccess & FILE_MAP_COPY) && !(mProtFlags & PAGE_WRITECOPY))
    … …  
    222222BOOL Win32MemMapDup::commitPage(ULONG ulFaultAddr, ULONG offset, BOOL fWriteAccess, int nrpages)
    223223{
    224     if(mProtFlags & PAGE_WRITECOPY) 
     224    if(mProtFlags & PAGE_WRITECOPY)
    225225    {//this is a COW map, call commitGuardPage
    226226        return commitGuardPage(ulFaultAddr, offset, fWriteAccess);
    … …  
    245245//
    246246//******************************************************************************
    247 BOOL Win32MemMapDup::commitGuardPage(ULONG ulFaultAddr, ULONG ulOffset, 
     247BOOL Win32MemMapDup::commitGuardPage(ULONG ulFaultAddr, ULONG ulOffset,
    248248                                     BOOL fWriteAccess)
    249249{

  • branches/gcc-kmk/src/kernel32/mmapnotify.cpp

    r21716 r21720  
    66 * Calls notification handler when an exception occurs in the memory range of
    77 * the map.
    8  * 
     8 *
    99 * Copyright 2003 Sander van Leeuwen (sandervl@innotek.de)
    1010 *
    … …  
    1616#include <stdlib.h>
    1717#include <string.h>
    18 #include <win\virtual.h>
     18#include <win/virtual.h>
    1919#include <odincrt.h>
    2020#include <handlemanager.h>
    … …  
    2323#include "oslibmem.h"
    2424#include "winimagepeldr.h"
    25 #include <custombuild.h> 
     25#include <custombuild.h>
    2626#include <memmap.h>
    2727
    … …  
    128128// Win32MemMapNotify::findMapByView
    129129//
    130 // Find the map of the view that contains the specified starting address 
     130// Find the map of the view that contains the specified starting address
    131131// and has the specified access type
    132132//

  • branches/gcc-kmk/src/kernel32/mmapview.cpp

    r21716 r21720  
    2828#include <stdlib.h>
    2929#include <string.h>
    30 #include <win\virtual.h>
     30#include <win/virtual.h>
    3131#include <odincrt.h>
    3232#include <handlemanager.h>
    … …  
    3535#include "oslibmem.h"
    3636#include "winimagepeldr.h"
    37 #include <custombuild.h> 
     37#include <custombuild.h>
    3838
    3939#define DBG_LOCALLOG    DBG_mmapview
    … …  
    5151//
    5252//******************************************************************************
    53 Win32MemMapView::Win32MemMapView(Win32MemMap *map, ULONG offset, ULONG size, 
     53Win32MemMapView::Win32MemMapView(Win32MemMap *map, ULONG offset, ULONG size,
    5454                                 ULONG fdwAccess, Win32MemMap *owner)
    5555{
    … …  
    8787    {
    8888        //shared memory map, so map it into our address space
    89         if(OSLibDosGetNamedSharedMem((LPVOID *)&viewaddr, map->getMemName()) != OSLIB_NOERROR) 
     89        if(OSLibDosGetNamedSharedMem((LPVOID *)&viewaddr, map->getMemName()) != OSLIB_NOERROR)
    9090        {
    9191            dprintf(("new OSLibDosGetNamedSharedMem FAILED"));
    … …  
    104104    }
    105105    else {
    106         if(mfAccess & MEMMAP_ACCESS_COPYONWRITE) 
     106        if(mfAccess & MEMMAP_ACCESS_COPYONWRITE)
    107107        {
    108108            //A copy on write view is a private copy of the memory map
    … …  
    118118        }
    119119        }
    120         else 
     120        else
    121121        if(OSLibDosAliasMem(viewaddr, size, &pMapView, accessAttr) != OSLIB_NOERROR) {
    122122            dprintf(("new OSLibDosAliasMem FAILED"));
    … …  
    126126        }
    127127    }
    128     //Allocate bitmap for all pages of a COW view to track which pages are 
     128    //Allocate bitmap for all pages of a COW view to track which pages are
    129129    //shared and which are private (copy on write -> private page)
    130     if(fdwAccess == FILE_MAP_COPY) 
     130    if(fdwAccess == FILE_MAP_COPY)
    131131    {
    132132        DWORD nrPages = mSize >> PAGE_SHIFT;
    … …  
    242242    viewpagestart = mOffset >> PAGE_SHIFT;
    243243    nrviewpages = mSize >> PAGE_SHIFT;
    244     if(mSize & 0xFFF) 
     244    if(mSize & 0xFFF)
    245245        nrviewpages++;
    246246
    … …  
    248248        return; //outside this view
    249249    }
    250     if(startpage + nrpages > viewpagestart + nrviewpages) { 
     250    if(startpage + nrpages > viewpagestart + nrviewpages) {
    251251        nrpages -= ((startpage + nrpages) - (viewpagestart + nrviewpages));
    252252    }
    … …  
    286286    }
    287287
    288     if( ( (mfAccess & MEMMAP_ACCESS_COPYONWRITE) && (flags != PAGEVIEW_GUARD)  ) || 
    289         ( (flags == PAGEVIEW_GUARD) && !(mfAccess & MEMMAP_ACCESS_COPYONWRITE) ) ) 
     288    if( ( (mfAccess & MEMMAP_ACCESS_COPYONWRITE) && (flags != PAGEVIEW_GUARD)  ) ||
     289        ( (flags == PAGEVIEW_GUARD) && !(mfAccess & MEMMAP_ACCESS_COPYONWRITE) ) )
    290290    {
    291291        //PAGEVIEW_GUARD only applies to COW views
    292292        //PAGEVIEW_VIEW/READONLY does not apply to COW views
    293         return TRUE; 
     293        return TRUE;
    294294    }
    295295    if(mOffset + mSize <= offset || mOffset >= offset + size) {
    … …  
    320320    }
    321321
    322     if(flags == PAGEVIEW_GUARD || (mfAccess & MEMMAP_ACCESS_COPYONWRITE)) 
     322    if(flags == PAGEVIEW_GUARD || (mfAccess & MEMMAP_ACCESS_COPYONWRITE))
    323323    {
    324324        DWORD startpage = (offset - mOffset) >> PAGE_SHIFT;
    … …  
    330330        //of the COW pages, then only the shared pages must be changed.
    331331        //So check each page if it is still shared.
    332         for(int i=startpage;i<startpage+nrPages;i++) 
     332        for(int i=startpage;i<startpage+nrPages;i++)
    333333    {
    334             if(!isCOWPage(i)) 
     334            if(!isCOWPage(i))
    335335            {//page is still shared, so set the guard flag
    336336                rc = OSLibDosSetMem((char *)pMapView+(offset - mOffset), PAGE_SIZE, accessAttr);
    … …  
    354354//******************************************************************************
    355355//******************************************************************************
    356 int Win32MemMapView::findViews(Win32MemMap *map, int nrViews, 
     356int Win32MemMapView::findViews(Win32MemMap *map, int nrViews,
    357357                               Win32MemMapView *viewarray[])
    358358{
    … …  
    362362  Win32MemMapView *view = mapviews, *nextview;
    363363
    364   if(view != NULL) 
     364  if(view != NULL)
    365365  {
    366       while(view && i < nrViews) 
     366      while(view && i < nrViews)
    367367      {
    368368          if(view->getParentMap() == map)
    … …  
    384384  Win32MemMapView *view = mapviews, *nextview;
    385385
    386   if(view != NULL) 
     386  if(view != NULL)
    387387  {
    388       while(view) 
     388      while(view)
    389389      {
    390390          nextview = view->next;
    … …  
    404404// Win32MemMap::findMapByView
    405405//
    406 // Find the map of the view that contains the specified starting address 
     406// Find the map of the view that contains the specified starting address
    407407// and has the specified access type
    408408//

  • branches/gcc-kmk/src/kernel32/osliblvm.cpp

    r21583 r21720  
    2121#include <win32type.h>
    2222#include <winconst.h>
    23 #include <win\winioctl.h>
     23#include <win/winioctl.h>
    2424#include "osliblvm.h"
    2525
    … …  
    8989    rc = DosQueryProcAddr(hModLVM, 0, "Write_Sectors", (PFN *)&pfnWrite_Sectors);
    9090    if(rc) goto fail;
    91    
     91
    9292    return TRUE;
    9393
    … …  
    267267    Volume_Control_Array *volctrl;
    268268    CARDINAL32            lasterror;
    269    
     269
    270270    if(!hModLVM) {
    271271        dprintf(("LVM dll not loaded -> fail"));
    … …  
    310310//******************************************************************************
    311311//******************************************************************************
    312 BOOL OSLibLVMQueryVolumeName(HANDLE hVolumeControlData, ULONG *pVolIndex, 
     312BOOL OSLibLVMQueryVolumeName(HANDLE hVolumeControlData, ULONG *pVolIndex,
    313313                             LPSTR lpszVolumeName, DWORD cchBufferLength)
    314314{
    … …  
    346346static Volume_Information_Record OSLibLVMFindVolumeByDriveLetter(ULONG driveLetter,
    347347                                                                 Volume_Control_Record *pVolRec,
    348                                                                  CARDINAL32 *lasterror) 
     348                                                                 CARDINAL32 *lasterror)
    349349{
    350350    Volume_Control_Array      *volctrl;
    … …  
    384384static Volume_Information_Record OSLibLVMFindVolumeByName(LPSTR pszVolName,
    385385                                                          Volume_Control_Record *pVolRec,
    386                                                           CARDINAL32 *lasterror) 
     386                                                          CARDINAL32 *lasterror)
    387387{
    388388    Volume_Control_Array      *volctrl;
    … …  
    564564//            - -1 if volume wasn't found
    565565//            - 0 if volume is present, but not mounted
    566 //   
     566//
    567567//******************************************************************************
    568568CHAR OSLibLVMQueryDriveFromVolumeName(LPCSTR lpszVolume)
    … …  
    596596//******************************************************************************
    597597//******************************************************************************
    598 DWORD OSLibLVMQueryVolumeSerialAndName(LPSTR lpszVolume, LPDWORD lpVolumeSerialNumber, 
     598DWORD OSLibLVMQueryVolumeSerialAndName(LPSTR lpszVolume, LPDWORD lpVolumeSerialNumber,
    599599                                       LPSTR lpVolumeNameBuffer, DWORD nVolumeNameSize)
    600600{
    … …  
    621621//******************************************************************************
    622622//******************************************************************************
    623 BOOL OSLibLVMGetVolumeNameForVolumeMountPoint(LPCSTR lpszVolumeMountPoint, 
    624                                               LPSTR lpszVolumeName, 
     623BOOL OSLibLVMGetVolumeNameForVolumeMountPoint(LPCSTR lpszVolumeMountPoint,
     624                                              LPSTR lpszVolumeName,
    625625                                              DWORD cchBufferLength)
    626626{
    … …  
    665665    strncpy(lpszOS2VolumeName, &lpszWin32VolumeName[sizeof(VOLUME_NAME_PREFIX)-1+1], cchBufferLength-1);  //-zero term + starting '{'
    666666    length -= sizeof(VOLUME_NAME_PREFIX)-1+1;
    667     if(lpszOS2VolumeName[length-2] == '}') 
     667    if(lpszOS2VolumeName[length-2] == '}')
    668668    {
    669669        lpszOS2VolumeName[length-2] = 0;
    … …  
    671671    }
    672672    else
    673     if(lpszOS2VolumeName[length-1] == '}') 
     673    if(lpszOS2VolumeName[length-1] == '}')
    674674    {
    675675        lpszOS2VolumeName[length-1] = 0;

  • branches/gcc-kmk/src/kernel32/osliblvm.h

    r9693 r21720  
    1515#endif
    1616
    17 #include <win\winioctl.h>
     17#include <win/winioctl.h>
    1818
    1919#ifdef OS2_INCLUDED
    … …  
    3030typedef unsigned long      LBA;
    3131
    32 /* Define a Partition Sector Number.  A Partition Sector Number is 
    33    relative to the start of a partition. The first sector in a partition 
     32/* Define a Partition Sector Number.  A Partition Sector Number is
     33   relative to the start of a partition. The first sector in a partition
    3434   is PSN 0. */
    3535typedef unsigned long      PSN;
    … …  
    330330HANDLE OSLibLVMQueryVolumeControlData();
    331331void   OSLibLVMFreeVolumeControlData(HANDLE hVolumeControlData);
    332 BOOL   OSLibLVMQueryVolumeName(HANDLE hVolumeControlData, ULONG *pVolIndex, 
     332BOOL   OSLibLVMQueryVolumeName(HANDLE hVolumeControlData, ULONG *pVolIndex,
    333333                               LPSTR lpszVolumeName, DWORD cchBufferLength);
    334334
    … …  
    338338ULONG  OSLibLVMGetDriveType(LPCSTR lpszVolume);
    339339CHAR   OSLibLVMQueryDriveFromVolumeName(LPCSTR lpszVolume);
    340 BOOL   OSLibLVMGetVolumeNameForVolumeMountPoint(LPCSTR lpszVolumeMountPoint, LPSTR lpszVolumeName, 
     340BOOL   OSLibLVMGetVolumeNameForVolumeMountPoint(LPCSTR lpszVolumeMountPoint, LPSTR lpszVolumeName,
    341341                                                DWORD cchBufferLength);
    342342

  • branches/gcc-kmk/src/kernel32/oslibmem.cpp

    r21711 r21720  
    3131#include <win32api.h>
    3232#include <winconst.h>
    33 #include <win\winioctl.h>
     33#include <win/winioctl.h>
    3434#include <dbglog.h>
    3535#include <vmutex.h>

  • branches/gcc-kmk/src/kernel32/process.cpp

    r21716 r21720  
    2727#include <misc.h>
    2828#include <wprocess.h>
    29 #include <win\task.h>
     29#include <win/task.h>
    3030#include "winimagebase.h"
    3131#include "oslibdos.h"
    … …  
    151151 * GetProcessHeaps [KERNEL32.376]
    152152 */
    153 DWORD WINAPI GetProcessHeaps(DWORD nrofheaps,HANDLE *heaps) 
     153DWORD WINAPI GetProcessHeaps(DWORD nrofheaps,HANDLE *heaps)
    154154{
    155155    dprintf(("GetProcessHeaps: (%ld,%p), incomplete implementation.\n",nrofheaps,heaps));
    … …  
    310310    if ( !process ) return 0;
    311311
    312     switch ( offset ) 
     312    switch ( offset )
    313313    {
    314314    case GPD_APP_COMPAT_FLAGS:
    … …  
    379379
    380380/***********************************************************************
    381  *           ODIN_SetProcessDword   
     381 *           ODIN_SetProcessDword
    382382 *
    383383 * SvL: Special version that allows the caller to change some values
    … …  
    391391    if ( !process ) return;
    392392
    393     switch ( offset ) 
     393    switch ( offset )
    394394    {
    395395    case GPD_STARTF_SHOWWINDOW:
    … …  
    424424    if ( !process ) return;
    425425
    426     switch ( offset ) 
     426    switch ( offset )
    427427    {
    428428    case GPD_APP_COMPAT_FLAGS:
    … …  
    444444
    445445    case GPD_USERDATA:
    446         process->process_dword = value; 
     446        process->process_dword = value;
    447447        break;
    448448
    … …  
    488488  if(!NtdllRtlExtendedIntegerMultiply) {
    489489        HINSTANCE hInstance = LoadLibraryA("NTDLL.DLL");
    490         if(hInstance) 
     490        if(hInstance)
    491491                *(VOID **)&NtdllRtlExtendedIntegerMultiply=(void*)GetProcAddress(hInstance, (LPCSTR)"RtlExtendedIntegerMultiply");
    492492  }

  • branches/gcc-kmk/src/kernel32/virtual.cpp

    r21675 r21720  
    2323#include <stdlib.h>
    2424#include <string.h>
    25 #include <win\virtual.h>
    26 #include <win\thread.h>
     25#include <win/virtual.h>
     26#include <win/thread.h>
    2727#include <heapstring.h>
    2828#include <handlemanager.h>

  • branches/gcc-kmk/src/kernel32/winimagebase.cpp

    r21716 r21720  
    3838#include "initterm.h"
    3939#include "directory.h"
    40 #include <win\virtual.h>
     40#include <win/virtual.h>
    4141#include <winconst.h>
    4242

  • branches/gcc-kmk/src/kernel32/winimagebase.h

    r10397 r21720  
    2020#include <winconst.h>
    2121#else
    22 #include <win\winnls.h>
     22#include <win/winnls.h>
    2323#endif
    2424

  • branches/gcc-kmk/src/kernel32/winimagelx.cpp

    r21716 r21720  
    4242#include "oslibmisc.h"
    4343#include "initterm.h"
    44 #include <win\virtual.h>
     44#include <win/virtual.h>
    4545
    4646#define DBG_LOCALLOG    DBG_winimagelx

  • branches/gcc-kmk/src/kernel32/winimagepeldr.cpp

    r21355 r21720  
    5656#include "oslibmisc.h"
    5757#include "initterm.h"
    58 #include <win\virtual.h>
     58#include <win/virtual.h>
    5959#include "oslibdos.h"
    6060#include "oslibmem.h"

  • branches/gcc-kmk/src/kernel32/wprocess.cpp

    r21673 r21720  
    5252#include "shellapi.h"
    5353
    54 #include <win\ntddk.h>
    55 #include <win\psapi.h>
     54#include <win/ntddk.h>
     55#include <win/psapi.h>
    5656
    5757#include <custombuild.h>
Note: See TracChangeset for help on using the changeset viewer.