Changeset 6060 for trunk/src


Ignore:
Timestamp:
Jun 21, 2001, 11:07:54 PM (24 years ago)
Author:
sandervl
Message:

semaphore updates

Location:
trunk/src/kernel32
Files:
10 edited

Legend:

Unmodified
Added
Removed

  • trunk/src/kernel32/hmdevice.cpp

    r6049 r6060  
    1 /* $Id: hmdevice.cpp,v 1.27 2001-06-19 10:50:23 sandervl Exp $ */
     1/* $Id: hmdevice.cpp,v 1.28 2001-06-21 21:07:53 sandervl Exp $ */
    22
    33/*
    … …  
    983983
    984984
    985 /*****************************************************************************
    986  * Name      : DWORD HMDeviceHandler::WaitForSingleObject
    987  * Purpose   : object synchronization
    988  * Parameters: PHMHANDLEDATA pHMHandleData
    989  *             DWORD dwTimeout
    990  * Variables :
    991  * Result    : API returncode
    992  * Remark    :
    993  * Status    :
    994  *
    995  * Author    : Patrick Haller [Wed, 1999/06/17 20:44]
    996  *****************************************************************************/
    997 
    998 DWORD HMDeviceHandler::WaitForSingleObject(PHMHANDLEDATA pHMHandleData,
    999                                                DWORD         dwTimeout)
    1000 {
    1001   dprintf(("KERNEL32: HandleManager::DeviceHandler::WaitForSingleObject(%08xh,%08h)\n",
    1002            pHMHandleData->hHMHandle,
    1003            dwTimeout));
    1004 
    1005   return(ERROR_INVALID_FUNCTION);
    1006 }
    1007 
    1008 
    1009 /*****************************************************************************
    1010  * Name      : DWORD HMDeviceHandler::WaitForSingleObjectEx
    1011  * Purpose   : object synchronization
    1012  * Parameters: PHMHANDLEDATA pHMHandleData
    1013  *             DWORD dwTimeout
    1014  *             BOOL  fAlertable
    1015  * Variables :
    1016  * Result    : API returncode
    1017  * Remark    :
    1018  * Status    :
    1019  *
    1020  * Author    : Patrick Haller [Wed, 1999/06/17 20:44]
    1021  *****************************************************************************/
    1022 
    1023 DWORD HMDeviceHandler::WaitForSingleObjectEx(PHMHANDLEDATA pHMHandleData,
    1024                                                  DWORD         dwTimeout,
    1025                                                  BOOL          fAlertable)
    1026 {
    1027   dprintf(("KERNEL32: HandleManager::DeviceHandler::WaitForSingleObjectEx(%08xh,%08h,%08xh) not implemented correctly.\n",
    1028            pHMHandleData->hHMHandle,
    1029            dwTimeout,
    1030            fAlertable));
    1031 
    1032   //@@@PH: WARNING mapped to WaitForSingleObject simply. fAlertable missing!
    1033   return(ERROR_INVALID_FUNCTION);
    1034 }
    1035 
    1036985
    1037986/*****************************************************************************
    … …  
    18931842    return(FALSE);
    18941843}
     1844/*****************************************************************************
     1845 * Name      : BOOL HMDeviceHandler::WaitForSingleObject
     1846 * Purpose   :
     1847 * Variables :
     1848 * Result    :
     1849 * Remark    :
     1850 * Status    :
     1851 *
     1852 * Author    : SvL
     1853 *****************************************************************************/
     1854DWORD HMDeviceHandler::WaitForSingleObject(PHMHANDLEDATA pHMHandleData,
     1855                                           DWORD  dwTimeout)
     1856{
     1857    dprintf(("KERNEL32: ERROR: HandleManager::DeviceHandler::WaitForSingleObject %08x %x",
     1858              pHMHandleData->hHMHandle, dwTimeout));
     1859
     1860    return WAIT_FAILED;
     1861}
     1862/*****************************************************************************
     1863 * Name      : BOOL HMDeviceHandler::WaitForSingleObject
     1864 * Purpose   :
     1865 * Variables :
     1866 * Result    :
     1867 * Remark    :
     1868 * Status    :
     1869 *
     1870 * Author    : SvL
     1871 *****************************************************************************/
     1872DWORD HMDeviceHandler::WaitForSingleObjectEx(PHMHANDLEDATA pHMHandleData,
     1873                                             DWORD  dwTimeout,
     1874                                             BOOL   fAlertable)
     1875{
     1876    dprintf(("KERNEL32: ERROR: HandleManager::DeviceHandler::WaitForSingleObjectEx %08x %x %d",
     1877              pHMHandleData->hHMHandle, dwTimeout, fAlertable));
     1878
     1879    return WAIT_FAILED;
     1880}
     1881/*****************************************************************************
     1882 * Name      : BOOL HMDeviceHandler::MsgWaitForMultipleObjects
     1883 * Purpose   :
     1884 * Variables :
     1885 * Result    :
     1886 * Remark    :
     1887 * Status    :
     1888 *
     1889 * Author    : SvL
     1890 *****************************************************************************/
     1891DWORD HMDeviceHandler::MsgWaitForMultipleObjects(PHMHANDLEDATA pHMHandleData,
     1892                                          DWORD      nCount,
     1893                                          LPHANDLE       pHandles,
     1894                                          BOOL       fWaitAll,
     1895                                          DWORD      dwMilliseconds,
     1896                                          DWORD      dwWakeMask)
     1897{
     1898    dprintf(("KERNEL32: ERROR: HandleManager::DeviceHandler::MsgWaitForMultipleObjects %08x %d %x %d %d %x",
     1899              pHMHandleData->hHMHandle, nCount, pHandles, fWaitAll, dwMilliseconds, dwWakeMask));
     1900
     1901    return WAIT_FAILED;
     1902}
     1903/*****************************************************************************
     1904 * Name      : BOOL HMDeviceHandler::WaitForMultipleObjects
     1905 * Purpose   :
     1906 * Variables :
     1907 * Result    :
     1908 * Remark    :
     1909 * Status    :
     1910 *
     1911 * Author    : SvL
     1912 *****************************************************************************/
     1913DWORD HMDeviceHandler::WaitForMultipleObjects (PHMHANDLEDATA pHMHandleData,
     1914                                               DWORD   cObjects,
     1915                                               PHANDLE lphObjects,
     1916                                               BOOL    fWaitAll,
     1917                                               DWORD   dwTimeout)
     1918{
     1919    dprintf(("KERNEL32: ERROR: HandleManager::DeviceHandler::WaitForMultipleObjects %08x %d %x %d %x",
     1920              pHMHandleData->hHMHandle, cObjects, lphObjects, fWaitAll, dwTimeout));
     1921
     1922    return WAIT_FAILED;
     1923}

  • trunk/src/kernel32/hmdevice.h

    r5587 r6060  
    1 /* $Id: hmdevice.h,v 1.26 2001-04-26 13:22:44 sandervl Exp $ */
     1/* $Id: hmdevice.h,v 1.27 2001-06-21 21:07:53 sandervl Exp $ */
    22
    33/*
    … …  
    209209                             LPOVERLAPPED  lpOverlapped);
    210210
    211                 /* this is a handler method for calls to WaitForSingleObject */
     211  /* this is a handler method for calls to WaitForSingleObject */
    212212  virtual DWORD WaitForSingleObject  (PHMHANDLEDATA pHMHandleData,
    213213                                      DWORD  dwTimeout);
    214214
    215               /* this is a handler method for calls to WaitForSingleObjectEx */
     215  /* this is a handler method for calls to WaitForSingleObjectEx */
    216216  virtual DWORD WaitForSingleObjectEx(PHMHANDLEDATA pHMHandleData,
    217217                                      DWORD  dwTimeout,
    218218                                      BOOL   fAlertable);
    219219
     220  virtual DWORD MsgWaitForMultipleObjects(PHMHANDLEDATA pHMHandleData,
     221                                          DWORD      nCount,
     222                                          PHANDLE       pHandles,
     223                                          BOOL       fWaitAll,
     224                                          DWORD      dwMilliseconds,
     225                                          DWORD      dwWakeMask);
     226
     227  virtual DWORD WaitForMultipleObjects (PHMHANDLEDATA pHMHandleData,
     228                                        DWORD   cObjects,
     229                                        PHANDLE lphObjects,
     230                                        BOOL    fWaitAll,
     231                                        DWORD   dwTimeout);
    220232
    221233  /***************************************************************************

  • trunk/src/kernel32/hmevent.cpp

    r6049 r6060  
    1 /* $Id: hmevent.cpp,v 1.5 2001-06-19 10:50:24 sandervl Exp $ */
     1/* $Id: hmevent.cpp,v 1.6 2001-06-21 21:07:53 sandervl Exp $ */
    22
    33/*
    … …  
    3232#ifdef USE_OS2SEMAPHORES
    3333#define INCL_DOSSEMAPHORES
     34#define INCL_DOSERRORS
    3435#include <os2wrap.h>
    3536#include <win32type.h>
    … …  
    111112  //unblocked and the app must manually reset the event semaphore
    112113  //Automatic reset -> only one waiting thread unblocked & state reset
    113   rc = DosCreateEventSem(lpszEventName, &hev, (fManualReset) ? 0 : DCE_POSTONE, fInitialState);
     114  rc = DosCreateEventSem(lpszEventName, &hev, (fManualReset) ? 0 : (DCE_POSTONE|DCE_AUTORESET), fInitialState);
    114115
    115116  if(rc) {
    … …  
    292293#endif
    293294
     295#ifdef USE_OS2SEMAPHORES
     296/*****************************************************************************
     297 * Name      : DWORD HMDeviceEventClass::WaitForSingleObject
     298 * Purpose   : object synchronization
     299 * Parameters: PHMHANDLEDATA pHMHandleData
     300 *             DWORD dwTimeout
     301 * Variables :
     302 * Result    : API returncode
     303 * Remark    :
     304 * Status    :
     305 *
     306 * Author    : SvL
     307 *****************************************************************************/
     308
     309DWORD HMDeviceEventClass::WaitForSingleObject(PHMHANDLEDATA pHMHandleData,
     310                                              DWORD         dwTimeout)
     311{
     312 DWORD rc;
     313
     314  dprintf2(("KERNEL32: HMDeviceEventClass::WaitForSingleObject(%08xh %08xh)",
     315            pHMHandleData->hHMHandle, dwTimeout));
     316
     317  if(!(pHMHandleData->dwAccess & SYNCHRONIZE_W) )
     318  {
     319      dprintf(("ERROR: Access denied!!"));
     320      SetLastError(ERROR_ACCESS_DENIED_W);
     321      return WAIT_FAILED_W;
     322  }
     323
     324  rc = DosWaitEventSem(pHMHandleData->hHMHandle, dwTimeout);
     325  if(rc && rc != ERROR_INTERRUPT && rc != ERROR_TIMEOUT && rc != ERROR_SEM_OWNER_DIED) {
     326      dprintf(("DosWaitEventSem %x failed with rc %d", pHMHandleData->hHMHandle, rc));
     327      SetLastError(error2WinError(rc));
     328      return WAIT_FAILED_W;
     329  }
     330  SetLastError(ERROR_SUCCESS_W);
     331  if(rc == ERROR_INTERRUPT || rc == ERROR_SEM_OWNER_DIED) {
     332      return WAIT_ABANDONED_W;
     333  }
     334  else
     335  if(rc == ERROR_TIMEOUT) {
     336      return WAIT_TIMEOUT_W;
     337  }
     338  return WAIT_OBJECT_0_W;
     339}
     340#endif
     341
     342#ifdef USE_OS2SEMAPHORES
     343/*****************************************************************************
     344 * Name      : DWORD HMDeviceEventClass::WaitForSingleObjectEx
     345 * Purpose   : object synchronization
     346 * Parameters: PHMHANDLEDATA pHMHandleData
     347 *             DWORD dwTimeout
     348 *             BOOL  fAlertable
     349 * Variables :
     350 * Result    : API returncode
     351 * Remark    :
     352 * Status    :
     353 *
     354 * Author    : SvL
     355 *****************************************************************************/
     356
     357DWORD HMDeviceEventClass::WaitForSingleObjectEx(PHMHANDLEDATA pHMHandleData,
     358                                                DWORD         dwTimeout,
     359                                                BOOL          fAlertable)
     360{
     361  dprintf2(("KERNEL32: HMDeviceEventClass::WaitForSingleObjectEx(%08xh,%08h,%08xh) not implemented correctly.\n",
     362            pHMHandleData->hHMHandle, dwTimeout, fAlertable));
     363
     364  if(!(pHMHandleData->dwAccess & SYNCHRONIZE_W) )
     365  {
     366      dprintf(("ERROR: Access denied!!"));
     367      SetLastError(ERROR_ACCESS_DENIED_W);
     368      return WAIT_FAILED_W;
     369  }
     370
     371  return WaitForSingleObject(pHMHandleData, dwTimeout);
     372}
     373#endif
     374
     375#ifdef USE_OS2SEMAPHORES
     376/*****************************************************************************
     377 * Name      : BOOL HMDeviceEventClass::MsgWaitForMultipleObjects
     378 * Purpose   :
     379 * Variables :
     380 * Result    :
     381 * Remark    :
     382 * Status    :
     383 *
     384 * Author    : SvL
     385 *****************************************************************************/
     386DWORD HMDeviceEventClass::MsgWaitForMultipleObjects(PHMHANDLEDATA pHMHandleData,
     387                                                    DWORD      nCount,
     388                                                    PHANDLE    pHandles,
     389                                                    BOOL       fWaitAll,
     390                                                    DWORD      dwMilliseconds,
     391                                                    DWORD      dwWakeMask)
     392{
     393    dprintf(("KERNEL32: ERROR: HandleManager::DeviceHandler::MsgWaitForMultipleObjects %08x %d %x %d %d %x",
     394              pHMHandleData->hHMHandle, nCount, pHandles, fWaitAll, dwMilliseconds, dwWakeMask));
     395
     396    if(!(pHMHandleData->dwAccess & SYNCHRONIZE_W) )
     397    {
     398        dprintf(("ERROR: Access denied!!"));
     399        SetLastError(ERROR_ACCESS_DENIED_W);
     400        return WAIT_FAILED_W;
     401    }
     402
     403    return WAIT_FAILED_W;
     404}
     405#endif
     406
     407#ifdef USE_OS2SEMAPHORES
     408/*****************************************************************************
     409 * Name      : BOOL HMDeviceHandler::WaitForMultipleObjects
     410 * Purpose   :
     411 * Variables :
     412 * Result    :
     413 * Remark    :
     414 * Status    :
     415 *
     416 * Author    : SvL
     417 *****************************************************************************/
     418DWORD HMDeviceEventClass::WaitForMultipleObjects(PHMHANDLEDATA pHMHandleData,
     419                                                 DWORD   cObjects,
     420                                                 PHANDLE lphObjects,
     421                                                 BOOL    fWaitAll,
     422                                                 DWORD   dwTimeout)
     423{
     424    dprintf(("KERNEL32: ERROR: HandleManager::DeviceHandler::WaitForMultipleObjects %08x %d %x %d %x",
     425              pHMHandleData->hHMHandle, cObjects, lphObjects, fWaitAll, dwTimeout));
     426
     427    if(!(pHMHandleData->dwAccess & SYNCHRONIZE_W) )
     428    {
     429        dprintf(("ERROR: Access denied!!"));
     430        SetLastError(ERROR_ACCESS_DENIED_W);
     431        return WAIT_FAILED_W;
     432    }
     433
     434    return WAIT_FAILED_W;
     435}
     436#endif
     437
    294438/*****************************************************************************
    295439 * Name      : HMSetEvent

  • trunk/src/kernel32/hmevent.h

    r6049 r6060  
    1 /* $Id: hmevent.h,v 1.3 2001-06-19 10:50:24 sandervl Exp $ */
     1/* $Id: hmevent.h,v 1.4 2001-06-21 21:07:53 sandervl Exp $ */
    22
    33/*
    … …  
    3636{
    3737public:
     38#ifdef USE_OS2SEMAPHORES
     39  HMDeviceEventClass(LPCSTR lpDeviceName) : HMDeviceHandler(lpDeviceName) {}
     40#else
    3841  HMDeviceEventClass(LPCSTR lpDeviceName) : HMDeviceOpen32Class(lpDeviceName) {}
     42#endif
    3943
    4044  /* this is a handler method for calls to CreateEvent() */
    … …  
    5660                               DWORD   fdwOptions,
    5761                               DWORD   fdwOdinOptions);
     62
     63  /* this is a handler method for calls to WaitForSingleObject */
     64  virtual DWORD WaitForSingleObject  (PHMHANDLEDATA pHMHandleData,
     65                                      DWORD  dwTimeout);
     66
     67  /* this is a handler method for calls to WaitForSingleObjectEx */
     68  virtual DWORD WaitForSingleObjectEx(PHMHANDLEDATA pHMHandleData,
     69                                      DWORD  dwTimeout,
     70                                      BOOL   fAlertable);
     71
     72  virtual DWORD MsgWaitForMultipleObjects(PHMHANDLEDATA pHMHandleData,
     73                                          DWORD      nCount,
     74                                          PHANDLE       pHandles,
     75                                          BOOL       fWaitAll,
     76                                          DWORD      dwMilliseconds,
     77                                          DWORD      dwWakeMask);
     78
     79  virtual DWORD WaitForMultipleObjects (PHMHANDLEDATA pHMHandleData,
     80                                        DWORD   cObjects,
     81                                        PHANDLE lphObjects,
     82                                        BOOL    fWaitAll,
     83                                        DWORD   dwTimeout);
     84
    5885#endif
    5986 

  • trunk/src/kernel32/hmmutex.cpp

    r6049 r6060  
    1 /* $Id: hmmutex.cpp,v 1.4 2001-06-19 10:50:25 sandervl Exp $ */
     1/* $Id: hmmutex.cpp,v 1.5 2001-06-21 21:07:53 sandervl Exp $ */
    22
    33/*
    … …  
    3131#ifdef USE_OS2SEMAPHORES
    3232#define INCL_DOSSEMAPHORES
     33#define INCL_DOSERRORS
    3334#include <os2wrap.h>
    3435#include <win32type.h>
    … …  
    273274#endif
    274275
     276
     277#ifdef USE_OS2SEMAPHORES
     278/*****************************************************************************
     279 * Name      : DWORD HMDeviceOpen32Class::WaitForSingleObject
     280 * Purpose   : object synchronization
     281 * Parameters: PHMHANDLEDATA pHMHandleData
     282 *             DWORD dwTimeout
     283 * Variables :
     284 * Result    : API returncode
     285 * Remark    :
     286 * Status    :
     287 *
     288 * Author    : Patrick Haller [Wed, 1999/06/17 20:44]
     289 *****************************************************************************/
     290
     291DWORD HMDeviceMutexClass::WaitForSingleObject(PHMHANDLEDATA pHMHandleData,
     292                                              DWORD         dwTimeout)
     293{
     294 DWORD rc;
     295
     296  dprintf2(("KERNEL32: HMDeviceMutexClass::WaitForSingleObject(%08xh %08xh)",
     297            pHMHandleData->hHMHandle, dwTimeout));
     298
     299  if(!(pHMHandleData->dwAccess & SYNCHRONIZE_W) )
     300  {
     301      dprintf(("ERROR: Access denied!!"));
     302      SetLastError(ERROR_ACCESS_DENIED_W);
     303      return FALSE;
     304  }
     305
     306  rc = DosRequestMutexSem(pHMHandleData->hHMHandle, dwTimeout);
     307  if(rc && rc != ERROR_INTERRUPT && rc != ERROR_TIMEOUT && rc != ERROR_SEM_OWNER_DIED) {
     308      dprintf(("DosWaitEventSem %x failed with rc %d", pHMHandleData->hHMHandle, rc));
     309      SetLastError(error2WinError(rc));
     310      return WAIT_FAILED_W;
     311  }
     312  SetLastError(ERROR_SUCCESS_W);
     313  if(rc == ERROR_INTERRUPT || rc == ERROR_SEM_OWNER_DIED) {
     314      return WAIT_ABANDONED_W;
     315  }
     316  else
     317  if(rc == ERROR_TIMEOUT) {
     318      return WAIT_TIMEOUT_W;
     319  }
     320  return WAIT_OBJECT_0_W;
     321}
     322#endif
     323
     324#ifdef USE_OS2SEMAPHORES
     325/*****************************************************************************
     326 * Name      : DWORD HMDeviceOpen32Class::WaitForSingleObjectEx
     327 * Purpose   : object synchronization
     328 * Parameters: PHMHANDLEDATA pHMHandleData
     329 *             DWORD dwTimeout
     330 *             BOOL  fAlertable
     331 * Variables :
     332 * Result    : API returncode
     333 * Remark    :
     334 * Status    :
     335 *
     336 * Author    : Patrick Haller [Wed, 1999/06/17 20:44]
     337 *****************************************************************************/
     338
     339DWORD HMDeviceMutexClass::WaitForSingleObjectEx(PHMHANDLEDATA pHMHandleData,
     340                                                DWORD         dwTimeout,
     341                                                BOOL          fAlertable)
     342{
     343  dprintf2(("KERNEL32: HMDeviceMutexClass::WaitForSingleObjectEx(%08xh,%08h,%08xh) not implemented correctly.\n",
     344            pHMHandleData->hHMHandle, dwTimeout, fAlertable));
     345
     346  if(!(pHMHandleData->dwAccess & SYNCHRONIZE_W) )
     347  {
     348      dprintf(("ERROR: Access denied!!"));
     349      SetLastError(ERROR_ACCESS_DENIED_W);
     350      return WAIT_FAILED_W;
     351  }
     352
     353  return WaitForSingleObject(pHMHandleData, dwTimeout);
     354}
     355#endif
     356
     357#ifdef USE_OS2SEMAPHORES
     358/*****************************************************************************
     359 * Name      : BOOL HMDeviceMutexClass::MsgWaitForMultipleObjects
     360 * Purpose   :
     361 * Variables :
     362 * Result    :
     363 * Remark    :
     364 * Status    :
     365 *
     366 * Author    : SvL
     367 *****************************************************************************/
     368DWORD HMDeviceMutexClass::MsgWaitForMultipleObjects(PHMHANDLEDATA pHMHandleData,
     369                                                    DWORD      nCount,
     370                                                    PHANDLE    pHandles,
     371                                                    BOOL       fWaitAll,
     372                                                    DWORD      dwMilliseconds,
     373                                                    DWORD      dwWakeMask)
     374{
     375    dprintf(("KERNEL32: ERROR: HandleManager::DeviceHandler::MsgWaitForMultipleObjects %08x %d %x %d %d %x",
     376              pHMHandleData->hHMHandle, nCount, pHandles, fWaitAll, dwMilliseconds, dwWakeMask));
     377
     378    if(!(pHMHandleData->dwAccess & SYNCHRONIZE_W) )
     379    {
     380        dprintf(("ERROR: Access denied!!"));
     381        SetLastError(ERROR_ACCESS_DENIED_W);
     382        return WAIT_FAILED_W;
     383    }
     384    return WAIT_FAILED_W;
     385}
     386#endif
     387
     388#ifdef USE_OS2SEMAPHORES
     389/*****************************************************************************
     390 * Name      : BOOL HMDeviceMutexClass::WaitForMultipleObjects
     391 * Purpose   :
     392 * Variables :
     393 * Result    :
     394 * Remark    :
     395 * Status    :
     396 *
     397 * Author    : SvL
     398 *****************************************************************************/
     399DWORD HMDeviceMutexClass::WaitForMultipleObjects(PHMHANDLEDATA pHMHandleData,
     400                                                 DWORD   cObjects,
     401                                                 PHANDLE lphObjects,
     402                                                 BOOL    fWaitAll,
     403                                                 DWORD   dwTimeout)
     404{
     405    dprintf(("KERNEL32: ERROR: HandleManager::DeviceHandler::WaitForMultipleObjects %08x %d %x %d %x",
     406              pHMHandleData->hHMHandle, cObjects, lphObjects, fWaitAll, dwTimeout));
     407
     408    if(!(pHMHandleData->dwAccess & SYNCHRONIZE_W) )
     409    {
     410        dprintf(("ERROR: Access denied!!"));
     411        SetLastError(ERROR_ACCESS_DENIED_W);
     412        return WAIT_FAILED_W;
     413    }
     414    return WAIT_FAILED_W;
     415}
     416#endif
     417
    275418/*****************************************************************************
    276419 * Name      : HMReleaseMutex

  • trunk/src/kernel32/hmmutex.h

    r6049 r6060  
    1 /* $Id: hmmutex.h,v 1.3 2001-06-19 10:50:25 sandervl Exp $ */
     1/* $Id: hmmutex.h,v 1.4 2001-06-21 21:07:54 sandervl Exp $ */
    22
    33/*
    … …  
    3636{
    3737public:
     38#ifdef USE_OS2SEMAPHORES
     39  HMDeviceMutexClass(LPCSTR lpDeviceName) : HMDeviceHandler(lpDeviceName) {}
     40#else
    3841  HMDeviceMutexClass(LPCSTR lpDeviceName) : HMDeviceOpen32Class(lpDeviceName) {}
     42#endif
    3943
    4044  /* this is a handler method for calls to CreateMutex() */
    … …  
    6064                               DWORD   fdwOptions,
    6165                               DWORD   fdwOdinOptions);
     66
     67  /* this is a handler method for calls to WaitForSingleObject */
     68  virtual DWORD WaitForSingleObject  (PHMHANDLEDATA pHMHandleData,
     69                                      DWORD  dwTimeout);
     70
     71  /* this is a handler method for calls to WaitForSingleObjectEx */
     72  virtual DWORD WaitForSingleObjectEx(PHMHANDLEDATA pHMHandleData,
     73                                      DWORD  dwTimeout,
     74                                      BOOL   fAlertable);
     75
     76  virtual DWORD MsgWaitForMultipleObjects(PHMHANDLEDATA pHMHandleData,
     77                                          DWORD      nCount,
     78                                          PHANDLE       pHandles,
     79                                          BOOL       fWaitAll,
     80                                          DWORD      dwMilliseconds,
     81                                          DWORD      dwWakeMask);
     82
     83  virtual DWORD WaitForMultipleObjects (PHMHANDLEDATA pHMHandleData,
     84                                        DWORD   cObjects,
     85                                        PHANDLE lphObjects,
     86                                        BOOL    fWaitAll,
     87                                        DWORD   dwTimeout);
    6288#endif
    6389                               

  • trunk/src/kernel32/hmsemaphore.cpp

    r6049 r6060  
    1 /* $Id: hmsemaphore.cpp,v 1.4 2001-06-19 10:50:25 sandervl Exp $ */
     1/* $Id: hmsemaphore.cpp,v 1.5 2001-06-21 21:07:54 sandervl Exp $ */
    22
    33/*
    … …  
    88 * TODO: No inheritance when CreateSemaphore is called for existing named event semaphore?
    99 *       (see HMCreateSemaphore in handlemanager.cpp)
     10 * TODO: OpenSemaphore does not work right now! initialcount/maximumcount)
    1011 * TODO: Name collisions with files & mutex not allowed. Check if this can happen in OS/2
    1112 * TODO: Does NOT work for sharing semaphores between processes!!
    … …  
    3334#ifdef USE_OS2SEMAPHORES
    3435#define INCL_DOSSEMAPHORES
     36#define INCL_DOSERRORS
    3537#include <os2wrap.h>
    3638#include <win32type.h>
    … …  
    115117      lpszSemaphoreName = szSemName;
    116118  }
    117   //Manual reset means all threads waiting on the event semaphore will be
    118   //unblocked and the app must manually reset the event semaphore
    119   //Automatic reset -> only one waiting thread unblocked & state reset
    120119  rc = DosCreateEventSem(lpszSemaphoreName, &hev, DCE_POSTONE, lInitialCount);
    121120
    … …  
    127126  pHMHandleData->dwAccess  = SEMAPHORE_ALL_ACCESS_W;
    128127  pHMHandleData->dwFlags   = lMaximumCount;
     128  pHMHandleData->dwCreation= lInitialCount;
    129129  pHMHandleData->hHMHandle = hev;
    130130  return ERROR_SUCCESS_W;
    … …  
    176176  char szSemName[CCHMAXPATH];
    177177
     178  //TODO: NOT WORKING (initialcount/maximumcount)
    178179  dprintf(("KERNEL32: HandleManager::Semaphore::OpenSemaphore(%08xh,%08xh,%s)\n",
    179180           pHMHandleData,
    … …  
    293294  }
    294295  pHMHandleData->dwAccess  = fdwAccess;
    295   pHMHandleData->dwFlags   = pHMSrcHandle->dwFlags; //lMaximumCount;
     296  pHMHandleData->dwFlags   = pHMSrcHandle->dwFlags;    //lMaximumCount;
     297  pHMHandleData->dwCreation= pHMSrcHandle->dwCreation; //lInitialCount;
    296298  pHMHandleData->hHMHandle = hev;
    297299  SetLastError(ERROR_SUCCESS_W);
    298300  return TRUE;
     301}
     302#endif
     303
     304#ifdef USE_OS2SEMAPHORES
     305/*****************************************************************************
     306 * Name      : DWORD HMDeviceSemaphoreClass::WaitForSingleObject
     307 * Purpose   : object synchronization
     308 * Parameters: PHMHANDLEDATA pHMHandleData
     309 *             DWORD dwTimeout
     310 * Variables :
     311 * Result    : API returncode
     312 * Remark    :
     313 * Status    :
     314 *
     315 * Author    : SvL
     316 *****************************************************************************/
     317
     318DWORD HMDeviceSemaphoreClass::WaitForSingleObject(PHMHANDLEDATA pHMHandleData,
     319                                               DWORD         dwTimeout)
     320{
     321 DWORD rc;
     322
     323  dprintf2(("KERNEL32: HMDeviceSemaphoreClass::WaitForSingleObject(%08xh %08xh)",
     324            pHMHandleData->hHMHandle, dwTimeout));
     325
     326  if(!(pHMHandleData->dwAccess & SYNCHRONIZE_W) )
     327  {
     328      dprintf(("ERROR: Access denied!!"));
     329      SetLastError(ERROR_ACCESS_DENIED_W);
     330      return WAIT_FAILED_W;
     331  }
     332
     333  rc = DosWaitEventSem(pHMHandleData->hHMHandle, dwTimeout);
     334  if(rc && rc != ERROR_INTERRUPT && rc != ERROR_TIMEOUT && rc != ERROR_SEM_OWNER_DIED) {
     335      dprintf(("DosWaitEventSem %x failed with rc %d", pHMHandleData->hHMHandle, rc));
     336      SetLastError(error2WinError(rc));
     337      return WAIT_FAILED_W;
     338  }
     339  SetLastError(ERROR_SUCCESS_W);
     340  if(rc == ERROR_INTERRUPT || rc == ERROR_SEM_OWNER_DIED) {
     341      return WAIT_ABANDONED_W;
     342  }
     343  else
     344  if(rc == ERROR_TIMEOUT) {
     345      return WAIT_TIMEOUT_W;
     346  }
     347  return WAIT_OBJECT_0_W;
     348}
     349#endif
     350
     351#ifdef USE_OS2SEMAPHORES
     352/*****************************************************************************
     353 * Name      : DWORD HMDeviceSemaphoreClass::WaitForSingleObjectEx
     354 * Purpose   : object synchronization
     355 * Parameters: PHMHANDLEDATA pHMHandleData
     356 *             DWORD dwTimeout
     357 *             BOOL  fAlertable
     358 * Variables :
     359 * Result    : API returncode
     360 * Remark    :
     361 * Status    :
     362 *
     363 * Author    : SvL
     364 *****************************************************************************/
     365
     366DWORD HMDeviceSemaphoreClass::WaitForSingleObjectEx(PHMHANDLEDATA pHMHandleData,
     367                                                 DWORD         dwTimeout,
     368                                                 BOOL          fAlertable)
     369{
     370    dprintf2(("KERNEL32: HMDeviceSemaphoreClass::WaitForSingleObjectEx(%08xh,%08h,%08xh) not implemented correctly.\n",
     371              pHMHandleData->hHMHandle, dwTimeout, fAlertable));
     372
     373    if(!(pHMHandleData->dwAccess & SYNCHRONIZE_W) )
     374    {
     375        dprintf(("ERROR: Access denied!!"));
     376        SetLastError(ERROR_ACCESS_DENIED_W);
     377        return WAIT_FAILED_W;
     378    }
     379
     380    return WaitForSingleObject(pHMHandleData, dwTimeout);
     381}
     382#endif
     383
     384#ifdef USE_OS2SEMAPHORES
     385/*****************************************************************************
     386 * Name      : BOOL HMDeviceSemaphoreClass::MsgWaitForMultipleObjects
     387 * Purpose   :
     388 * Variables :
     389 * Result    :
     390 * Remark    :
     391 * Status    :
     392 *
     393 * Author    : SvL
     394 *****************************************************************************/
     395DWORD HMDeviceSemaphoreClass::MsgWaitForMultipleObjects(PHMHANDLEDATA pHMHandleData,
     396                                                        DWORD      nCount,
     397                                                        PHANDLE    pHandles,
     398                                                        BOOL       fWaitAll,
     399                                                        DWORD      dwMilliseconds,
     400                                                        DWORD      dwWakeMask)
     401{
     402    dprintf(("KERNEL32: ERROR: HandleManager::DeviceHandler::MsgWaitForMultipleObjects %08x %d %x %d %d %x",
     403              pHMHandleData->hHMHandle, nCount, pHandles, fWaitAll, dwMilliseconds, dwWakeMask));
     404
     405    if(!(pHMHandleData->dwAccess & SYNCHRONIZE_W) )
     406    {
     407        dprintf(("ERROR: Access denied!!"));
     408        SetLastError(ERROR_ACCESS_DENIED_W);
     409        return WAIT_FAILED_W;
     410    }
     411
     412    return WAIT_FAILED_W;
     413}
     414#endif
     415
     416#ifdef USE_OS2SEMAPHORES
     417/*****************************************************************************
     418 * Name      : BOOL HMDeviceSemaphoreClass::WaitForMultipleObjects
     419 * Purpose   :
     420 * Variables :
     421 * Result    :
     422 * Remark    :
     423 * Status    :
     424 *
     425 * Author    : SvL
     426 *****************************************************************************/
     427DWORD HMDeviceSemaphoreClass::WaitForMultipleObjects(PHMHANDLEDATA pHMHandleData,
     428                                                 DWORD   cObjects,
     429                                                 PHANDLE lphObjects,
     430                                                 BOOL    fWaitAll,
     431                                                 DWORD   dwTimeout)
     432{
     433    dprintf(("KERNEL32: ERROR: HandleManager::DeviceHandler::WaitForMultipleObjects %08x %d %x %d %x",
     434              pHMHandleData->hHMHandle, cObjects, lphObjects, fWaitAll, dwTimeout));
     435
     436    if(!(pHMHandleData->dwAccess & SYNCHRONIZE_W) )
     437    {
     438        dprintf(("ERROR: Access denied!!"));
     439        SetLastError(ERROR_ACCESS_DENIED_W);
     440        return WAIT_FAILED_W;
     441    }
     442
     443    return WAIT_FAILED_W;
    299444}
    300445#endif

  • trunk/src/kernel32/hmsemaphore.h

    r6049 r6060  
    1 /* $Id: hmsemaphore.h,v 1.3 2001-06-19 10:50:25 sandervl Exp $ */
     1/* $Id: hmsemaphore.h,v 1.4 2001-06-21 21:07:54 sandervl Exp $ */
    22
    33/*
    … …  
    3636{
    3737public:
     38#ifdef USE_OS2SEMAPHORES
     39  HMDeviceSemaphoreClass(LPCSTR lpDeviceName) : HMDeviceHandler(lpDeviceName) {}
     40#else
    3841  HMDeviceSemaphoreClass(LPCSTR lpDeviceName) : HMDeviceOpen32Class(lpDeviceName) {}
     42#endif
    3943
    4044  /* this is a handler method for calls to CreateSemaphore() */
    … …  
    6165                               DWORD   fdwOptions,
    6266                               DWORD   fdwOdinOptions);
     67
     68  /* this is a handler method for calls to WaitForSingleObject */
     69  virtual DWORD WaitForSingleObject  (PHMHANDLEDATA pHMHandleData,
     70                                      DWORD  dwTimeout);
     71
     72  /* this is a handler method for calls to WaitForSingleObjectEx */
     73  virtual DWORD WaitForSingleObjectEx(PHMHANDLEDATA pHMHandleData,
     74                                      DWORD  dwTimeout,
     75                                      BOOL   fAlertable);
     76
     77  virtual DWORD MsgWaitForMultipleObjects(PHMHANDLEDATA pHMHandleData,
     78                                          DWORD      nCount,
     79                                          PHANDLE       pHandles,
     80                                          BOOL       fWaitAll,
     81                                          DWORD      dwMilliseconds,
     82                                          DWORD      dwWakeMask);
     83
     84  virtual DWORD WaitForMultipleObjects (PHMHANDLEDATA pHMHandleData,
     85                                        DWORD   cObjects,
     86                                        PHANDLE lphObjects,
     87                                        BOOL    fWaitAll,
     88                                        DWORD   dwTimeout);
     89
    6390#endif
    6491

  • trunk/src/kernel32/kernel32.mak

    r5830 r6060  
    1 # $Id: kernel32.mak,v 1.6 2001-05-30 01:36:07 phaller Exp $
     1# $Id: kernel32.mak,v 1.7 2001-06-21 21:07:54 sandervl Exp $
    22
    33#
    … …  
    1616#
    1717!include ../../makefile.inc
     18
     19#
     20# Overrides.
     21#
     22##CDEFINES    = $(CDEFINES) -DUSE_OS2SEMAPHORES
     23
    1824
    1925#

  • trunk/src/kernel32/oslibdos.cpp

    r6053 r6060  
    1 /* $Id: oslibdos.cpp,v 1.67 2001-06-20 20:51:58 sandervl Exp $ */
     1/* $Id: oslibdos.cpp,v 1.68 2001-06-21 21:07:54 sandervl Exp $ */
    22/*
    33 * Wrappers for OS/2 Dos* API
    … …  
    134134
    135135    case ERROR_INVALID_ACCESS: //12
    136       return ERROR_INVALID_ACCESS_W;
     136        return ERROR_INVALID_ACCESS_W;
    137137
    138138    case ERROR_NO_MORE_FILES: //18
    … …  
    177177    case ERROR_DEVICE_IN_USE: //99
    178178        return ERROR_DEVICE_IN_USE_W;
     179
     180    case ERROR_TOO_MANY_SEMAPHORES: //100
     181        return ERROR_TOO_MANY_SEMAPHORES_W;
    179182
    180183    case ERROR_DRIVE_LOCKED: //108
Note: See TracChangeset for help on using the changeset viewer.