/*******************************************************************************
Copyright by Telesoft Europe AB 1990, 1991.
Copyright by Telelogic Malmoe AB 1991, 1992, 1993, 1994.
Copyright by Telelogic AB 1994 - 2001.
This Program is owned by Telelogic and is protected by national
copyright laws and international copyright treaties. Telelogic
grants you the right to use this Program on one computer or in
one local computer network at any one time.
Under this License you may only modify the source code for the purpose
of adapting it to your environment. You must reproduce and include
any copyright and trademark notices on all copies of the source code.
You may not use, copy, merge, modify or transfer the Program except as
provided in this License.
Telelogic does not warrant that the Program will meet your
requirements or that the operation of the Program will be
uninterrupted and error free. You are solely responsible that the
selection of the Program and the modification of the source code
will achieve your intended results and that the results are actually
obtained.
*******************************************************************************/

/* * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * */
/*    NOTE. The operators Free...AvailList is not appropriate in   */
/*    an SDL system that is to be validated by the SDT Validator.  */
/*    It will in the Validator be a null action.                   */
/*                                                                 */
/*    NOTE ALSO. The operators in this data type is highly         */
/*    dependent on the data structures used to implement process,  */
/*    procedure, and signal. NO GAURENTEES can therefore be made   */
/*    that these operator are even possible to implemented in      */
/*    future releases of SDT.                                      */
/* * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * */

NEWTYPE PrdIdNode       /*#NAME 'xPrdIdNode'*/
/*#ADT(TA(S)E(S)R(S)W(S)D(H)HP)
#HEADING
#define  yDef_xPrdIdNode(yVar)  *(yVar) = (xPrdIdNode)0
*/
ENDNEWTYPE;

NEWTYPE SignalIdNode    /*#NAME 'xSignalIdNode'*/
/*#ADT(TA(S)E(S)R(S)W(S)D(H)HP)
#HEADING
#define  yDef_xSignalIdNode(yVar)  *(yVar) = (xSignalIdNode)0
*/
ENDNEWTYPE;

NEWTYPE PrsIdNode       /*#NAME 'xxPrsIdNode'*/
  OPERATORS
    GetIdNode           /*#NAME 'GetIdNode'*/
      : Pid -> PrsIdNode;
    Kill                /*#NAME 'Kill'*/
      : Pid -> Pid;
    KillAll             /*#NAME 'KillAll'*/
      : PrsIdNode -> Integer;
    FirstPid            /*#NAME 'FirstPid'*/
      : PrsIdNode -> Pid;
    SucPid              /*#NAME 'SucPid'*/
      : Pid -> Pid;
    InputPortLength     /*#NAME 'InputPortLength'*/
      : Pid -> Integer;
    InputPortLength     /*#NAME 'InputPortLengthI'*/
      : Pid, SignalIdNode -> Integer;
    NoOfProcesses       /*#NAME 'NoOfProcesses'*/
      : PrsIdNode -> Integer;
    IsStopped           /*#NAME 'IsStopped'*/
      : Pid -> Boolean;
    Broadcast           /*#NAME 'Broadcast'*/
      : PrsIdNode, SignalIdNode, Pid -> Integer;
    FreePrsAvailList    /*#NAME 'FreePrsAvailList'*/
      : PrsIdNode -> Integer;
    FreePrdAvailList    /*#NAME 'FreePrdAvailList'*/
      : PrdIdNode -> Integer;
    FreeSignalAvailList /*#NAME 'FreeSignalAvailList'*/
      : SignalIdNode -> Integer;

/*#ADT(TA(S)E(S)R(S)W(S)D(H)HP)
#TYPE
typedef xPrsIdNode xxPrsIdNode;
#HEADING
#define  yDef_xxPrsIdNode(yVar)  *(yVar) = (xPrsIdNode)0
extern xPrsIdNode   GetIdNode        ( SDL_PId P );
extern SDL_PId      Kill             ( SDL_PId P );
extern SDL_Integer  KillAll          ( xPrsIdNode Process );
extern SDL_PId      FirstPid         ( xPrsIdNode Process );
extern SDL_PId      SucPid           ( SDL_PId P );
extern SDL_Integer  InputPortLength  ( SDL_PId P );
extern SDL_Integer  InputPortLengthI ( SDL_PId P, xSignalIdNode Signal );
extern SDL_Integer  NoOfProcesses    ( xPrsIdNode Process );
extern SDL_Boolean  IsStopped        ( SDL_PId P );
extern SDL_Integer  Broadcast
       ( xPrsIdNode Process, xSignalIdNode Signal, SDL_PId Sender );
extern SDL_Integer  FreePrsAvailList    ( xPrsIdNode Id );
extern SDL_Integer  FreePrdAvailList    ( xPrdIdNode Id );
extern SDL_Integer  FreeSignalAvailList ( xSignalIdNode Id );

#BODY
#ifdef XVALIDATOR_LIB
#define xIsStopped(P) (P == xStoppedPId)
#else

#ifndef XPRSOPT
#define xIsStopped(P) (P.LocalPId != P.LocalPId->PrsP->Self.LocalPId)
#else
#ifdef XNRINST
#define xIsStopped(P) (P.LocalPId->InstNr == 0)
#else
#define xIsStopped(P) (P.LocalPId->InAvailList)
#endif
#endif

#ifdef xFirstActivePrs
#undef xFirstActivePrs
#endif
#define xFirstActivePrs(PNode)  (*PNode->ActivePrsList)

#ifdef xNextActivePrs
#undef xNextActivePrs
#endif
#define xNextActivePrs(P)  P->NextPrs

#define GetPrs(P)  P.LocalPId->PrsP
#endif


xPrsIdNode GetIdNode( SDL_PId P )
{
#ifdef XOPERRORF
  if ( xEq_SDL_PId_NULL(P) ) {
    xSDLOpError("GetIdNode in sort PrsIdNode", "PId parameter is NULL");
    return (xPrsIdNode)0;
  }
#endif
  return GetPrs(P)->NameNode;
}

SDL_PId Kill( SDL_PId P )
{
#ifdef XOPERRORF
  if ( xEq_SDL_PId_NULL(P) ) {
    xSDLOpError("Kill in sort PrsIdNode", "PId parameter is NULL");
    return SDL_NULL;
  }
  if ( xIsStopped(P) ) {
    xSDLOpError("Kill in sort PrsIdNode", "Process is stopped");
    return SDL_NULL;
  }
#endif
  SDL_Stop(GetPrs(P));
  return SDL_NULL;
}

SDL_Integer KillAll( xPrsIdNode Process )
{
  SDL_Integer I;
#ifdef XOPERRORF
  if ( Process == (xPrsIdNode)0 ) {
    xSDLOpError("KillAll in sort PrsIdNode", "PrsIdNode parameter is 0");
    return 0;
  }
#endif
  I = 0;
  while ( xFirstActivePrs(Process) != (xPrsNode)0 ) {
    SDL_Stop(xFirstActivePrs(Process));
    I++;
  }
  return I;
}

SDL_PId FirstPid( xPrsIdNode Process )
{
#ifdef XOPERRORF
  if ( Process == (xPrsIdNode)0 ) {
    xSDLOpError("FirstPid in sort PrsIdNode", "PrsIdNode parameter is 0");
    return SDL_NULL;
  }
#endif
  if ( xFirstActivePrs(Process) == (xPrsNode)0 )
    return SDL_NULL;
  return xFirstActivePrs(Process)->Self;
}

SDL_PId SucPid( SDL_PId P )
{
#ifdef XOPERRORF
  if ( xEq_SDL_PId_NULL(P) ) {
    xSDLOpError("SucPid in sort PrsIdNode", "PId parameter is NULL");
    return SDL_NULL;
  }
  if ( xIsStopped(P) ) {
    xSDLOpError("SucPid in sort PrsIdNode", "Process is stopped");
    return SDL_NULL;
  }
#endif
  if ( xNextActivePrs(GetPrs(P)) == (xPrsNode)0 )
    return SDL_NULL;
  return xNextActivePrs(GetPrs(P))->Self;
}

SDL_Integer InputPortLength( SDL_PId P )
{
  SDL_Integer I;
  xSignalNode IP, S;
#ifdef XOPERRORF
  if ( xEq_SDL_PId_NULL(P) ) {
    xSDLOpError("InputPortLength in sort PrsIdNode",
                "PId parameter is NULL");
    return 0;
  }
  if ( xIsStopped(P) ) {
    xSDLOpError("InputPortLength in sort PrsIdNode",
                "Process is stopped");
    return 0;
  }
#endif
  I = 0;
  IP = (xSignalNode)&(GetPrs(P)->InputPort);
  for (S = IP->Suc; S != IP; S = S->Suc) I++;
  return I;
}

SDL_Integer InputPortLengthI( SDL_PId P, xSignalIdNode Signal )
{
  SDL_Integer I;
  xSignalNode IP, S;
#ifdef XOPERRORF
  if ( xEq_SDL_PId_NULL(P) ) {
    xSDLOpError("InputPortLength in sort PrsIdNode",
                "PId parameter is NULL");
    return 0;
  }
  if ( xIsStopped(P) ) {
    xSDLOpError("InputPortLength in sort PrsIdNode",
                "Process is stopped");
    return 0;
  }
  if ( Signal == (xSignalIdNode)0 ) {
    xSDLOpError("InputPortLength in sort PrsIdNode",
                "SignalIdNode parameter is 0");
    return 0;
  }
#endif
  I = 0;
  IP =(xSignalNode)&(GetPrs(P)->InputPort);
  for (S = IP->Suc; S != IP; S = S->Suc)
    if (S->NameNode == Signal)
      I++;
  return I;
}

SDL_Integer NoOfProcesses( xPrsIdNode Process )
{
  SDL_Integer I;
  xPrsNode    P;
#ifdef XOPERRORF
  if ( Process == (xPrsIdNode)0 ) {
    xSDLOpError("NoOfProcesses in sort PrsIdNode",
                "PrsIdNode parameter is 0");
    return 0;
  }
#endif
  I = 0;
  for (P = xFirstActivePrs(Process);
       P != (xPrsNode)0;
       P = xNextActivePrs(P))
    I++;
  return I;
}

SDL_Boolean IsStopped( SDL_PId P )
{
#ifdef XOPERRORF
  if ( xEq_SDL_PId_NULL(P) ) {
    xSDLOpError("IsStopped in sort PrsIdNode",
                "PId parameter is NULL");
    return SDL_True;
  }
#endif
  return (SDL_Boolean) xIsStopped(P);
}

SDL_Integer Broadcast
  ( xPrsIdNode Process, xSignalIdNode Signal, SDL_PId Sender )
{
  SDL_Integer I;
  xPrsNode    P;
#ifdef XOPERRORF
  if ( Process == (xPrsIdNode)0 ) {
    xSDLOpError("Broadcast in sort PrsIdNode",
                "PrsIdNode parameter is 0");
    return 0;
  }
  if ( Signal == (xSignalIdNode)0 ) {
    xSDLOpError("Broadcast in sort PrsIdNode",
                "SignalIdNode parameter is 0");
    return 0;
  }
  if ( xEq_SDL_PId_NULL(Sender) ) {
    xSDLOpError("Broadcast in sort PrsIdNode",
                "PId parameter is NULL");
    return 0;
  }
  if ( xIsStopped(Sender) ) {
    xSDLOpError("Broadcast in sort PrsIdNode",
                "Process referenced by PId parameter is stopped");
    return 0;
  }
#endif
  I = 0;
  for (P = xFirstActivePrs(Process);
       P != (xPrsNode)0;
       P = xNextActivePrs(P)) {
    I++;
    SDL_Output(xGetSignal(Signal, P->Self, Sender)
               xSigPrioPar(xDefaultPrioSignal), (xIdNode *)0);
  }
  return I;
}

SDL_Integer FreePrsAvailList( xPrsIdNode Id )
{
#ifdef XVALIDATOR_LIB
  return 0;
#else
  SDL_Integer I;
  xPrsNode    ThisPrs, NextPrs;
#ifdef XOPERRORF
  if ( Id == (xPrsIdNode)0 ) {
    xSDLOpError("FreeAvailList in sort PrsIdNode",
                "PrsIdNode parameter is 0");
    return 0;
  }
#endif
  I = 0;
  ThisPrs = *Id->AvailPrsList;
  *Id->AvailPrsList = (xPrsNode)0;
  while ( ThisPrs != (xPrsNode)0 ) {
    NextPrs = ThisPrs->NextPrs;
#ifdef XPRSOPT
    xFree(&(ThisPrs->Self.LocalPId));
#endif
    xFree((void **)&ThisPrs);
    ThisPrs = NextPrs;
    I++;
  }
  return I;
#endif
}

SDL_Integer FreePrdAvailList( xPrdIdNode Id )
{
#ifdef XVALIDATOR_LIB
  return 0;
#else
  SDL_Integer I;
  xPrdNode    ThisPrd, NextPrd;
#ifdef XOPERRORF
  if ( Id == (xPrdIdNode)0 ) {
    xSDLOpError("FreeAvailList in sort PrsIdNode",
                "PrdIdNode parameter is 0");
    return 0;
  }
#endif
  I = 0;
  ThisPrd = *Id->AvailPrdList;
  *Id->AvailPrdList = (xPrdNode)0;
  while ( ThisPrd != (xPrdNode)0 ) {
    NextPrd = ThisPrd->DynamicFather;
    xFree((void **)&ThisPrd);
    ThisPrd = NextPrd;
    I++;
  }
  return I;
#endif
}

SDL_Integer FreeSignalAvailList( xSignalIdNode Id )
{
#ifdef XVALIDATOR_LIB
  return 0;
#else
  SDL_Integer I;
  xSignalNode ThisSig, NextSig;
#ifdef XOPERRORF
  if ( Id == (xSignalIdNode)0 ) {
    xSDLOpError("FreeAvailList in sort PrsIdNode",
                "SignalIdNode parameter is 0");
    return 0;
  }
#endif
  I = 0;
  if (Id->AvailSignalList != 0) {
    ThisSig = *Id->AvailSignalList;
    *Id->AvailSignalList = (xSignalNode)0;
    while ( ThisSig != (xSignalNode)0 ) {
      NextSig = ThisSig->Suc;
      xFree((void **)&ThisSig);
      ThisSig = NextSig;
      I++;
    }
  }
  return I;
#endif
}


*/
ENDNEWTYPE;