Class Monitor

src/system/windows.cpp:220–487

  };

  class Monitor : public System::Monitor {
   public:
    Monitor(System* s) : s(s), owner_(0), first(0), last(0), depth(0)
    {
      mutex = CreateMutex(0, false, 0);
      assertT(s, mutex);
    }

    virtual bool tryAcquire(System::Thread* context)
    {
      Thread* t = static_cast<Thread*>(context);
      assertT(s, t);

      if (owner_ == t) {
        ++depth;
        return true;
      } else {
        switch (WaitForSingleObject(mutex, 0)) {
        case WAIT_TIMEOUT:
          return false;

        case WAIT_OBJECT_0:
          owner_ = t;
          ++depth;
          return true;

        default:
          sysAbort(s);
        }
      }
    }

    virtual void acquire(System::Thread* context)
    {
      Thread* t = static_cast<Thread*>(context);
      assertT(s, t);

      if (owner_ != t) {
        int r UNUSED = WaitForSingleObject(mutex, INFINITE);
        assertT(s, r == WAIT_OBJECT_0);
        owner_ = t;
      }
      ++depth;
    }

    virtual void release(System::Thread* context)
    {
      Thread* t = static_cast<Thread*>(context);
      assertT(s, t);

      if (owner_ == t) {
        if (--depth == 0) {
          owner_ = 0;
          bool success UNUSED = ReleaseMutex(mutex);
          assertT(s, success);
        }
      } else {
        sysAbort(s);