blinksemlibb.c

来自「8051试验程序 基础教材」· C语言 代码 · 共 898 行 · 第 1/2 页

          nNeg = (unsigned char)((i >> 8) & 0x0FF);
#endif
#if (SEM_RMN_GUARDS)
          nGuard = (unsigned char)((i >> 16) & 0x0FF);
#endif
          nNxt = (unsigned char)(i >> 24);
          i = VS.RD[iRI++];
          SEM.nAction = (unsigned char)(i & 0x0FF);
#if (SEM_RMN_SIGNALS)
          nSignal = (unsigned char)((i >> 8) & 0x0FF);
#endif
#endif
#if (VS_NOF_STATE_MACHINES != 0)
          for (nNo = 0 ; nNo < nPos; nNo++)
          {
            SEM_STATE_TYPE sa;
            sa = (SEM_STATE_TYPE) VS.RD[iRI++];
            if (sa != SEM.CSV[VS.SMI[sa]]) {
              goto NextRule;
            }
          }
#if (SEM_RMN_NEGATIVE_STATE_SYNCS)
          for (nNo = 0; nNo < nNeg; nNo++)
          {
            SEM_STATE_TYPE sa;
            i = VS.RD[iRI++];
            sa = SEM.CSV[VS.SMI[i]];
            if ((sa == STATE_UNDEFINED) || (sa == (SEM_STATE_TYPE) i)) {
              goto NextRule;
            }
          }
#endif
#endif

#if (VS_NOF_STATE_MACHINES != 0)
          for (nNo = 0; nNo < nNxt; nNo++)
          {
            SEM_STATE_TYPE sa;
            sa = (SEM_STATE_TYPE) VS.RD[iRI++];
            i = VS.SMI[sa];
            if (SEM.WSV[i] == STATE_UNDEFINED)
            {
              SEM.WSV[i] = sa;
            }
            else if (SEM.WSV[i] != sa)
            {
              SEM._iRI = iRI;
              return (SES_CONTRADICTION);
            }
          }
#endif
#if (SEM_RMN_SIGNALS)
          if (nSignal)
          {
            for (nNo = 0; nNo < nSignal; nNo++)
            {
              i = VS.RD[iRI++];
#if (SEM_SIGNAL_QUEUE_ERROR_IF_FULL)
              if (SEM_SignalQueuePut ((SEM_EVENT_TYPE)i) == SES_SIGNAL_QUEUE_FULL) {
                SEM._iRI = iRI;
                return (SES_SIGNAL_QUEUE_FULL);
              }
#endif
#if (SEM_SIGNAL_QUEUE_NO_ERROR_IF_FULL)
              SEM_SignalQueuePut ((SEM_EVENT_TYPE)i);
#endif
            }
          }
#endif
          if (SEM.nAction)
          {
            *ActionNo = (SEM_ACTION_EXPRESSION_TYPE)VS.RD[iRI];
            if (SEM.nAction > 1)
            {
              iRI++;
              SEM._iRI = iRI;
              SEM.nAction--;
              SEM.State = STATE_SEM_OUTPUT;
            }
            return (SES_FOUND);
          }
NextRule :
          ;
        }
#if (VS_NOF_EVENT_GROUPS != 0)
        {
          SEM.State = STATE_SEM_PREPARE;
          break;
        }
#else
        {
#if (SEM_SIGNAL)
          goto Signal;
#else
          SEM.State = STATE_SEM_OKAY;
          return (SES_OKAY);
#endif
        }
#endif
      case STATE_SEM_OUTPUT :
        if (SEM.nAction)
        {
          *ActionNo = (SEM_ACTION_EXPRESSION_TYPE) VS.RD[SEM._iRI++];
          SEM.nAction--;
          return (SES_FOUND);
        }
        SEM.State = STATE_SEM_CONSULT;
        break;
      case STATE_SEM_OKAY :
        return (SES_OKAY);
      default :
        return (SES_EMPTY);
    }
  }
}


#if (SEM_GET_OUTPUT_ALL == 1)
#if (SEM_SIGNAL)
#error SEM_GetOutputAll cannot be used when the Project contains signals.
#endif
unsigned char BlinkSEM_GetOutputAll (SEM_ACTION_EXPRESSION_TYPE *ActionVector,
  SEM_ACTION_EXPRESSION_TYPE MaxSize)
{
  SEM_ACTION_EXPRESSION_TYPE i;
  unsigned char CC;

  for (i = 0; ((CC = BlinkSEM_GetOutput(&ActionVector[i])) == SES_FOUND) && i < MaxSize - 1; i++);

  if (CC == SES_OKAY)
  {
    ActionVector[i] = ACTION_EXPRESSION_TERMINATION_ID;
    return (SES_OKAY);
  }
  if (CC == SES_FOUND) {
    return (SES_BUFFER_OVERFLOW);
  }
  return (CC);
}
#endif


#if (SEM_NEXT_STATE_CHG == 1)
unsigned char BlinkSEM_NextStateChg (void)
#else
unsigned char BlinkSEM_NextState (void)
#endif
{
  unsigned char CC;
  SEM_ACTION_EXPRESSION_TYPE nAction;

  if (SEM.State != STATE_SEM_OKAY)
  {
    while ((CC = BlinkSEM_GetOutput (&nAction)) == SES_FOUND) {
      ;
    }
    if (CC != SES_OKAY) {
      return(CC);
    }
  }
#if (VS_NOF_STATE_MACHINES != 0)
  {
    SEM_STATE_MACHINE_TYPE i;
    for (i = 0; i < VS_NOF_STATE_MACHINES; i++)
    {
      if (SEM.WSV[i] != STATE_UNDEFINED)
      {
#if (SEM_NEXT_STATE_CHG == 1)
        if (SEM.CSV[i] != SEM.WSV[i]) {
          SEM.Chg = 1;
        }
#endif
        SEM.CSV[i] = SEM.WSV[i];
        SEM.WSV[i] = STATE_UNDEFINED;
      }
    }
  }
#endif
  SEM.State = STATE_SEM_INITIALIZE;

#if (SEM_NEXT_STATE_CHG == 1)
  if (SEM.Chg)
  {
    SEM.Chg = 0;
    return (SES_FOUND);
  }
  return (SES_OKAY);
#else
  return (SES_OKAY);
#endif
}


#if (SEM_NAME == 1)
unsigned char BlinkSEM_Name (unsigned char IdentType, 
  SEM_EXPLANATION_TYPE IdentNo, char *Text, unsigned short MaxSize)
{
  char  c, *s;
  unsigned short i;

  if (!MaxSize) {
    return (SES_TEXT_TOO_LONG);
  }
  switch (IdentType)
  {
#if (VS_EVENT_NAMES != 0)
    case EVENT_TYPE :
      if (VS_NOF_EVENTS <= IdentNo) {
        return (SES_RANGE_ERR);
      }
      s = (char *)VS.ENames + VS.ENI[IdentNo];
      break;
#endif
#if ((VS_STATE_NAMES != 0) && (VS_NOF_STATES != 0))
    case STATE_TYPE :
      if (VS_NOF_STATES <= IdentNo) {
        return (SES_RANGE_ERR);
      }
      s = (char *)VS.SNames + VS.SNI[IdentNo];
      break;
#endif
#if ((VS_ACTION_FUNCTION_NAMES != 0) && (VS_NOF_ACTION_FUNCTIONS != 0))
    case ACTION_TYPE :
      if (VS_NOF_ACTION_FUNCTIONS <= IdentNo) {
        return (SES_RANGE_ERR);
      }
      s = (char *)VS.ANames + VS.ANI[IdentNo];
      break;
#endif
    default :
      return (SES_TYPE_ERR);
  }
  for (i = 0; i < MaxSize; i++)
  {
    c = *s++;
    *Text++ = c;
    if (c == '\0') {
      return (SES_OKAY);
    }
  }
  Text--;
  *Text = '\0';
  return (SES_TEXT_TOO_LONG);
}
#endif


#if (SEM_NAME_ABS == 1)
unsigned char BlinkSEM_NameAbs (unsigned char IdentType, 
  SEM_EXPLANATION_TYPE IdentNo, char const **Text)
{
  switch (IdentType)
  {
#if (VS_EVENT_NAMES != 0)
    case EVENT_TYPE :
      if (VS_NOF_EVENTS <= IdentNo) {
        return (SES_RANGE_ERR);
      }
      *Text = (char const *)&VS.ENames + VS.ENI[IdentNo];
      break;
#endif
#if ((VS_STATE_NAMES != 0) && (VS_NOF_STATES != 0))
    case STATE_TYPE :
      if (VS_NOF_STATES <= IdentNo) {
        return (SES_RANGE_ERR);
      }
      *Text = (char const *)&VS.SNames + VS.SNI[IdentNo];
      break;
#endif
#if ((VS_ACTION_FUNCTION_NAMES != 0) && (VS_NOF_ACTION_FUNCTIONS != 0))
    case ACTION_TYPE :
      if (VS_NOF_ACTION_FUNCTIONS <= IdentNo) {
        return (SES_RANGE_ERR);
      }
      *Text = (char const *)&VS.ANames + VS.ANI[IdentNo];
      break;
#endif
    default :
      return (SES_TYPE_ERR);
  }
  return (SES_OKAY);
}
#endif


#if (SEM_EXPL == 1)
unsigned char BlinkSEM_Expl (unsigned char IdentType, SEM_EXPLANATION_TYPE IdentNo,
  char *Text, unsigned short MaxSize)
{
  char  c, *s;
  unsigned short i;

  if (!MaxSize) {
    return (SES_TEXT_TOO_LONG);
  }
  switch (IdentType)
  {
#if (VS_EVENT_EXPLS != 0)
    case EVENT_TYPE :
      if (VS_NOF_EVENTS <= IdentNo) {
        return (SES_RANGE_ERR);
      }
      s = (char *)VS.EExpls + VS.EEI[IdentNo];
      break;
#endif
#if ((VS_STATE_EXPLS != 0) && (VS_NOF_STATES != 0))
    case STATE_TYPE :
      if (VS_NOF_STATES <= IdentNo) {
        return (SES_RANGE_ERR);
      }
      s = (char *)VS.SExpls + VS.SEI[IdentNo];
      break;
#endif
#if ((VS_ACTION_EXPLS != 0) && (VS_NOF_ACTION_FUNCTIONS != 0))
    case ACTION_TYPE :
      if (VS_NOF_ACTION_FUNCTIONS <= IdentNo) {
        return (SES_RANGE_ERR);
      }
      s = (char *)VS.AExpls + VS.AEI[IdentNo];
      break;
#endif
    default :
      return (SES_TYPE_ERR);
  }

  for (i = 0; i < MaxSize; i++)
  {
    c = *s++;
    *Text++ = c;
    if (c == '\0') {
      return (SES_OKAY);
    }
  }
  Text--;
  *Text = '\0';
  return (SES_TEXT_TOO_LONG);
}
#endif


#if (SEM_EXPL_ABS == 1)
unsigned char BlinkSEM_ExplAbs (unsigned char IdentType,
  SEM_EXPLANATION_TYPE IdentNo, char const **Text)
{
  switch (IdentType)
  {
#if (VS_EVENT_EXPLS != 0)
    case EVENT_TYPE :
      if (VS_NOF_EVENTS <= IdentNo) {
        return (SES_RANGE_ERR);
      }
      *Text = (char const *)&VS.EExpls + VS.EEI[IdentNo];
      break;
#endif
#if ((VS_STATE_EXPLS != 0) && (VS_NOF_STATES != 0))
    case STATE_TYPE :
      if (VS_NOF_STATES <= IdentNo) {
        return (SES_RANGE_ERR);
      }
      *Text = (char const *)&VS.SExpls + VS.SEI[IdentNo];
      break;
#endif
#if ((VS_ACTION_EXPLS != 0) && (VS_NOF_ACTION_FUNCTIONS != 0))
    case ACTION_TYPE :
      if (VS_NOF_ACTION_FUNCTIONS <= IdentNo) {
        return (SES_RANGE_ERR);
      }
      *Text = (char const *)&VS.AExpls + VS.AEI[IdentNo];
      break;
#endif
    default :
      return (SES_TYPE_ERR);
  }
  return (SES_OKAY);
}
#endif


#if (SEM_STATE == 1)
unsigned char BlinkSEM_State (SEM_STATE_MACHINE_TYPE StateMachineNo,
  SEM_STATE_TYPE *StateNo)
{
  if (VS_NOF_STATE_MACHINES <= StateMachineNo) {
    return (SES_RANGE_ERR);
  }
#if (VS_NOF_STATE_MACHINES != 0)
  *StateNo = SEM.CSV[StateMachineNo];
#else
  *StateNo = 0;
#endif
  return (SES_FOUND);
}
#endif


#if (SEM_STATE_ALL == 1)
unsigned char BlinkSEM_StateAll (SEM_STATE_TYPE *StateVector,
  SEM_STATE_MACHINE_TYPE MaxSize)
{
  SEM_STATE_MACHINE_TYPE i;

  if (VS_NOF_STATE_MACHINES > MaxSize) {
    return (SES_BUFFER_OVERFLOW);
  }

#if (VS_NOF_STATE_MACHINES != 0)
  for (i = 0; i < VS_NOF_STATE_MACHINES; i++) {
    StateVector[i] = SEM.CSV[i];
  }
#else
  for (i = 0; i < VS_NOF_STATE_MACHINES; i++) {
    StateVector[i] = 0;
  }
#endif
  return (SES_FOUND);
}
#endif


#if (SEM_MACHINE == 1)
unsigned char BlinkSEM_Machine (SEM_STATE_TYPE StateNo,
  SEM_STATE_MACHINE_TYPE *StateMachineNo)
{
  if (VS_NOF_STATES <= StateNo) {
    return (SES_RANGE_ERR);
  }
#if (VS_NOF_STATE_MACHINES != 0)
  *StateMachineNo = VS.SMI[StateNo];
#else
  *StateMachineNo = 0;
#endif
  return (SES_FOUND);
}
#endif


#if (SEM_FORCE_STATE == 1)
unsigned char BlinkSEM_ForceState (SEM_STATE_TYPE StateNo)
{
  if (VS_NOF_STATES <= StateNo) {
    return (SES_RANGE_ERR);
  }
#if (VS_NOF_STATE_MACHINES != 0)
  SEM.CSV[VS.SMI[StateNo]] = StateNo;
#endif
  return (SES_OKAY);
}
#endif