FOREIGN MODULE java_util_concurrent_locks;

IMPORT
    java_io := "java.io",
    java_lang := "java.lang",
    java_util := "java.util",
    java_util_concurrent := "java.util.concurrent",
    sun_misc := "sun.misc",
    java_util_concurrent_atomic := "java.util.concurrent.atomic";

TYPE

  AbstractOwnableSynchronizer* = POINTER TO ABSTRACT RECORD (java_lang.Object + java_io.Serializable)    (* Typebound Procedures *)
                                 STATIC
                                   PROCEDURE Init!() : AbstractOwnableSynchronizer,CONSTRUCTOR;
                                 END;

  AbstractQueuedLongSynchronizer* = POINTER TO ABSTRACT RECORD (AbstractOwnableSynchronizer + java_io.Serializable)    (* Typebound Procedures *)
                                    STATIC
                                      PROCEDURE Init!() : AbstractQueuedLongSynchronizer,CONSTRUCTOR;
                                    END;

  AbstractQueuedLongSynchronizer$ConditionObject* = POINTER TO EXTENSIBLE RECORD (java_lang.Object + Condition + java_io.Serializable)    (* Typebound Procedures *)
                                                    STATIC
                                                      PROCEDURE Init*(p0 : AbstractQueuedLongSynchronizer) : AbstractQueuedLongSynchronizer$ConditionObject,CONSTRUCTOR;
                                                    END;

  AbstractQueuedSynchronizer* = POINTER TO ABSTRACT RECORD (AbstractOwnableSynchronizer + java_io.Serializable)    (* Typebound Procedures *)
                                STATIC
                                  PROCEDURE Init!() : AbstractQueuedSynchronizer,CONSTRUCTOR;
                                END;

  AbstractQueuedSynchronizer$ConditionObject* = POINTER TO EXTENSIBLE RECORD (java_lang.Object + Condition + java_io.Serializable)    (* Typebound Procedures *)
                                                STATIC
                                                  PROCEDURE Init*(p0 : AbstractQueuedSynchronizer) : AbstractQueuedSynchronizer$ConditionObject,CONSTRUCTOR;
                                                END;

  Condition* = POINTER TO INTERFACE RECORD (java_lang.Object)    (* Typebound Procedures *)
               END;

  Lock* = POINTER TO INTERFACE RECORD (java_lang.Object)    (* Typebound Procedures *)
          END;

  LockSupport* = POINTER TO EXTENSIBLE RECORD (java_lang.Object)
                 STATIC
                   PROCEDURE getBlocker*(p0 : java_lang.Thread) : java_lang.Object;
                   PROCEDURE park*(p0 : java_lang.Object);
                   PROCEDURE park*();
                   PROCEDURE parkNanos*(p0 : LONGINT);
                   PROCEDURE parkNanos*(p0 : java_lang.Object;
                                        p1 : LONGINT);
                   PROCEDURE parkUntil*(p0 : LONGINT);
                   PROCEDURE parkUntil*(p0 : java_lang.Object;
                                        p1 : LONGINT);
                   PROCEDURE unpark*(p0 : java_lang.Thread);
                 END;

  ReadWriteLock* = POINTER TO INTERFACE RECORD (java_lang.Object)    (* Typebound Procedures *)
                   END;

  ReentrantLock* = POINTER TO EXTENSIBLE RECORD (java_lang.Object + Lock + java_io.Serializable)    (* Typebound Procedures *)
                   STATIC
                     PROCEDURE Init*(p0 : BOOLEAN) : ReentrantLock,CONSTRUCTOR;
                     PROCEDURE Init*() : ReentrantLock,CONSTRUCTOR;
                   END;

  ReentrantReadWriteLock* = POINTER TO EXTENSIBLE RECORD (java_lang.Object + ReadWriteLock + java_io.Serializable)    (* Typebound Procedures *)
                            STATIC
                              PROCEDURE Init*(p0 : BOOLEAN) : ReentrantReadWriteLock,CONSTRUCTOR;
                              PROCEDURE Init*() : ReentrantReadWriteLock,CONSTRUCTOR;
                            END;

  ReentrantReadWriteLock$ReadLock* = POINTER TO EXTENSIBLE RECORD (java_lang.Object + Lock + java_io.Serializable)    (* Typebound Procedures *)
                                     STATIC
                                       PROCEDURE Init!(p0 : ReentrantReadWriteLock) : ReentrantReadWriteLock$ReadLock,CONSTRUCTOR;
                                     END;

  ReentrantReadWriteLock$WriteLock* = POINTER TO EXTENSIBLE RECORD (java_lang.Object + Lock + java_io.Serializable)    (* Typebound Procedures *)
                                      STATIC
                                        PROCEDURE Init!(p0 : ReentrantReadWriteLock) : ReentrantReadWriteLock$WriteLock,CONSTRUCTOR;
                                      END;




PROCEDURE (self:AbstractOwnableSynchronizer) getExclusiveOwnerThread!() : java_lang.Thread,NEW;

PROCEDURE (self:AbstractOwnableSynchronizer) setExclusiveOwnerThread!(p0 : java_lang.Thread),NEW;

PROCEDURE (self:AbstractQueuedLongSynchronizer) acquire*(p0 : LONGINT),NEW;

PROCEDURE (self:AbstractQueuedLongSynchronizer) acquireInterruptibly*(p0 : LONGINT),NEW;

PROCEDURE (self:AbstractQueuedLongSynchronizer) acquireShared*(p0 : LONGINT),NEW;

PROCEDURE (self:AbstractQueuedLongSynchronizer) acquireSharedInterruptibly*(p0 : LONGINT),NEW;

PROCEDURE (self:AbstractQueuedLongSynchronizer) compareAndSetState!(p0 : LONGINT;
                                                                    p1 : LONGINT) : BOOLEAN,NEW;

PROCEDURE (self:AbstractQueuedLongSynchronizer) getExclusiveQueuedThreads*() : java_util.Collection,NEW;

PROCEDURE (self:AbstractQueuedLongSynchronizer) getFirstQueuedThread*() : java_lang.Thread,NEW;

PROCEDURE (self:AbstractQueuedLongSynchronizer) getQueuedThreads*() : java_util.Collection,NEW;

PROCEDURE (self:AbstractQueuedLongSynchronizer) getQueueLength*() : INTEGER,NEW;

PROCEDURE (self:AbstractQueuedLongSynchronizer) getSharedQueuedThreads*() : java_util.Collection,NEW;

PROCEDURE (self:AbstractQueuedLongSynchronizer) getState!() : LONGINT,NEW;

PROCEDURE (self:AbstractQueuedLongSynchronizer) getWaitingThreads*(p0 : AbstractQueuedLongSynchronizer$ConditionObject) : java_util.Collection,NEW;

PROCEDURE (self:AbstractQueuedLongSynchronizer) getWaitQueueLength*(p0 : AbstractQueuedLongSynchronizer$ConditionObject) : INTEGER,NEW;

PROCEDURE (self:AbstractQueuedLongSynchronizer) hasContended*() : BOOLEAN,NEW;

PROCEDURE (self:AbstractQueuedLongSynchronizer) hasQueuedThreads*() : BOOLEAN,NEW;

PROCEDURE (self:AbstractQueuedLongSynchronizer) hasWaiters*(p0 : AbstractQueuedLongSynchronizer$ConditionObject) : BOOLEAN,NEW;

PROCEDURE (self:AbstractQueuedLongSynchronizer) isHeldExclusively!() : BOOLEAN,NEW,EXTENSIBLE;

PROCEDURE (self:AbstractQueuedLongSynchronizer) isQueued*(p0 : java_lang.Thread) : BOOLEAN,NEW;

PROCEDURE (self:AbstractQueuedLongSynchronizer) owns*(p0 : AbstractQueuedLongSynchronizer$ConditionObject) : BOOLEAN,NEW;

PROCEDURE (self:AbstractQueuedLongSynchronizer) release*(p0 : LONGINT) : BOOLEAN,NEW;

PROCEDURE (self:AbstractQueuedLongSynchronizer) releaseShared*(p0 : LONGINT) : BOOLEAN,NEW;

PROCEDURE (self:AbstractQueuedLongSynchronizer) setState!(p0 : LONGINT),NEW;

PROCEDURE (self:AbstractQueuedLongSynchronizer) toString*() : java_lang.String,EXTENSIBLE;

PROCEDURE (self:AbstractQueuedLongSynchronizer) tryAcquire!(p0 : LONGINT) : BOOLEAN,NEW,EXTENSIBLE;

PROCEDURE (self:AbstractQueuedLongSynchronizer) tryAcquireNanos*(p0 : LONGINT;
                                                                 p1 : LONGINT) : BOOLEAN,NEW;

PROCEDURE (self:AbstractQueuedLongSynchronizer) tryAcquireShared!(p0 : LONGINT) : LONGINT,NEW,EXTENSIBLE;

PROCEDURE (self:AbstractQueuedLongSynchronizer) tryAcquireSharedNanos*(p0 : LONGINT;
                                                                       p1 : LONGINT) : BOOLEAN,NEW;

PROCEDURE (self:AbstractQueuedLongSynchronizer) tryRelease!(p0 : LONGINT) : BOOLEAN,NEW,EXTENSIBLE;

PROCEDURE (self:AbstractQueuedLongSynchronizer) tryReleaseShared!(p0 : LONGINT) : BOOLEAN,NEW,EXTENSIBLE;

PROCEDURE (self:AbstractQueuedLongSynchronizer$ConditionObject) await*(),NEW;

PROCEDURE (self:AbstractQueuedLongSynchronizer$ConditionObject) await*(p0 : LONGINT;
                                                                       p1 : java_util_concurrent.TimeUnit) : BOOLEAN,NEW;

PROCEDURE (self:AbstractQueuedLongSynchronizer$ConditionObject) awaitNanos*(p0 : LONGINT) : LONGINT,NEW;

PROCEDURE (self:AbstractQueuedLongSynchronizer$ConditionObject) awaitUninterruptibly*(),NEW;

PROCEDURE (self:AbstractQueuedLongSynchronizer$ConditionObject) awaitUntil*(p0 : java_util.Date) : BOOLEAN,NEW;

PROCEDURE (self:AbstractQueuedLongSynchronizer$ConditionObject) getWaitingThreads!() : java_util.Collection,NEW;

PROCEDURE (self:AbstractQueuedLongSynchronizer$ConditionObject) getWaitQueueLength!() : INTEGER,NEW;

PROCEDURE (self:AbstractQueuedLongSynchronizer$ConditionObject) hasWaiters!() : BOOLEAN,NEW;

PROCEDURE (self:AbstractQueuedLongSynchronizer$ConditionObject) signal*(),NEW;

PROCEDURE (self:AbstractQueuedLongSynchronizer$ConditionObject) signalAll*(),NEW;

PROCEDURE (self:AbstractQueuedSynchronizer) acquire*(p0 : INTEGER),NEW;

PROCEDURE (self:AbstractQueuedSynchronizer) acquireInterruptibly*(p0 : INTEGER),NEW;

PROCEDURE (self:AbstractQueuedSynchronizer) acquireShared*(p0 : INTEGER),NEW;

PROCEDURE (self:AbstractQueuedSynchronizer) acquireSharedInterruptibly*(p0 : INTEGER),NEW;

PROCEDURE (self:AbstractQueuedSynchronizer) compareAndSetState!(p0 : INTEGER;
                                                                p1 : INTEGER) : BOOLEAN,NEW;

PROCEDURE (self:AbstractQueuedSynchronizer) getExclusiveQueuedThreads*() : java_util.Collection,NEW;

PROCEDURE (self:AbstractQueuedSynchronizer) getFirstQueuedThread*() : java_lang.Thread,NEW;

PROCEDURE (self:AbstractQueuedSynchronizer) getQueuedThreads*() : java_util.Collection,NEW;

PROCEDURE (self:AbstractQueuedSynchronizer) getQueueLength*() : INTEGER,NEW;

PROCEDURE (self:AbstractQueuedSynchronizer) getSharedQueuedThreads*() : java_util.Collection,NEW;

PROCEDURE (self:AbstractQueuedSynchronizer) getState!() : INTEGER,NEW;

PROCEDURE (self:AbstractQueuedSynchronizer) getWaitingThreads*(p0 : AbstractQueuedSynchronizer$ConditionObject) : java_util.Collection,NEW;

PROCEDURE (self:AbstractQueuedSynchronizer) getWaitQueueLength*(p0 : AbstractQueuedSynchronizer$ConditionObject) : INTEGER,NEW;

PROCEDURE (self:AbstractQueuedSynchronizer) hasContended*() : BOOLEAN,NEW;

PROCEDURE (self:AbstractQueuedSynchronizer) hasQueuedThreads*() : BOOLEAN,NEW;

PROCEDURE (self:AbstractQueuedSynchronizer) hasWaiters*(p0 : AbstractQueuedSynchronizer$ConditionObject) : BOOLEAN,NEW;

PROCEDURE (self:AbstractQueuedSynchronizer) isHeldExclusively!() : BOOLEAN,NEW,EXTENSIBLE;

PROCEDURE (self:AbstractQueuedSynchronizer) isQueued*(p0 : java_lang.Thread) : BOOLEAN,NEW;

PROCEDURE (self:AbstractQueuedSynchronizer) owns*(p0 : AbstractQueuedSynchronizer$ConditionObject) : BOOLEAN,NEW;

PROCEDURE (self:AbstractQueuedSynchronizer) release*(p0 : INTEGER) : BOOLEAN,NEW;

PROCEDURE (self:AbstractQueuedSynchronizer) releaseShared*(p0 : INTEGER) : BOOLEAN,NEW;

PROCEDURE (self:AbstractQueuedSynchronizer) setState!(p0 : INTEGER),NEW;

PROCEDURE (self:AbstractQueuedSynchronizer) toString*() : java_lang.String,EXTENSIBLE;

PROCEDURE (self:AbstractQueuedSynchronizer) tryAcquire!(p0 : INTEGER) : BOOLEAN,NEW,EXTENSIBLE;

PROCEDURE (self:AbstractQueuedSynchronizer) tryAcquireNanos*(p0 : INTEGER;
                                                             p1 : LONGINT) : BOOLEAN,NEW;

PROCEDURE (self:AbstractQueuedSynchronizer) tryAcquireShared!(p0 : INTEGER) : INTEGER,NEW,EXTENSIBLE;

PROCEDURE (self:AbstractQueuedSynchronizer) tryAcquireSharedNanos*(p0 : INTEGER;
                                                                   p1 : LONGINT) : BOOLEAN,NEW;

PROCEDURE (self:AbstractQueuedSynchronizer) tryRelease!(p0 : INTEGER) : BOOLEAN,NEW,EXTENSIBLE;

PROCEDURE (self:AbstractQueuedSynchronizer) tryReleaseShared!(p0 : INTEGER) : BOOLEAN,NEW,EXTENSIBLE;

PROCEDURE (self:AbstractQueuedSynchronizer$ConditionObject) await*(),NEW;

PROCEDURE (self:AbstractQueuedSynchronizer$ConditionObject) await*(p0 : LONGINT;
                                                                   p1 : java_util_concurrent.TimeUnit) : BOOLEAN,NEW;

PROCEDURE (self:AbstractQueuedSynchronizer$ConditionObject) awaitNanos*(p0 : LONGINT) : LONGINT,NEW;

PROCEDURE (self:AbstractQueuedSynchronizer$ConditionObject) awaitUninterruptibly*(),NEW;

PROCEDURE (self:AbstractQueuedSynchronizer$ConditionObject) awaitUntil*(p0 : java_util.Date) : BOOLEAN,NEW;

PROCEDURE (self:AbstractQueuedSynchronizer$ConditionObject) getWaitingThreads!() : java_util.Collection,NEW;

PROCEDURE (self:AbstractQueuedSynchronizer$ConditionObject) getWaitQueueLength!() : INTEGER,NEW;

PROCEDURE (self:AbstractQueuedSynchronizer$ConditionObject) hasWaiters!() : BOOLEAN,NEW;

PROCEDURE (self:AbstractQueuedSynchronizer$ConditionObject) signal*(),NEW;

PROCEDURE (self:AbstractQueuedSynchronizer$ConditionObject) signalAll*(),NEW;

PROCEDURE (self:Condition) await*(p0 : LONGINT;
                                  p1 : java_util_concurrent.TimeUnit) : BOOLEAN,NEW,ABSTRACT;

PROCEDURE (self:Condition) await*(),NEW,ABSTRACT;

PROCEDURE (self:Condition) awaitNanos*(p0 : LONGINT) : LONGINT,NEW,ABSTRACT;

PROCEDURE (self:Condition) awaitUninterruptibly*(),NEW,ABSTRACT;

PROCEDURE (self:Condition) awaitUntil*(p0 : java_util.Date) : BOOLEAN,NEW,ABSTRACT;

PROCEDURE (self:Condition) signal*(),NEW,ABSTRACT;

PROCEDURE (self:Condition) signalAll*(),NEW,ABSTRACT;

PROCEDURE (self:Lock) lock*(),NEW,ABSTRACT;

PROCEDURE (self:Lock) lockInterruptibly*(),NEW,ABSTRACT;

PROCEDURE (self:Lock) newCondition*() : Condition,NEW,ABSTRACT;

PROCEDURE (self:Lock) tryLock*(p0 : LONGINT;
                               p1 : java_util_concurrent.TimeUnit) : BOOLEAN,NEW,ABSTRACT;

PROCEDURE (self:Lock) tryLock*() : BOOLEAN,NEW,ABSTRACT;

PROCEDURE (self:Lock) unlock*(),NEW,ABSTRACT;

PROCEDURE (self:ReadWriteLock) readLock*() : Lock,NEW,ABSTRACT;

PROCEDURE (self:ReadWriteLock) writeLock*() : Lock,NEW,ABSTRACT;

PROCEDURE (self:ReentrantLock) getHoldCount*() : INTEGER,NEW,EXTENSIBLE;

PROCEDURE (self:ReentrantLock) getOwner!() : java_lang.Thread,NEW,EXTENSIBLE;

PROCEDURE (self:ReentrantLock) getQueuedThreads!() : java_util.Collection,NEW,EXTENSIBLE;

PROCEDURE (self:ReentrantLock) getQueueLength*() : INTEGER,NEW;

PROCEDURE (self:ReentrantLock) getWaitingThreads!(p0 : Condition) : java_util.Collection,NEW,EXTENSIBLE;

PROCEDURE (self:ReentrantLock) getWaitQueueLength*(p0 : Condition) : INTEGER,NEW,EXTENSIBLE;

PROCEDURE (self:ReentrantLock) hasQueuedThread*(p0 : java_lang.Thread) : BOOLEAN,NEW;

PROCEDURE (self:ReentrantLock) hasQueuedThreads*() : BOOLEAN,NEW;

PROCEDURE (self:ReentrantLock) hasWaiters*(p0 : Condition) : BOOLEAN,NEW,EXTENSIBLE;

PROCEDURE (self:ReentrantLock) isFair*() : BOOLEAN,NEW;

PROCEDURE (self:ReentrantLock) isHeldByCurrentThread*() : BOOLEAN,NEW,EXTENSIBLE;

PROCEDURE (self:ReentrantLock) isLocked*() : BOOLEAN,NEW,EXTENSIBLE;

PROCEDURE (self:ReentrantLock) lock*(),NEW,EXTENSIBLE;

PROCEDURE (self:ReentrantLock) lockInterruptibly*(),NEW,EXTENSIBLE;

PROCEDURE (self:ReentrantLock) newCondition*() : Condition,NEW,EXTENSIBLE;

PROCEDURE (self:ReentrantLock) toString*() : java_lang.String,EXTENSIBLE;

PROCEDURE (self:ReentrantLock) tryLock*(p0 : LONGINT;
                                        p1 : java_util_concurrent.TimeUnit) : BOOLEAN,NEW,EXTENSIBLE;

PROCEDURE (self:ReentrantLock) tryLock*() : BOOLEAN,NEW,EXTENSIBLE;

PROCEDURE (self:ReentrantLock) unlock*(),NEW,EXTENSIBLE;

PROCEDURE (self:ReentrantReadWriteLock) getOwner!() : java_lang.Thread,NEW,EXTENSIBLE;

PROCEDURE (self:ReentrantReadWriteLock) getQueuedReaderThreads!() : java_util.Collection,NEW,EXTENSIBLE;

PROCEDURE (self:ReentrantReadWriteLock) getQueuedThreads!() : java_util.Collection,NEW,EXTENSIBLE;

PROCEDURE (self:ReentrantReadWriteLock) getQueuedWriterThreads!() : java_util.Collection,NEW,EXTENSIBLE;

PROCEDURE (self:ReentrantReadWriteLock) getQueueLength*() : INTEGER,NEW;

PROCEDURE (self:ReentrantReadWriteLock) getReadHoldCount*() : INTEGER,NEW,EXTENSIBLE;

PROCEDURE (self:ReentrantReadWriteLock) getReadLockCount*() : INTEGER,NEW,EXTENSIBLE;

PROCEDURE (self:ReentrantReadWriteLock) getWaitingThreads!(p0 : Condition) : java_util.Collection,NEW,EXTENSIBLE;

PROCEDURE (self:ReentrantReadWriteLock) getWaitQueueLength*(p0 : Condition) : INTEGER,NEW,EXTENSIBLE;

PROCEDURE (self:ReentrantReadWriteLock) getWriteHoldCount*() : INTEGER,NEW,EXTENSIBLE;

PROCEDURE (self:ReentrantReadWriteLock) hasQueuedThread*(p0 : java_lang.Thread) : BOOLEAN,NEW;

PROCEDURE (self:ReentrantReadWriteLock) hasQueuedThreads*() : BOOLEAN,NEW;

PROCEDURE (self:ReentrantReadWriteLock) hasWaiters*(p0 : Condition) : BOOLEAN,NEW,EXTENSIBLE;

PROCEDURE (self:ReentrantReadWriteLock) isFair*() : BOOLEAN,NEW;

PROCEDURE (self:ReentrantReadWriteLock) isWriteLocked*() : BOOLEAN,NEW,EXTENSIBLE;

PROCEDURE (self:ReentrantReadWriteLock) isWriteLockedByCurrentThread*() : BOOLEAN,NEW,EXTENSIBLE;

PROCEDURE (self:ReentrantReadWriteLock) readLock*() : Lock,NEW,EXTENSIBLE;

PROCEDURE (self:ReentrantReadWriteLock) readLock*() : ReentrantReadWriteLock$ReadLock,NEW,EXTENSIBLE;

PROCEDURE (self:ReentrantReadWriteLock) toString*() : java_lang.String,EXTENSIBLE;

PROCEDURE (self:ReentrantReadWriteLock) writeLock*() : ReentrantReadWriteLock$WriteLock,NEW,EXTENSIBLE;

PROCEDURE (self:ReentrantReadWriteLock) writeLock*() : Lock,NEW,EXTENSIBLE;

PROCEDURE (self:ReentrantReadWriteLock$ReadLock) lock*(),NEW,EXTENSIBLE;

PROCEDURE (self:ReentrantReadWriteLock$ReadLock) lockInterruptibly*(),NEW,EXTENSIBLE;

PROCEDURE (self:ReentrantReadWriteLock$ReadLock) newCondition*() : Condition,NEW,EXTENSIBLE;

PROCEDURE (self:ReentrantReadWriteLock$ReadLock) toString*() : java_lang.String,EXTENSIBLE;

PROCEDURE (self:ReentrantReadWriteLock$ReadLock) tryLock*() : BOOLEAN,NEW,EXTENSIBLE;

PROCEDURE (self:ReentrantReadWriteLock$ReadLock) tryLock*(p0 : LONGINT;
                                                          p1 : java_util_concurrent.TimeUnit) : BOOLEAN,NEW,EXTENSIBLE;

PROCEDURE (self:ReentrantReadWriteLock$ReadLock) unlock*(),NEW,EXTENSIBLE;

PROCEDURE (self:ReentrantReadWriteLock$WriteLock) getHoldCount*() : INTEGER,NEW,EXTENSIBLE;

PROCEDURE (self:ReentrantReadWriteLock$WriteLock) isHeldByCurrentThread*() : BOOLEAN,NEW,EXTENSIBLE;

PROCEDURE (self:ReentrantReadWriteLock$WriteLock) lock*(),NEW,EXTENSIBLE;

PROCEDURE (self:ReentrantReadWriteLock$WriteLock) lockInterruptibly*(),NEW,EXTENSIBLE;

PROCEDURE (self:ReentrantReadWriteLock$WriteLock) newCondition*() : Condition,NEW,EXTENSIBLE;

PROCEDURE (self:ReentrantReadWriteLock$WriteLock) toString*() : java_lang.String,EXTENSIBLE;

PROCEDURE (self:ReentrantReadWriteLock$WriteLock) tryLock*() : BOOLEAN,NEW,EXTENSIBLE;

PROCEDURE (self:ReentrantReadWriteLock$WriteLock) tryLock*(p0 : LONGINT;
                                                           p1 : java_util_concurrent.TimeUnit) : BOOLEAN,NEW,EXTENSIBLE;

PROCEDURE (self:ReentrantReadWriteLock$WriteLock) unlock*(),NEW,EXTENSIBLE;

END java_util_concurrent_locks.