mk_queu.c

是一个手机功能的模拟程序

      **   save pointer to that signal
      */
      f = *rover ;

      /*
      **   remove that signal from the queue
      */
      *rover = ( *rover )->next ;

      /*
      **   insert the removed signal into the free list
      */
      xmk_FreeSignal( ( xmk_T_MESSAGE xmk_RAM_ptr)f ) ;

    } 
    else
    {

      /*
      **  Signal pointer may have been affected already in if-loop above !!
      */
      rover = &( ( *rover )->next );
    } /* END IF */
  } /* END WHILE */

  XMK_END_CRITICAL_PATH;

  #ifdef XMK_ADD_PRINTF_QUEUE
    XMK_TRACE_EXIT("xmk_RemoveSignalBySignalID");
  #endif

} /* END OF FUNCTION */

#if defined(XMK_USED_DYNAMIC_STOP) || defined(XMK_USE_CMD_KILL)

/*+FHDR E*/
/*
+------------------------------------------------------------------------------+
|  Functionname : xmk_RemoveSignalsByProcessID                                 |
|  Author       : S&P Media GmbH Germany                                       |
+------------------------------------------------------------------------------+
|                                                                              |
|                                                                              |
|  Description  :                                                              |
|  All signals addressed to a specific process are removed by calling this     |
|  Function.                                                                   |
|                                                                              |
|  Parameter    : ProcessId  - PID of Process                                  |
|                                                                              |
|  Return       : -                                                            |
|                                                                              |
+------------------------------------------------------------------------------+
*/
/*-FHDR E*/

/*+FDEF E*/

#ifndef XNOPROTO
  void xmk_RemoveSignalsByProcessID( xPID ProcessID )
#else
  void xmk_RemoveSignalsByProcessID( ProcessID )
  xPID           ProcessID;
#endif

/*-FDEF E*/

{
  X_REGISTER T_E_SIGNAL xmk_RAM_ptr xmk_RAM_ptr rover;

  #ifndef XMK_USE_RECEIVER_PID_IN_SIGNAL
    xPID OwnerProcessPID ;
  #endif

  #ifdef XMK_ADD_PRINTF_QUEUE
    XMK_FUNCTION("xmk_RemoveSignalsByProcessID");
  #endif

  XMK_BEGIN_CRITICAL_PATH;

  #ifdef XMK_USE_PREEMPTIVE
    rover = &Prio_Queue[EPIDTYPE(ProcessID)];
  #else
    rover = &xmk_Queue;
  #endif

  /*
  **     for all the signals in the queue
  */
  while (*rover != (T_E_SIGNAL xmk_RAM_ptr) NULL)
  {
    #ifdef XMK_USE_RECEIVER_PID_IN_SIGNAL
      if ( ( *rover               != XMK_CURRENTSIGNAL) &&
           ( (*rover)->Signal.rec == ProcessID) )
    #else
      OwnerProcessPID = xRouteSignal ((*rover)->Signal.signal) ;
      if ( ( *rover               != XMK_CURRENTSIGNAL) &&
           ( OwnerProcessPID == ProcessID ) )

    #endif
    {

      /*
      ** The element, which must be unchained, is found.
      */
      T_E_SIGNAL xmk_RAM_ptr f;

      f= *rover;
      *rover = (*rover)->next;
      xmk_FreeSignal(( xmk_T_MESSAGE xmk_RAM_ptr )f);
    }  
    else
    {
      /*
      ** load next element
      */
      rover = &( (*rover)->next );
    }  /* END IF */
  } /* END WHILE */

  XMK_END_CRITICAL_PATH;

  #ifdef XMK_ADD_PRINTF_QUEUE
    XMK_TRACE_EXIT("xmk_RemoveSignalsByProcessID");
  #endif

} /* END OF FUNCTION */

#endif /* ... XMK_USED_DYNAMIC_STOP */


/*+FHDR E*/
/*
+------------------------------------------------------------------------------+
|  Functionname : xmk_AllocSignal                                              |
|  Author       : S&P Media GmbH Germany                                       |
+------------------------------------------------------------------------------+
|                                                                              |
|  Description  :                                                              |
|  An initialized signal from the beginning of the list of free signals        |
|  is returned, as far as there still remains one. If not NULL is returned.    |
|                                                                              |
|  A pointer to the signal that was allocated is returned usually, or NULL, if |
|  there is no space left to allocate one more signal.                         |
|                                                                              |
|  Parameter    : -                                                            |
|                                                                              |
|  Return       : Pointer to returned signal                                   |
|                 (NULL if there is none)                                      |
|                                                                              |
+------------------------------------------------------------------------------+
*/
/*-FHDR E*/

/*+FDEF E*/

#ifndef XNOPROTO
  xmk_T_MESSAGE xmk_RAM_ptr xmk_AllocSignal( void )
#else
  xmk_T_MESSAGE xmk_RAM_ptr xmk_AllocSignal( )
#endif

/*-FDEF E*/

{
  X_REGISTER T_E_SIGNAL xmk_RAM_ptr AllocatedMessage ;

  #ifdef XMK_ADD_PRINTF_QUEUE
    XMK_FUNCTION("xmk_AllocSignal");
  #endif

  /*
  **  Return-value: first signal in free list
  */
  AllocatedMessage = xmk_FreeListPointer ;

  /*
  **  if that signal isn't NULL
  */
  if( AllocatedMessage != (T_E_SIGNAL xmk_RAM_ptr) NULL )
  {
    /*
    **    set pointer to first signal in free list to the next one
    */
    xmk_FreeListPointer = xmk_FreeListPointer->next ;

  } /* END IF */

  #ifdef XMK_ADD_PRINTF_QUEUE
    XMK_TRACE_EXIT("xmk_AllocSignal");
  #endif

  return( (xmk_T_MESSAGE xmk_RAM_ptr)AllocatedMessage ) ;

} /* END OF FUNCTION */



/*+FHDR E*/
/*
+------------------------------------------------------------------------------+
|  Functionname : xmk_FreeSignal                                               |
|  Author       : S&P Media GmbH Germany                                       |
+------------------------------------------------------------------------------+
|                                                                              |
|  Description  :                                                              |
|  A signal is initialized and inserted into the free-list at the first        |
|  position.                                                                   |
|                                                                              |
|  The parameter p_Message must point to the signal that is to be initialized. |
|                                                                              |
|  Parameter    : *p_Message - Pointer to signal to be initialized             |
|                                                                              |
|  Return       : -                                                            |
|                                                                              |
+------------------------------------------------------------------------------+
*/
/*-FHDR E*/

/*+FDEF E*/

#ifndef XNOPROTO
  void xmk_FreeSignal( xmk_T_MESSAGE xmk_RAM_ptr p_Message )
#else
  void xmk_FreeSignal( p_Message )
  xmk_T_MESSAGE xmk_RAM_ptr p_Message;
#endif

/*-FDEF E*/

{
  X_REGISTER T_E_SIGNAL xmk_RAM_ptr element ;

  #ifdef XMK_ADD_PRINTF_QUEUE
    XMK_FUNCTION("xmk_FreeSignal");
  #endif

  element = (T_E_SIGNAL xmk_RAM_ptr )p_Message ;

  /*
  **     if signal's parameter are in an allocated memory area
  */
  #ifdef XMK_USED_SIGNAL_WITH_PARAMS
    if (element->Signal.mess_length > XMK_MSG_BORDER_LEN)
    {
      /*
      **     free the allocated memory area
      */
      xFree (&element->Signal.ParUnion.ParPtr);
    }
  #endif

  #ifdef XMK_USED_SAVE
    /*
    **    Reset signal's SaveState 
    */
    element->SaveState = 0;
  #endif

  #ifndef XMK_USE_HIGH_OPTIMIZATION
    /*
    **    set all the information in the signal to zero (initialize signal)
    */
    (void)memset( (void xmk_RAM_ptr) element, 0, sizeof( T_E_SIGNAL) ) ;
  #endif

  /*
  **   Insert signal in front of the free-list and set
  **   pointer to free list to the new signal
  */
  element->next = xmk_FreeListPointer ;
  xmk_FreeListPointer = element ;
  XMK_Q_DECR_ACT

  #ifdef XMK_ADD_PRINTF_QUEUE
    XMK_TRACE_EXIT("xmk_FreeSignal");
  #endif

} /* END OF FUNCTION */



#ifdef XMK_USED_SAVE

/*+FHDR E*/
/*
+------------------------------------------------------------------------------+
|  Functionname : xmk_TestAndSetSaveState                                      |
|  Author       : S&P Media GmbH Germany                                       |
+------------------------------------------------------------------------------+
|                                                                              |
|  Description  :                                                              |
|  This function tests whether the current signal's SAVE-state is set or not.  |
|  In testing, the SAVE-state is set.                                          |
|                                                                              |
|  Parameter    : State - SAVE-state                                           |
|                                                                              |
|  Return       : XMK_TRUE  - the given SAVE-state equals the signal's         |
|                             SAVE state                                       |
|                 XMK_FALSE - the given SAVE-sate differs from the signal's    |
|                                                                              |
+------------------------------------------------------------------------------+
*/
/*-FHDR E*/

/*+FDEF E*/

#ifndef XNOPROTO
  xmk_T_BOOL xmk_TestAndSetSaveState( xmk_T_STATE State )
#else
  xmk_T_BOOL xmk_TestAndSetSaveState( State )
  xmk_T_STATE State ;
#endif

/*-FDEF E*/

{
  X_REGISTER xmk_T_BOOL match = XMK_FALSE ;

  #ifdef XMK_ADD_PRINTF_QUEUE
    XMK_FUNCTION("xmk_TestAndSetSaveState");
  #endif

  XMK_BEGIN_CRITICAL_PATH;

  /*
  **   If there is a signal in the queue
  */
  if( XMK_CURRENTSIGNAL != (T_E_SIGNAL *) NULL )
  {

    /*
    **     Test if signal's save state equals parameter State
    */
    match = ( (XMK_CURRENTSIGNAL)->SaveState == State ) ;