home *** CD-ROM | disk | FTP | other *** search
/ OS/2 Shareware BBS: 10 Tools / 10-Tools.zip / threads.zip / ievntsem.cpp < prev    next >
Text File  |  1995-10-09  |  9KB  |  277 lines
  1. /*******************************************************************************
  2. * FILE NAME: IEVNTSEM.CPP
  3. *
  4. * DESCRIPTION:
  5. *   This file contains implementation of the class IEventSem.
  6. *
  7. * COPYRIGHT:
  8. *   Licensed Materials - Property of IBM
  9. *   (C) Copyright IBM Corporation 1995
  10. *   All Rights Reserved
  11. *   US Government Users Restricted Rights - Use, duplication, or disclosure
  12. *   restricted by GSA ADP Schedule Contract with IBM Corp.
  13. *
  14. *******************************************************************************/
  15.  
  16.  #define INCL_DOSSEMAPHORES
  17.  #define INCL_DOSERRORS
  18.  #define INCL_DOSPROCESS
  19.  #include <os2.h>
  20.  #include <stdio.h>
  21.  #include <string.h>
  22.  
  23.  #include <iexcept.hpp>
  24.  #include <istring.hpp>
  25.  #include <ihandle.hpp>
  26.  #include <ievntsem.hpp>
  27.  
  28. // Define the functions and static data members to be exported.
  29. // Ordinals 150 through 199 are reserved for use by IEventSem.
  30. #pragma export(IEventSem::handle(),, 150)
  31. #pragma export(IEventSem::IEventSem(const IString&,IEventSem::SemOperation),, 151)
  32. #pragma export(IEventSem::IEventSem(),, 152)
  33. #pragma export(IEventSem::IEventSem(ISemaphoreHandle&),, 153)
  34. #pragma export(IEventSem::name(),, 154)
  35. #pragma export(IEventSem::post(),, 155)
  36. #pragma export(IEventSem::postCount(),, 156)
  37. #pragma export(IEventSem::reset(),, 157)
  38. #pragma export(IEventSem::type(),, 158)
  39. #pragma export(IEventSem::wait(long),, 159)
  40. #pragma export(IEventSem::~IEventSem(),, 160)
  41.  
  42. // It's possible for the caller of the external entry points to have a
  43. // different C library environment.  Make sure the exception handler for
  44. // our library environment is registered on entry and deregistered on exit.
  45. #pragma handler(IEventSem::handle())
  46. #pragma handler(IEventSem::IEventSem(const IString&,IEventSem::SemOperation))
  47. #pragma handler(IEventSem::IEventSem())
  48. #pragma handler(IEventSem::IEventSem(ISemaphoreHandle&))
  49. #pragma handler(IEventSem::name())
  50. #pragma handler(IEventSem::post())
  51. #pragma handler(IEventSem::postCount())
  52. #pragma handler(IEventSem::reset())
  53. #pragma handler(IEventSem::type())
  54. #pragma handler(IEventSem::wait())
  55. #pragma handler(IEventSem::wait(long))
  56. #pragma handler(IEventSem::~IEventSem())
  57.  
  58.  
  59. IEventSem :: IEventSem( const IString& semName, SemOperation semOp):
  60.                szName( *(new IString("\\SEM32\\" + semName)) )
  61.    {
  62.     long      rc = 0;
  63.     HEV       handle = 0;          // no handle yet.
  64.  
  65.     if ( semOp == createSem )
  66.        {
  67.          // Semaphore is public (i.e. SHARED)
  68.          // and initial semaphore state is "set" (i.e. FALSE)
  69.          // If a name was specified, then the semaphore is named.
  70.          semType = created;
  71.          if ( semName.length() != 0)
  72.           {
  73.            rc = (long) DosCreateEventSem( (PSZ)szName,
  74.                                           &handle,
  75.                                           DC_SEM_SHARED,
  76.                                           FALSE );
  77.           }
  78.          else
  79.           {
  80.            rc = (long) DosCreateEventSem( (PSZ)0,
  81.                                           &handle,
  82.                                           DC_SEM_SHARED,
  83.                                           FALSE );
  84.            IString nullStr;
  85.            szName = nullStr;
  86.           }
  87.  
  88.         if ( rc != 0 )
  89.           {
  90.            ITHROWSYSTEMERROR( rc,
  91.                               "DosCreateEventSem",
  92.                               IErrorInfo::accessError,
  93.                               IException::recoverable) ;
  94.           }
  95.        }  //end if Creating semaphore
  96.     else
  97.        {
  98.         // Open an existing semaphore.
  99.         semType = opened;
  100.         rc = (long) DosOpenEventSem( (PSZ)szName,
  101.                                       &handle );
  102.         if ( rc != 0 )
  103.           {
  104.            ITHROWSYSTEMERROR( rc,
  105.                               "DosOpenEventSem",
  106.                               IErrorInfo::accessError,
  107.                               IException::recoverable) ;
  108.           }
  109.        }  //end else Opening semaphore
  110.  
  111.     hndlSem = new ISemaphoreHandle( handle);
  112.     return;
  113.    }
  114.  
  115.  /*----------------------------*/
  116. IEventSem :: IEventSem( ):
  117.                szName( *(new IString("")) )
  118.    {
  119.                                    // an unnamed semaphore here.
  120.     long      rc = 0;
  121.     HEV       handle = 0;          // no handle yet.
  122.  
  123.      // Semaphore is unnamed, private
  124.      // and initial semaphore state is "set" (i.e. FALSE)
  125.      semType = localRam;
  126.      rc = (long) DosCreateEventSem( (PSZ)0,
  127.                                     &handle,
  128.                                     0,
  129.                                     FALSE );
  130.      if ( rc != 0 )
  131.        {
  132.         ITHROWSYSTEMERROR( rc,
  133.                            "DosCreateEventSem",
  134.                            IErrorInfo::accessError,
  135.                            IException::recoverable) ;
  136.        }
  137.  
  138.     hndlSem = new ISemaphoreHandle( handle);
  139.     return;
  140.    }
  141.  
  142.  
  143.  /*----------------------------*/
  144. IEventSem :: IEventSem( ISemaphoreHandle& handle):
  145.                szName( *(new IString("")) )
  146.    {
  147.                                    // a previously created, unnammed semaphore.
  148.     long     rc;
  149.     HEV      hand = handle;        // handle as passed in.
  150.  
  151.     // Semaphore is unnamed.
  152.     // and initial semaphore state is "set" (i.e. FALSE)
  153.     semType = opened;
  154.     rc = (long) DosOpenEventSem( (PSZ)0,
  155.                                  &hand );
  156.     if ( rc != 0 )
  157.       {
  158.        ITHROWSYSTEMERROR( rc,
  159.                           "DosOpenEventSem",
  160.                           IErrorInfo::accessError,
  161.                           IException::recoverable) ;
  162.       }
  163.  
  164.     hndlSem = new ISemaphoreHandle( hand);
  165.     return;
  166.    }
  167.  
  168.  /*----------------------------*/
  169. IEventSem :: ~IEventSem( )
  170.    {
  171.     long      rc = 0;
  172.     delete  &szName;
  173.     // if this semaphore is currently created/opened, close it.
  174.     rc = (long) DosCloseEventSem( (HEV)(*hndlSem) );
  175.     if ( rc)
  176.      {
  177.       ITHROWSYSTEMERROR( rc,
  178.                          "DosCloseEventSem",
  179.                          IErrorInfo::accessError,
  180.                          IException::recoverable) ;
  181.      }
  182.     delete hndlSem;
  183.    }
  184.  
  185. /*----------------------------*/
  186. IEventSem & IEventSem :: post( )
  187.    {
  188.     long      rc = 0;
  189.     rc = (long) DosPostEventSem( (HEV)(*hndlSem) );
  190.     if ( rc)
  191.      {
  192.       // Treat the case of already-posted as OK.
  193.       if ( rc != ERROR_ALREADY_POSTED)
  194.         ITHROWSYSTEMERROR( rc,
  195.                            "DosPostEventSem",
  196.                            IErrorInfo::accessError,
  197.                            IException::recoverable) ;
  198.      }
  199.     return (*this);
  200.    }
  201.  
  202.  /*----------------------------*/
  203. unsigned long IEventSem :: postCount( )
  204.    {
  205.     long      rc = 0;
  206.     unsigned long count = 0;
  207.  
  208.     rc = (long) DosQueryEventSem( (HEV)(*hndlSem), &count);
  209.     if ( rc)
  210.      {
  211.       ITHROWSYSTEMERROR( rc,
  212.                          "DosQueryEventSem",
  213.                          IErrorInfo::accessError,
  214.                          IException::recoverable) ;
  215.      }
  216.     return (count);
  217.    }
  218.  
  219.  /*----------------------------*/
  220. unsigned long IEventSem :: reset( )
  221.    {
  222.     long      rc = 0;
  223.     unsigned long ulPostCount = 0;
  224.  
  225.     rc = (long) DosResetEventSem( (HEV)(*hndlSem), &ulPostCount );
  226.     if ( rc)
  227.      {
  228.       // Treat the case of already-reset as OK.
  229.       if ( rc != ERROR_ALREADY_RESET)
  230.         ITHROWSYSTEMERROR( rc,
  231.                            "DosResetEventSem",
  232.                            IErrorInfo::accessError,
  233.                            IException::recoverable) ;
  234.      }
  235.     return( ulPostCount );
  236.    }
  237.  
  238.  /*----------------------------*/
  239. IEventSem & IEventSem :: wait( long timeOut)
  240.    {
  241.     long      rc = 0;
  242.     rc = (long) DosWaitEventSem( (HEV)(*hndlSem), timeOut );
  243.     if ( rc)
  244.      {
  245.       IErrorInfo::ExceptionType type;
  246.       if ( rc == ERROR_TIMEOUT)
  247.         type = IErrorInfo::resourceExhausted;
  248.       else
  249.         type = IErrorInfo::accessError;
  250.  
  251.       ITHROWSYSTEMERROR( rc,
  252.                          "DosWaitEventSem",
  253.                          type,
  254.                          IException::recoverable) ;
  255.      } /* endif */
  256.     return (*this);
  257.    }
  258.  
  259.  /*----------------------------*/
  260.  const IString & IEventSem :: name( )
  261.    {
  262.     return szName;
  263.    }
  264.  
  265.  /*----------------------------*/
  266.  IEventSem::EventSemType IEventSem :: type( )
  267.    {
  268.     return semType;
  269.    }
  270.  
  271.  /*----------------------------*/
  272.  const ISemaphoreHandle &IEventSem :: handle( )
  273.    {
  274.     return( *hndlSem );
  275.    }
  276.  
  277.