abnf.c

mgcp协议源代码和测试程序,还有一个编译器

    case MGCPParameter_ParamQuarantineHandling:
      Free_ParamQuarantineHandling(&MGCPParameter->u.ParamQuarantineHandling);
    break;

    /* Free ParamDetectEvents */
    case MGCPParameter_ParamDetectEvents:
      Free_ParamDetectEvents(&MGCPParameter->u.ParamDetectEvents);
    break;

    /* Free ParamRestartMethod */
    case MGCPParameter_ParamRestartMethod:
      Free_ParamRestartMethod(&MGCPParameter->u.ParamRestartMethod);
    break;

    /* Free ParamRestartDelay */
    case MGCPParameter_ParamRestartDelay:
      Free_ParamRestartDelay(&MGCPParameter->u.ParamRestartDelay);
    break;

    /* Free ParamCapabilities */
    case MGCPParameter_ParamCapabilities:
      Free_ParamCapabilities(&MGCPParameter->u.ParamCapabilities);
    break;

    /* Free ParamEventStates */
    case MGCPParameter_ParamEventStates:
      Free_ParamEventStates(&MGCPParameter->u.ParamEventStates);
    break;

    /* Free ParamPackageList */
    case MGCPParameter_ParamPackageList:
      Free_ParamPackageList(&MGCPParameter->u.ParamPackageList);
    break;

    /* Free ParamMaxMGCPDatagram */
    case MGCPParameter_ParamMaxMGCPDatagram:
      Free_ParamMaxMGCPDatagram(&MGCPParameter->u.ParamMaxMGCPDatagram);
    break;

    /* Free ExtendedParameter */
    case MGCPParameter_ExtendedParameter:
      Free_ExtendedParameter(&MGCPParameter->u.ExtendedParameter);
    break;

    default:
      Assert(0);
  }
}

int DE_ParamResponseAck(TCtx *ctx, TParamResponseAck *ParamResponseAck)
{
  /* String Element: K */
  if (ParseString(ctx, 1, 1, "K") != OK)
    return FAIL;

  /* String Element: : */
  if (ParseString(ctx, 1, 1, ":") != OK)
    return FAIL;

  /* Token Element: WSP */
  if (ParseToken(ctx, 0, 655, DE_WSP) != OK)
    return FAIL;

  /* Opt Element: ResponseAck */
  while (1)
  {
    CtxSave(ResponseAck, ctx);

    ParamResponseAck->ResponseAck.pRuleData = (TResponseAck*)AbnfAlloc(ctx, sizeof(TResponseAck));

    /* Rule Element in Option */
    if (DE_ResponseAck(ctx, (TResponseAck*)ParamResponseAck->ResponseAck.pRuleData) != OK)
    {
      CtxRestore(ctx, ResponseAck);
      break;
    }

    ParamResponseAck->ResponseAck.flag = 1;
    break;
  }

  return OK;
}

int EN_ParamResponseAck(TCtx *ctx, TParamResponseAck *ParamResponseAck)
{
  /* String Element: K */
  if (EncodeString(ctx, 1, "K") != OK)
    return FAIL;

  /* String Element: : */
  if (EncodeString(ctx, 1, ":") != OK)
    return FAIL;

  /* Token Element: WSP */
  if (EncodeToken(ctx, 0, EN_WSP) != OK)
    return FAIL;

  /* Opt Element: ResponseAck */
  if (ParamResponseAck->ResponseAck.flag)
  {
    TResponseAck *ResponseAck = (TResponseAck*)ParamResponseAck->ResponseAck.pRuleData;

    /* Rule Element in Option */
    if (EN_ResponseAck(ctx, ResponseAck) != OK)
      return FAIL;
  }

  return OK;
}

void Free_ParamResponseAck(TParamResponseAck *ParamResponseAck)
{
  /* Free Option: ResponseAck */
  if(ParamResponseAck->ResponseAck.flag)
  {
    Free_ResponseAck((TResponseAck*)ParamResponseAck->ResponseAck.pRuleData);
    free(ParamResponseAck->ResponseAck.pRuleData);
  }
}

int DE_ParamBearerInformation(TCtx *ctx, TParamBearerInformation *ParamBearerInformation)
{
  /* String Element: B */
  if (ParseString(ctx, 1, 1, "B") != OK)
    return FAIL;

  /* String Element: : */
  if (ParseString(ctx, 1, 1, ":") != OK)
    return FAIL;

  /* Token Element: WSP */
  if (ParseToken(ctx, 0, 655, DE_WSP) != OK)
    return FAIL;

  /* Opt Element: BearerInformation */
  while (1)
  {
    CtxSave(BearerInformation, ctx);

    ParamBearerInformation->BearerInformation.pRuleData = (TBearerInformation*)AbnfAlloc(ctx, sizeof(TBearerInformation));

    /* Rule Element in Option */
    if (DE_BearerInformation(ctx, (TBearerInformation*)ParamBearerInformation->BearerInformation.pRuleData) != OK)
    {
      CtxRestore(ctx, BearerInformation);
      break;
    }

    ParamBearerInformation->BearerInformation.flag = 1;
    break;
  }

  return OK;
}

int EN_ParamBearerInformation(TCtx *ctx, TParamBearerInformation *ParamBearerInformation)
{
  /* String Element: B */
  if (EncodeString(ctx, 1, "B") != OK)
    return FAIL;

  /* String Element: : */
  if (EncodeString(ctx, 1, ":") != OK)
    return FAIL;

  /* Token Element: WSP */
  if (EncodeToken(ctx, 0, EN_WSP) != OK)
    return FAIL;

  /* Opt Element: BearerInformation */
  if (ParamBearerInformation->BearerInformation.flag)
  {
    TBearerInformation *BearerInformation = (TBearerInformation*)ParamBearerInformation->BearerInformation.pRuleData;

    /* Rule Element in Option */
    if (EN_BearerInformation(ctx, BearerInformation) != OK)
      return FAIL;
  }

  return OK;
}

void Free_ParamBearerInformation(TParamBearerInformation *ParamBearerInformation)
{
  /* Free Option: BearerInformation */
  if(ParamBearerInformation->BearerInformation.flag)
  {
    Free_BearerInformation((TBearerInformation*)ParamBearerInformation->BearerInformation.pRuleData);
    free(ParamBearerInformation->BearerInformation.pRuleData);
  }
}

int DE_ParamCallId(TCtx *ctx, TParamCallId *ParamCallId)
{
  /* String Element: C */
  if (ParseString(ctx, 1, 1, "C") != OK)
    return FAIL;

  /* String Element: : */
  if (ParseString(ctx, 1, 1, ":") != OK)
    return FAIL;

  /* Token Element: WSP */
  if (ParseToken(ctx, 0, 655, DE_WSP) != OK)
    return FAIL;

  /* Rule Element: CallId */
  if (ParseStrRule(ctx, &ParamCallId->CallId, 1, 1, DE_CallId) != OK)
    return FAIL;

  return OK;
}

int EN_ParamCallId(TCtx *ctx, TParamCallId *ParamCallId)
{
  /* String Element: C */
  if (EncodeString(ctx, 1, "C") != OK)
    return FAIL;

  /* String Element: : */
  if (EncodeString(ctx, 1, ":") != OK)
    return FAIL;

  /* Token Element: WSP */
  if (EncodeToken(ctx, 0, EN_WSP) != OK)
    return FAIL;

  /* Rule Element: CallId */
  if (EncodeString(ctx, 1, ParamCallId->CallId) != OK)
    return FAIL;

  return OK;
}

void Free_ParamCallId(TParamCallId *ParamCallId)
{
  /* Free String: CallId */
  free(ParamCallId->CallId);
}

int DE_ParamConnectionId(TCtx *ctx, TParamConnectionId *ParamConnectionId)
{
  /* String Element: I */
  if (ParseString(ctx, 1, 1, "I") != OK)
    return FAIL;

  /* String Element: : */
  if (ParseString(ctx, 1, 1, ":") != OK)
    return FAIL;

  /* Token Element: WSP */
  if (ParseToken(ctx, 0, 655, DE_WSP) != OK)
    return FAIL;

  /* Opt Element: ConnectionId */
  while (1)
  {
    CtxSave(ConnectionId, ctx);

    ParamConnectionId->ConnectionId.pRuleData = (TConnectionId*)AbnfAlloc(ctx, sizeof(TConnectionId));

    /* Rule Element in Option */
    if (DE_ConnectionId(ctx, (TConnectionId*)ParamConnectionId->ConnectionId.pRuleData) != OK)
    {
      CtxRestore(ctx, ConnectionId);
      break;
    }

    ParamConnectionId->ConnectionId.flag = 1;
    break;
  }

  return OK;
}

int EN_ParamConnectionId(TCtx *ctx, TParamConnectionId *ParamConnectionId)
{
  /* String Element: I */
  if (EncodeString(ctx, 1, "I") != OK)
    return FAIL;

  /* String Element: : */
  if (EncodeString(ctx, 1, ":") != OK)
    return FAIL;

  /* Token Element: WSP */
  if (EncodeToken(ctx, 0, EN_WSP) != OK)
    return FAIL;

  /* Opt Element: ConnectionId */
  if (ParamConnectionId->ConnectionId.flag)
  {
    TConnectionId *ConnectionId = (TConnectionId*)ParamConnectionId->ConnectionId.pRuleData;

    /* Rule Element in Option */
    if (EN_ConnectionId(ctx, ConnectionId) != OK)
      return FAIL;
  }

  return OK;
}

void Free_ParamConnectionId(TParamConnectionId *ParamConnectionId)
{
  /* Free Option: ConnectionId */
  if(ParamConnectionId->ConnectionId.flag)
  {
    Free_ConnectionId((TConnectionId*)ParamConnectionId->ConnectionId.pRuleData);
    free(ParamConnectionId->ConnectionId.pRuleData);
  }
}

int DE_ParamNotifiedEntity(TCtx *ctx, TParamNotifiedEntity *ParamNotifiedEntity)
{
  /* String Element: N */
  if (ParseString(ctx, 1, 1, "N") != OK)
    return FAIL;

  /* String Element: : */
  if (ParseString(ctx, 1, 1, ":") != OK)
    return FAIL;

  /* Token Element: WSP */
  if (ParseToken(ctx, 0, 655, DE_WSP) != OK)
    return FAIL;

  /* Opt Element: NotifiedEntity */
  while (1)
  {
    CtxSave(NotifiedEntity, ctx);

    ParamNotifiedEntity->NotifiedEntity.pRuleData = (TNotifiedEntity*)AbnfAlloc(ctx, sizeof(TNotifiedEntity));

    /* Rule Element in Option */
    if (DE_NotifiedEntity(ctx, (TNotifiedEntity*)ParamNotifiedEntity->NotifiedEntity.pRuleData) != OK)
    {
      CtxRestore(ctx, NotifiedEntity);
      break;
    }

    ParamNotifiedEntity->NotifiedEntity.flag = 1;
    break;
  }

  return OK;
}

int EN_ParamNotifiedEntity(TCtx *ctx, TParamNotifiedEntity *ParamNotifiedEntity)
{
  /* String Element: N */
  if (EncodeString(ctx, 1, "N") != OK)
    return FAIL;

  /* String Element: : */
  if (EncodeString(ctx, 1, ":") != OK)
    return FAIL;

  /* Token Element: WSP */
  if (EncodeToken(ctx, 0, EN_WSP) != OK)
    return FAIL;

  /* Opt Element: NotifiedEntity */
  if (ParamNotifiedEntity->NotifiedEntity.flag)
  {
    TNotifiedEntity *NotifiedEntity = (TNotifiedEntity*)ParamNotifiedEntity->NotifiedEntity.pRuleData;

    /* Rule Element in Option */
    if (EN_NotifiedEntity(ctx, NotifiedEntity) != OK)
      return FAIL;
  }

  return OK;
}

void Free_ParamNotifiedEntity(TParamNotifiedEntity *ParamNotifiedEntity)
{
  /* Free Option: NotifiedEntity */
  if(ParamNotifiedEntity->NotifiedEntity.flag)
  {
    Free_NotifiedEntity((TNotifiedEntity*)ParamNotifiedEntity->NotifiedEntity.pRuleData);
    free(ParamNotifiedEntity->NotifiedEntity.pRuleData);
  }
}

int DE_ParamRequestIdentifier(TCtx *ctx, TParamRequestIdentifier *ParamRequestIdentifier)
{
  /* String Element: X */
  if (ParseString(ctx, 1, 1, "X") != OK)
    return FAIL;

  /* String Element: : */
  if (ParseString(ctx, 1, 1, ":") != OK)
    return FAIL;

  /* Token Element: WSP */
  if (ParseToken(ctx, 0, 655, DE_WSP) != OK)
    return FAIL;

  /* Opt Element: RequestIdentifier */
  while (1)
  {
    CtxSave(RequestIdentifier, ctx);

    /* Rule Element in Option */
    if (ParseStrRule(ctx, (char**)(&ParamRequestIdentifier->RequestIdentifier.pRuleData), 1, 1, DE_RequestIdentifier) != OK)
    {
      CtxRestore(ctx, RequestIdentifier);
      break;
    }

    ParamRequestIdentifier->RequestIdentifier.flag = 1;
    break;
  }

  return OK;
}

int EN_ParamRequestIdentifier(TCtx *ctx, TParamRequestIdentifier *ParamRequestIdentifier)
{
  /* String Element: X */
  if (EncodeString(ctx, 1, "X") != OK)
    return FAIL;

  /* String Element: : */
  if (EncodeString(ctx, 1, ":") != OK)
    return FAIL;

  /* Token Element: WSP */
  if (EncodeToken(ctx, 0, EN_WSP) != OK)
    return FAIL;

  /* Opt Element: RequestIdentifier */
  if (ParamRequestIdentifier->RequestIdentifier.flag)
  {
    char *RequestIdentifier = (char*)ParamRequestIdentifier->RequestIdentifier.pRuleData;

    /* Rule Element in Option */
    if (EncodeString(ctx, 1, RequestIdentifier) != OK)
      return FAIL;
  }

  return OK;
}

void Free_ParamRequestIdentifier(TParamRequestIdentifier *ParamRequestIdentifier)
{
  /* Free Option: RequestIdentifier */
  if(ParamRequestIdentifier->RequestIdentifier.flag)
  {
    free(ParamRequestIdentifier->RequestIdentifier.pRuleData);
  }
}

int DE_ParamLocalConnectionOptions(TCtx *ctx, TParamLocalConnectionOptions *ParamLocalConnectionOptions)
{
  /* String Element: L */
  if (ParseString(ctx, 1, 1, "L") != OK)
    return FAIL;

  /* String Element: : */
  if (ParseString(ctx, 1, 1, ":") != OK)
    return FAIL;

  /* Token Element: WSP */
  if (ParseToken(ctx, 0, 655, DE_WSP) != OK)
    return FAIL;

  /* Opt Element: LocalConnectionOptions */
  while (1)
  {
    CtxSave(LocalConnectionOptions, ctx);

    ParamLocalConnectionOptions->LocalConnectionOptions.pRuleData = (TLocalConnectionOptions*)AbnfAlloc(ctx, sizeof(TLocalConnectionOptions));

    /* Rule Element in Option */
    if (DE_LocalConnectionOptions(ctx, (TLocalConnectionOptions*)ParamLocalConnectionOptions->LocalConnectionOptions.pRuleData) != OK)
    {
      CtxRestore(ctx, LocalConnectionOptions);
      break;
    }

    ParamLocalConnectionOptions->LocalConnectionOptions.flag = 1;
    break;
  }

  return OK;
}

int EN_ParamLocalConnectionOptions(TCtx *ctx, TParamLocalConnectionOptions *ParamLocalConnectionOptions)
{
  /* String Element: L */
  if (EncodeString(ctx, 1, "L") != OK)
    return FAIL;

  /* String Element: : */
  if (EncodeString(ctx, 1, ":") != OK)
    return FAIL;

  /* Token Element: WSP */
  if (EncodeToken(ctx, 0, EN_WSP) != OK)
    return FAIL;

  /* Opt Element: LocalConnectionOptions */
  if (ParamLocalConnectionOptions->LocalConnectionOptions.flag)
  {
    TLocalConnectionOptions *LocalConnectionOptions = (TLocalConnectionOptions*)ParamLocalConnectionOptions->LocalConnectionOptions.pRuleData;

    /* Rule Element in Option */
    if (EN_LocalConnectionOptions(ctx, LocalConnectionOptions) != OK)
      return FAIL;
  }

  return OK;
}

void Free_ParamLocalConnectionOptions(TParamLocalConnectionOptions *ParamLocalConnectionOptions)
{
  /* Free Option: LocalConnectionOptions */
  if(ParamLocalConnectionOptions->LocalConnectionOptions.flag)
  {
    Free_LocalConnectionOptions((TLocalConnectionOptions*)ParamLocalConnectionOptions->LocalConnectionOptions.pRuleData);
    free(ParamLocalConnectionOptions->LocalConnectionOptions.pRuleData);
  }
}

int DE_ParamConnectionMode(TCtx *ctx, TParamConnectionMode *ParamConnectionMode)
{
  /* String Element: M */
  if (ParseString(ctx, 1, 1, "M") != OK)
    return FAIL;

  /* String Element: : */
  if (ParseString(ctx, 1, 1, ":") != OK)
    return FAIL;

  /* Token Element: WSP */
  if (ParseToken(ctx, 0, 655, DE_WSP) != OK)
    return FAIL;

  /* Rule Element: ConnectionMode */
  if (DE_ConnectionMode(ctx, &ParamConnectionMode->ConnectionMode) != OK)
    return FAIL;

  return OK;