TABLE OF CONTENTS

ljanus.lib/AddService
ljanus.lib/AllocJanusMem
ljanus.lib/AllocJRemember
ljanus.lib/AllocServiceMem
ljanus.lib/AttachJRemember
ljanus.lib/CallService
ljanus.lib/DeleteService
ljanus.lib/FreeJanusMem
ljanus.lib/FreeJRemember
ljanus.lib/FreeServiceMem
ljanus.lib/GetBase
ljanus.lib/GetService
ljanus.lib/j_file_transfer
ljanus.lib/JanusInitLock
ljanus.lib/JanusLock
ljanus.lib/JanusLockAttempt
ljanus.lib/JanusUnlock
ljanus.lib/LockServiceData
ljanus.lib/PError
ljanus.lib/PrintSD
ljanus.lib/ReleaseService
ljanus.lib/UnlockServiceData
ljanus.lib/WaitService
ljanus.lib/AddService                                   ljanus.lib/AddService

   NAME   
      AddService -- Adds a Service to the system.

   SYNOPSIS
      result = AddService(
         ServiceData,AppID,LocalID,MemSize,MemType,Handler,Flags)

      UBYTE AddService(struct ServiceData **,ULONG,USHORT,USHORT,USHORT
                        ULONG,USHORT);

   FUNCTION
      This routine adds a Service to the system. Except where noted
      this function behaves identically to the janus.library version.
      see the janus.library autodocs for a detailed explanation.

   INPUTS
      Handler - Pointer to an assembly language routine. This routine
                will be called whenever anyone else calls this service.
                If Handler = NULL no routine will be called.

   RESULT
      Returns a status byte defined in services.[h,inc]. JSERV_OK if
      all went well.

   EXAMPLE

   NOTES

   BUGS

   SEE ALSO
      GetService(), CallService(), DeleteService(), ReleaseService()
      WaitService()

ljanus.lib/AllocJanusMem                             ljanus.lib/AllocJanusMem

   NAME   
      AllocJanusMem -- Allocate Janus Dual-Port memory.

   SYNOPSIS
      MemPtr = AllocJanusMem(Size,Type);

      APTR AllocJanusMem(ULONG,ULONG);

   FUNCTION
      This routine allocates memory from the special Janus RAM.
      Except where noted this function behaves identically to the 
      janus.library version. see the janus.library autodocs for a
      detailed explanation.

   INPUTS
      Type - One of MEMF_PARAMETER or MEMF_BUFFER. Access modes are not
             necessary.

   RESULT

   EXAMPLE

   NOTES

   BUGS

   SEE ALSO
      FreeJanusMem()

ljanus.lib/AllocJRemember                           ljanus.lib/AllocJRemember

   NAME   
     AllocJRemember -- Allocate Janus memory and link into a Remember list

   SYNOPSIS
     MemPtr = AllocJRemember(JRememberKey, Size, Type)

     APTR AllocJRemember(RPTR *,USHORT,USHORT);

   FUNCTION
      Except where noted this function behaves identically to the 
     janus.library version. See the janus.library autodocs for a 
     detailed explanation.

   INPUTS
     JRememberKey = Pointer to an RPTR in Janus memory that will be the
                     JRemeberKey. Before your very first call to 
                    AllocJRemember(), the RPTR should be set to NULL.
                     The RPTR MUST reside in Janus memory!
     Size         = the size in bytes of the memory allocation.
     Type         = the type of the desired memory.  Please refer to the
                    AllocJanusMem() documentation for details about this
                    field

   RESULT
     MemPtr = a pointer to the Janus memory you've requested, or NULL 
              if no memory was available.

   EXAMPLE
     RPTR JRememberKey;
     JRememberKey = NULL;

     if (ptr = AllocJRemember(&JRememberKey, BUFSIZE, MEMF_BUFFER))
     {
        \* Use the ptr memory *\
     }
     FreeJRemember(&JRememberKey, TRUE);

   NOTES

   BUGS

   SEE ALSO
     intuition.library/AllocRemember(), AttachJRemember(), FreeJRemember()

ljanus.lib/AllocServiceMem                         ljanus.lib/AllocServiceMem

   NAME   
     AllocServiceMem -- Allocate Janus memory linked to a ServiceData struct

   SYNOPSIS
     MemPtr = AllocServiceMem(ServiceData, Size,   Type)

     APTR AllocServiceMem(struct ServiceData *,USHORT,USHORT);

   FUNCTION
     This routine allocates memory for you and records the details of 
     the allocation in the specified ServiceData structure. This memory,
     unless you free it explicitly with a call to FreeServiceMem(), 
     will be automatically freed when the service is deleted and 
     removed from the system.  
     
     This routine calls the Janus library's AllocJRemember() call for you, 
     using the ServiceData's JRememberKey field to record the parameters 
     of the allocation for you.  You may then free the memory using 
     the FreeServiceMem() routine.  Alternatively, you may pay no 
     further attention to this memory allocation because after the 
     service is deleted and all users have released it, any memory 
     allocated using the ServiceData's JRememberKey will be freed 
     using the FreeJRemember() function.  
     
     You are allowed to call this routine whether you have acquired the 
     ServiceData address from AddService() or GetService().  
     
     The ServiceData structure pointer that you provide to this routine 
     doesn't have to point to any particular Janus memory-access address 
     space (although it must point to Janus memory of course).  What this 
     means is that if you translate the ServiceData pointer you get from 
     AddService() or GetService() from word-access to byte-access or 
     anything else, you don't have to translate it back before calling 
     AllocServiceMem().  
     
     The Size and Type arguments are the same as those passed to the 
     AllocJanusMem() function.  Please refer to the AllocJanusMem() 
     documentation for a description of these arguments.  
     
     If the call succeeds, you are returned a pointer to the Janus 
     memory that you desire.  If the call fails, a NULL is returned.  

   INPUTS
     ServiceData = address of a ServiceData structure. This may point to
                   any type of Janus memory-access address, not
                   necessarily word-access
     Size        = the size in bytes of the memory allocation.
     Type        = the type of the desired memory.  Please refer to the 
                   AllocJanusMem() documentation for details about this
                   field

   RESULT
     MemPtr = a pointer to the Janus memory you've requested, or NULL 
              if no memory was available.

   EXAMPLE
     struct ServiceData *SData;
     if (GetService(&SData, ...) == JSERV_OK))
     {
        ptr1 = AllocServiceMem(SData, 100, MEMF_BUFFER | MEM_BYTEACCESS);
        ptr2 = AllocServiceMem(SData, 100, MEMF_BUFFER | MEM_BYTEACCESS);
        ReleaseService(SData);
     }

   NOTES

   BUGS

   SEE ALSO
     FreeServiceMem()

ljanus.lib/AttachJRemember                         ljanus.lib/AttachJRemember

   NAME   
     AttachJRemember -- Attach the list of one Janus memory key to another

   SYNOPSIS
     VOID AttachJRemember(ToKey, FromKey);

     VOID AttachJRemember(RPTR *,RPTR *);

   FUNCTION
      Except where noted this function behaves identically to the 
     janus.library version. See the janus.library autodocs for a 
     detailed explanation.

   INPUTS
     ToKey   = address of a word in Janus memory that is the ToKey, which 
               is going to receive the list pointed to by FromKey
     FromKey = address of a word in Janus memory that is the FromKey, 
                which has the list that's going to be attached ToKey, 
               after which the FromKey variable will be set to NULL

   RESULT
     None

   EXAMPLE
     RPTR JanusRemember GlobalJKey = NULL;
     
     exampleAllocJ(&GlobalJKey);
     exampleAllocJ(&GlobalJKey);
     exampleAllocJ(&GlobalJKey);
     FreeJRemember(&GlobalJKey, TRUE);
     
     exampleAllocJ(globalkey)
     RPTR *globalkey;
     {
        BOOL success;
        RPTR localkey;
     
        success = FALSE;
        localkey = NULL;
     
        if(AllocJRemember(&localkey,10000,MEMF_BUFFER | MEM_WORDACCESS))
        if(AllocJRemember(&localkey,100  ,MEMF_BUFFER | MEM_WORDACCESS))
        if(AllocJRemember(&localkey,1    ,MEMF_BUFFER | MEM_WORDACCESS))
           success = TRUE;
     
        if (success) AttachJRemember(globalkey, &localkey);
           else FreeJRemember(&localkey, TRUE);
     }

   NOTES

   BUGS

   SEE ALSO
     intuition.library/AllocRemember(), AllocJRemember(), FreeJRemember()

ljanus.lib/CallService                                 ljanus.lib/CallService

   NAME   
      CallService -- Signal all other users of a Janus Service.

   SYNOPSIS
      ReturnCode = CallService(Service);

      UBYTE CallService(struct ServiceData *);

   FUNCTION
      Sends a signal to all other users of this service. Except where noted
      this function behaves identically to the janus.library version.
      see the janus.library autodocs for a detailed explanation.

   INPUTS

   RESULT

   EXAMPLE

   NOTES

   BUGS

   SEE ALSO
      AddService(), DeleteService(), GetService(), ReleaseService(),
      WaitService()

ljanus.lib/DeleteService                             ljanus.lib/DeleteService

   NAME   
      DeleteService -- Delete a Janus Service.

   SYNOPSIS
      ReturnCode = DeleteService(ServiceData);

      UBYTE DeleteService(struct ServiceData *);

   FUNCTION
      Deletes a Janus Service from the system. Except where noted
      this function behaves identically to the janus.library version.
      see the janus.library autodocs for a detailed explanation.

   INPUTS

   RESULT

   EXAMPLE

   NOTES

   BUGS

   SEE ALSO
      AddService(), CallService(), GetService(), ReleaseService(),
      WaitService()

ljanus.lib/FreeJanusMem                               ljanus.lib/FreeJanusMem

   NAME   
      FreeJanusMem -- Frees Janus Dual-Port memory.

   SYNOPSIS
      ReturnCode = FreeJanusMem(Ptr);

      UBYTE FreeJanusMem(APTR);

   FUNCTION
      Frees Janus mem previously allocated with AllocJanusMem().

   INPUTS
      Ptr - Pointer to previously allocated memory.

   RESULT
      Returns JSERV_OK or crashes on bad Ptr.

   EXAMPLE

   NOTES

   BUGS

   SEE ALSO
      AllocJanusMem()

ljanus.lib/FreeJRemember                             ljanus.lib/FreeJRemember

   NAME   
     FreeJRemember -- Free memory allocated by calls to AllocJRemember()

   SYNOPSIS
     VOID FreeJRemember(JRememberKey, ReallyForget)

     VOID FreeJRemember(RPTR *,BOOL);

   FUNCTION
      Except where noted this function behaves identically to the 
     janus.library version. See the janus.library autodocs for a 
     detailed explanation.

   INPUTS
     JRememberKey = the address of word in Janus memory that is a pointer 
                    to a struct JanusRemember. This pointer should either 
                    be NULL or set to some value (possibly NULL) by a call
                    to AllocRemember()
     ReallyForget = a BOOL FALSE or TRUE describing, respectively, 
                    whether you want to free up only the Remember nodes
                    or if you want this procedure to really forget about
                    all of the memory, including both the nodes and the
                    memory buffers pointed to by the nodes.

   RESULT
     None

   EXAMPLE
     RPTR JRememberKey;
     JRememberKey = NULL;

     while (AllocJRemember(&JRememberKey, BUFSIZE, MEMF_BUFFER)) ;
        FreeJRemember(&JRememberKey, TRUE);

   NOTES

   BUGS

   SEE ALSO
     AllocJRemember(), intuition.library/FreeRemember(), AttachJRemember()

ljanus.lib/FreeServiceMem                           ljanus.lib/FreeServiceMem

   NAME   
     FreeServiceMem -- Free mem added to a ServiceData by AllocServiceMem()

   SYNOPSIS
     VOID FreeServiceMem(ServiceData, MemPtr)

     VOID FreeServiceMem(struct ServiceData *,APTR);

   FUNCTION
     This routine frees memory that had been allocated with a call 
     to AllocServiceMem().  You can choose to free a single block of 
     memory or all the memory of the ServiceData structure.  
     
     The ServiceData structure pointer that you provide to this routine 
     doesn't have to point to any particular Janus memory-access address 
     space (although it must point to Janus memory of course).  What this 
     means is that if you translate the ServiceData pointer you get from 
     AddService() or GetService() from word-access to byte-access or 
     anything else, you don't have to translate it back before calling 
     FreeServiceMem().  
     
     Note that the address of the ServiceData structure that you supply to 
     this routine must be the same address that you passed to the
     associated AllocServiceMem() call, if any.
     
     The MemPtr argument may be one of two things:
        - the pointer to memory returned by a call to AllocServiceMem()
          (using the same ServiceData structure as the one provided to
          this call), or
        - NULL to designate that you want all (if any) of the ServiceData's
          allocated memory to be freed (note that this does not include
          freeing the memory allocated at time of AddService()
     
     Note that only memory allocated by AllocServiceMem can be freed.  
     The memory allocated for the service during AddService() cannot be 
     deleted using FreeServiceMem(), not even if you call FreeServiceMem() 
     with a MemPtr argument of NULL.  
     
     You are allowed to call this routine whether you have acquired the 
     ServiceData address from AddService() or GetService().  

   INPUTS
     ServiceData = address of a ServiceData structure.  This may point to 
                   any type of Janus memory-access address, not
                   necessarily word-access
     MemPtr      = a pointer to the Janus memory returned by a call 
                   to AllocJanusMem(), or NULL if you want to delete
                   all of the ServiceData's memory

   RESULT
     None

   EXAMPLE
     struct ServiceData *SData;
     if (GetService(&SData, ...) == JSERV_OK))
     {
        \* Allocate a bunch of memory *\
        AllocServiceMem(SData, 100, MEMF_BUFFER | MEM_BYTEACCESS);
        AllocServiceMem(SData, 100, MEMF_BUFFER | MEM_BYTEACCESS);
        ptr1 = AllocServiceMem(SData, 100, MEMF_BUFFER | MEM_BYTEACCESS);
 
        \* Free the last one allocated *\
        FreeServiceMem(SData, ptr1);
 
        \* Free all the rest *\
        FreeServiceMem(SData, NULL);
 
        ReleaseService(SData);
     }

   NOTES

   BUGS

   SEE ALSO
     AllocServiceMem()

ljanus.lib/GetBase                                         ljanus.lib/GetBase

   NAME   
      GetBase -- Get segment pointers for buffer and parameter mem,as
                 well as the default parameter memory for the old
                 style service.

   SYNOPSIS
      ReturnCode = GetBase(Service,ParmSeg,ParmOff,BuffSeg);

      UBYTE GetBase(UBYTE,UWORD *,UWORD *,UWORD *);

   FUNCTION
      Returns the segment addresses for buffer and parameter mem. Also
      returns the default parameter mem offset for this service if
      defined else -1.

   INPUTS
      Service - Service number of old style service.

      ParmSeg - Pointer to a UWORD to recieve the Parameter segment pointer.

      ParmOff - Pointer to a UWORD to recieve the offset of this services
                parameter memory.

      BuffSeg - Pointer to a UWORD to recieve the Buffer segment pointer.

   RESULT
      Returns JSERV_OK, JSERV_NOJANUSBASE.

   EXAMPLE

   NOTES

   BUGS

   SEE ALSO

ljanus.lib/GetService                                   ljanus.lib/GetService

   NAME   
      GetService -- Get a Janus Service.

   SYNOPSIS
      ReturnCode = GetService(ServiceData,AppID,LocalID,Handler,Flags);

      UBYTE GetService(struct ServiceData **,ULONG,UWORD,ULONG,UWORD);

   FUNCTION
      This routine gets a Janus Service. Except where noted
      this function behaves identically to the janus.library version.
      see the janus.library autodocs for a detailed explanation.

   INPUTS
      Handler - Pointer to an assembly language routine to be called
                whenever someone else calls this service ot NULL for
                no handler.

   RESULT
      Returns JSERV_OK if no error.

   EXAMPLE

   NOTES

   BUGS

   SEE ALSO
      AddService(), CallService(), DeleteService(), ReleaseService(),
      WaitService()

ljanus.lib/j_file_transfer                         ljanus.lib/j_file_transfer

   NAME   
      j_file_transfer -- Transfer files MS-DOS <-> AmigaDOS.

   SYNOPSIS
      Error = j_file_transfer(Infile,Outfile,Direction,Mode,Transtable,
                              Convert);

      int j_file_transfer(char *,char *,int,int,unsigned char *,int);

   FUNCTION
      Transfers files from AmigaDOS to MS-DOS and vice versa. This function
      provides a user interface to the PCDisk program on the Amiga.

   INPUTS
      Infile -     Pointer to NULL terminated string which is the name of
                  the input file to open. If Direction==JFT_AMIGA_PC Infile
                  will point to string containing a valid AmigaDos
                  filespec as documented in AREAD.DOC. If Direction==
                  JFT_PC_AMIGA Infile will point to a string containing
                  a valid PC filespec as documented in AWRITE.DOC.      
      Outfile -    Pointer to NULL terminated string which is the name of
                  the output file to open. If Direction==JFT_AMIGA_PC
                  Infile will point to a string containing a valid MS-DOS
                  filespec as documented in AREAD.DOC. If Direction==
                  JFT_PC_AMIGA Infile will point to a valid AmigaDOS
                  filespec as documented in AWRITE.DOC.
           
      Direction -  Direction flag from jftrans.h
                  JFT_AMIGA_PC - Indicates that the transfer is from the
                  Amiga to the PC so infile will be
                  an Amiga filespec and Outfile will be
                  an MS-DOS filespec.
                  JFT_PC_AMIGA - Indicates that the transfer is from the
                  PC to the Amiga. Infile will be a MS-DOS
                  filespec and Outfile will be an Amiga
                  filespec.
      Mode -       Mode flag from jftrans.h
                  JFT_CRLF   - Causes CRLF conversions to take place.
                  JFT_BINARY - Suppresses CRLF conversions.
      Transtable - Pointer to an optional character array to be used for
                  character translations. The format for the array is
                  char table[256] = {
                     0xnn,      Entry 0 
                     0xnn,      Entry 1 
                       .        .   
                       .        .   
                       .        .   
                     0xnn,      Entry 254 
                     0xnn };    Entry 255 
                  j_file_transfer() uses the following line to perform
                  its translations:
                  writechar = transtable[readchar];
                  so the input character is used as an index into the
                  table and the and the character contained in that entry
                  is the character sent as output. In this way all 255
                  ASCII characters can be converted. If a NULL is provided
                  for this field the default translation tables are used.
                  The default translations are documented in AREAD.DOC and
                  AWRITE.DOC.
      Convert -    Conversion flag from jftrans.h
                  JFT_CONVERT   - Convert characters according to
                  Transtable provided or use defaults if NULL given as
                  Transtable.
                  JFT_NO_CONVERT - Perform no conversion of characters.
                  Character value written will be the
                  same as that read.

   RESULT
      Error - Error flag from jftrans.h
       JFT_NOERROR                     - Indicates a successful transfer.
       JFT_ERR_INVALID_MODE            - An invalid mode was specified
                                         Valid modes are JFT_CRLF and
                                         JFT_BINARY.
       JFT_ERR_INVALID_DIRECTION       - An invalid direction was
                                         specified. Valid directions
                                         are JFT_PC_AMIGA and
                                         JFT_AMIGA_PC.
       JFT_ERR_NO_JANUS                - The Janus library has not been loade
d
       JFT_ERR_NO_SERVER               - The Amiga file server, DOSServ,
                                         could not be loaded.
       JFT_ERR_PC_OPEN                 - The PC file could not be opened.
       JFT_ERR_AMIGA_OPEN              - The Amiga file could not be
                                         opened.
       JFT_ERR_AMIGA_READ              - There was an error while reading
                                         from the Amiga.
       JFT_ERR_AMIGA_WRITE             - There was an error while writing
                                         to the Amiga.     
       JFT_ERR_INVALID_CONVERSION_MODE - An invalid conversion mode was
                                         specified, Valid modes are
                                         JFT_CONVERT and JFT_NO_CONVERT.
       JFT_ERR_PC_READ                 - There was an error while reading
                                         from the PC.
       JFT_ERR_PC_WRITE                - There was an error while writing
                                         to the PC.

   EXAMPLE

   NOTES

   BUGS

   SEE ALSO

ljanus.lib/JanusInitLock                             ljanus.lib/JanusInitLock

   NAME   
      JanusInitLock -- Initialize a lock byte.

   SYNOPSIS
      JanusInitLock(Lock);

      VOID JanusInitLock(UBYTE *);

   FUNCTION
      Does everything necessary to initialize a lock byte.
      Except where noted this function behaves identically
      to the janus.library version. See the janus.library autodocs for a
      detailed explanation.

   INPUTS
      Lock - Pointer to the lock byte to be initialized.

   RESULT
      The lock byte is initialized.

   EXAMPLE

   NOTES

   BUGS

   SEE ALSO
      JanusLockAttempt(), JanusLock(), JanusUnlock()

ljanus.lib/JanusLock                                     ljanus.lib/JanusLock

   NAME   
      JanusLock -- Get a lock.

   SYNOPSIS
      JanusLock(Lock);

      VOID JanusLock(UBYTE *);

   FUNCTION
      Does everything necessary to Lock a lock byte.
      Except where noted this function behaves identically
      to the janus.library version. See the janus.library autodocs for a
      detailed explanation.

   INPUTS
      Lock - Pointer to the lock byte to be locked.

   RESULT
      The lock is yours.

   EXAMPLE

   NOTES

   BUGS

   SEE ALSO
      JanusInitLock(), JanusLockAttempt(), JanusUnlock()

ljanus.lib/JanusLockAttempt                       ljanus.lib/JanusLockAttempt

   NAME   
      JanusLockAttempt -- Try once to get a lock.

   SYNOPSIS
      JanusLockAttempt(Lock);

      VOID JanusLockAttempt(UBYTE *);

   FUNCTION
      Attempts to Lock a lock byte.
      Except where noted this function behaves identically
      to the janus.library version. See the janus.library autodocs for a
      detailed explanation.

   INPUTS
      Lock - Pointer to the lock byte to be locked.

   RESULT
      TRUE if lock gotten FALSE otherwise.

   EXAMPLE

   NOTES

   BUGS

   SEE ALSO
      JanusInitLock(), JanusLock(), JanusUnlock()

ljanus.lib/JanusUnlock                                 ljanus.lib/JanusUnlock

   NAME   
      JanusUnlock -- Release a lock.

   SYNOPSIS
      JanusUnlock(Lock);

      VOID JanusUnlock(UBYTE *);

   FUNCTION
      Does everything necessary to Unlock a lock byte.
      Except where noted this function behaves identically
      to the janus.library version. See the janus.library autodocs for a
      detailed explanation.

   INPUTS
      Lock - Pointer to the lock byte to be unlocked.

   RESULT
      The lock is released.

   EXAMPLE

   NOTES

   BUGS

   SEE ALSO
      JanusInitLock(), JanusLockAttempt(), JanusLock()

ljanus.lib/LockServiceData                         ljanus.lib/LockServiceData

   NAME   
      LockServiceData -- Lock a ServiceData structure for exclusive use.

   SYNOPSIS
      ReturnCode = LockServiceData(ServiceData);

      UBYTE LockServiceData(struct ServiceData *);

   FUNCTION
      Does everything necessary to lock a ServiceData structure for 
      exclusive use. Except where noted this function behaves identically
      to the janus.library version. See the janus.library autodocs for a
      detailed explanation.

   INPUTS
      ServiceData - Pointer to the ServiceData structure that you want to
                    lock.

   RESULT
      Returns JSERV_OK if the lock was obtained.

   EXAMPLE

   NOTES

   BUGS

   SEE ALSO
      UnlockServiceData()

ljanus.lib/PError                                           ljanus.lib/PError

   NAME   
      PError -- Print out an ASCII string for the error code given.

   SYNOPSIS
      PError(Error);

      VOID PError(UBYTE);

   FUNCTION
      Prints the ASCII error message associated with the return code.

   INPUTS
      Error - Error code returned by one of the Service functions.

   RESULT
      An ASCII error message is printed to stdout.

   EXAMPLE

   NOTES

   BUGS

   SEE ALSO
      PrintSD()

ljanus.lib/PrintSD                                         ljanus.lib/PrintSD

   NAME   
      PrintSD -- Print out a ServiceData structure.

   SYNOPSIS
      PrintSD(ServiceData);

      VOID PrintSD(struct ServiceData *);

   FUNCTION
      Prints out all the fields of a ServiceData structure. Useful for
      debugging service programs.

   INPUTS
      ServiceData - Pointer to the ServiceData structure to be printed.

   RESULT
      The ServiceData structure is printed to stdout.

   EXAMPLE

   NOTES

   BUGS

   SEE ALSO
      PError()

ljanus.lib/ReleaseService                           ljanus.lib/ReleaseService

   NAME   
      ReleaseService -- Release a service previously gotten with
                        GetService().

   SYNOPSIS
      ReturnCode = ReleaseService(ServiceData);

      UBYTE ReleaseService(struct ServiceData *);

   FUNCTION
      Release a Janus Service. Except where noted
      this function behaves identically to the janus.library version.
      see the janus.library autodocs for a detailed explanation.

   INPUTS

   RESULT

   EXAMPLE

   NOTES

   BUGS

   SEE ALSO
      AddService(), CallsService(), DeleteService(), GetService()
      WaitService()

ljanus.lib/UnlockServiceData                     ljanus.lib/UnlockServiceData

   NAME   
      UnlockServiceData -- Unlock a previously locked ServiceData structure.

   SYNOPSIS
      ReturnCode = UnlockServiceData(ServiceData);

      UBYTE UnlockServiceData(struct ServiceData *);

   FUNCTION
      Unlocks a ServiceData structure previously locked with 
      LockServieData(). Except where noted
      this function behaves identically to the janus.library version.
      see the janus.library autodocs for a detailed explanation.

   INPUTS

   RESULT

   EXAMPLE

   NOTES

   BUGS

   SEE ALSO
      LockServiceData()

ljanus.lib/WaitService                                 ljanus.lib/WaitService

   NAME   
      WaitService -- Wait for a service request to complete.

   SYNOPSIS
      WaitService(ServiceData);

      VOID WaitService(struct ServiceData *);

   FUNCTION
      Waits for someone else to CallService() this service.

   INPUTS
      ServiceData - Pointer to the ServieData structure of the service you
                    wish to wait for.

   RESULT
      Returns when this service has been called.

   EXAMPLE

   NOTES

   BUGS

   SEE ALSO
      AddService(), CallService(), DeleteService(), GetService()
      ReleaseService()

