abnf.c

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

/* This file is generated by abnf compiler
 * Data   : 14:21:39 Aug 28 2008 
 */

#include <stdio.h>
#include <stdlib.h>
#include <string.h>

#include "parser.h"
#include "typedef.h"
#include "debg.h"
#include "abnf.h"


int DE_MGCPMsgList(TCtx *ctx, TMGCPMsgList *MGCPMsgList)
{
  /* RuleLst Element: MGCPMessage */
  ListNewNode(ctx, &MGCPMsgList->MGCPMessage, sizeof(TMGCPMessage));

  if (DE_MGCPMessage(ctx, (TMGCPMessage*)MGCPMsgList->MGCPMessage.pNode) != OK)
  {
    ListRemoveLast(&MGCPMsgList->MGCPMessage);
    return FAIL;
  }

  /* RuleList Group Element: MGCPMessage */
  while (1)
  {
    TMGCPMessage *MGCPMessage = (TMGCPMessage*)ListNewNode(ctx, &MGCPMsgList->MGCPMessage, sizeof(TMGCPMessage));

    CtxSave(MGCPMessage, ctx);

    /* String Element in Group */
    if (ParseString(ctx, 1, 1, ".") != OK)
    {
      CtxRestore(ctx, MGCPMessage);
      ListRemoveLast(&MGCPMsgList->MGCPMessage);
      break;
    }

    /* Token Element in Group: EOL */
    if (ParseToken(ctx, 1, 1, DE_EOL) != OK)
    {
      CtxRestore(ctx, MGCPMessage);
      ListRemoveLast(&MGCPMsgList->MGCPMessage);
      break;
    }

    /* Rule Element in Group */
    if (DE_MGCPMessage(ctx, MGCPMessage) != OK)
    {
      CtxRestore(ctx, MGCPMessage);
      ListRemoveLast(&MGCPMsgList->MGCPMessage);
      break;
    }

    /* Rule num reach upper repeat limit */
    if (MGCPMsgList->MGCPMessage.iNum >= 655)
      break;
  }

    /* Rule num less than lower repeat limit */
  if (MGCPMsgList->MGCPMessage.iNum < 0)
    return FAIL;

  return OK;
}

int EN_MGCPMsgList(TCtx *ctx, TMGCPMsgList *MGCPMsgList)
{
  int i_MGCPMessage = 0;

  /* Check rule number in list */
  if (MGCPMsgList->MGCPMessage.iNum < 1)
    return FAIL;

  /* RuleList Element: MGCPMessage */
  if (EN_MGCPMessage(ctx, (TMGCPMessage*)MGCPMsgList->MGCPMessage.pNode) != OK)
    return FAIL;

  /* GrpRule in RuleLst */
  for (i_MGCPMessage = 1; i_MGCPMessage < MGCPMsgList->MGCPMessage.iNum; i_MGCPMessage++)
  {
    TMGCPMessage *MGCPMessage = (TMGCPMessage*)MGCPMsgList->MGCPMessage.pNode + i_MGCPMessage;

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

    /* Token Element in Group: EOL */
    if (EncodeToken(ctx, 1, EN_EOL) != OK)
      return FAIL;

    /* Rule Element in Group */
    if (EN_MGCPMessage(ctx, MGCPMessage) != OK)
      return FAIL;
  }

  return OK;
}

void Free_MGCPMsgList(TMGCPMsgList *MGCPMsgList)
{
  /* Free elements in RuleList: MGCPMessage */
  while(MGCPMsgList->MGCPMessage.iNum-- > 0)
    Free_MGCPMessage((TMGCPMessage*)MGCPMsgList->MGCPMessage.pNode + MGCPMsgList->MGCPMessage.iNum);

  /* Free RuleList pointer: MGCPMessage */
  free(MGCPMsgList->MGCPMessage.pNode);
}

int DE_MGCPMessage(TCtx *ctx, TMGCPMessage *MGCPMessage)
{
  CtxSave(MGCPMessage, ctx);

  /* MGCPCommand */
  if (DE_MGCPCommand(ctx, &MGCPMessage->u.MGCPCommand) == OK)
  {
    MGCPMessage->iType = MGCPMessage_MGCPCommand;
    return OK;
  }

  CtxRestore(ctx, MGCPMessage);

  /* MGCPResponse */
  if (DE_MGCPResponse(ctx, &MGCPMessage->u.MGCPResponse) == OK)
  {
    MGCPMessage->iType = MGCPMessage_MGCPResponse;
    return OK;
  }

  return FAIL;
}

int EN_MGCPMessage(TCtx *ctx, TMGCPMessage *MGCPMessage)
{
  switch (MGCPMessage->iType)
  {
    /* MGCPCommand */
    case MGCPMessage_MGCPCommand:
      return EN_MGCPCommand(ctx, &MGCPMessage->u.MGCPCommand);

    /* MGCPResponse */
    case MGCPMessage_MGCPResponse:
      return EN_MGCPResponse(ctx, &MGCPMessage->u.MGCPResponse);
  }

  return FAIL;
}

void Free_MGCPMessage(TMGCPMessage *MGCPMessage)
{
  switch (MGCPMessage->iType)
  {
    /* Free MGCPCommand */
    case MGCPMessage_MGCPCommand:
      Free_MGCPCommand(&MGCPMessage->u.MGCPCommand);
    break;

    /* Free MGCPResponse */
    case MGCPMessage_MGCPResponse:
      Free_MGCPResponse(&MGCPMessage->u.MGCPResponse);
    break;

    default:
      Assert(0);
  }
}

int DE_MGCPCommand(TCtx *ctx, TMGCPCommand *MGCPCommand)
{
  /* Rule Element: MGCPCommandLine */
  if (DE_MGCPCommandLine(ctx, &MGCPCommand->MGCPCommandLine) != OK)
    return FAIL;

  /* Group Element: MGCPParameter */
  while (1)
  {
    TMGCPParameter *MGCPParameter = (TMGCPParameter*)ListNewNode(ctx, &MGCPCommand->MGCPParameter, sizeof(TMGCPParameter));

    CtxSave(MGCPParameter, ctx);

    /* Rule Element in Group */
    if (DE_MGCPParameter(ctx, MGCPParameter) != OK)
    {
      CtxRestore(ctx, MGCPParameter);
      ListRemoveLast(&MGCPCommand->MGCPParameter);
      break;
    }

    /* Token Element in Group: EOL */
    if (ParseToken(ctx, 1, 1, DE_EOL) != OK)
    {
      CtxRestore(ctx, MGCPParameter);
      ListRemoveLast(&MGCPCommand->MGCPParameter);
      break;
    }

    /* Rule num reach upper repeat limit */
    if (MGCPCommand->MGCPParameter.iNum >= 655)
      break;
  }

    /* Rule num less than lower repeat limit */
  if (MGCPCommand->MGCPParameter.iNum < 0)
    return FAIL;

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

    MGCPCommand->Announcement.pRuleData = (TAnnouncement*)AbnfAlloc(ctx, sizeof(TAnnouncement));

    /* Token Element in Option: EOL */
    if (ParseToken(ctx, 1, 1, DE_EOL) != OK)
    {
      CtxRestore(ctx, Announcement);
      break;
    }

    /* Rule Element in Option */
    if (DE_Announcement(ctx, (TAnnouncement*)MGCPCommand->Announcement.pRuleData) != OK)
    {
      CtxRestore(ctx, Announcement);
      break;
    }

    MGCPCommand->Announcement.flag = 1;
    break;
  }

  return OK;
}

int EN_MGCPCommand(TCtx *ctx, TMGCPCommand *MGCPCommand)
{
  int i_MGCPParameter = 0;

  /* Rule Element: MGCPCommandLine */
  if (EN_MGCPCommandLine(ctx, &MGCPCommand->MGCPCommandLine) != OK)
    return FAIL;

  /* Check rule number in list */
  if (MGCPCommand->MGCPParameter.iNum < 0 || MGCPCommand->MGCPParameter.iNum > 655)
    return FAIL;

  /* Group Element: MGCPParameter */
  for(i_MGCPParameter = 0; i_MGCPParameter < MGCPCommand->MGCPParameter.iNum; i_MGCPParameter++)
  {
    TMGCPParameter *MGCPParameter = (TMGCPParameter*)MGCPCommand->MGCPParameter.pNode + i_MGCPParameter;

    /* Rule Element in Group */
    if (EN_MGCPParameter(ctx, MGCPParameter) != OK)
      return FAIL;

    /* Token Element in Group: EOL */
    if (EncodeToken(ctx, 1, EN_EOL) != OK)
      return FAIL;
  }

  /* Opt Element: Announcement */
  if (MGCPCommand->Announcement.flag)
  {
    TAnnouncement *Announcement = (TAnnouncement*)MGCPCommand->Announcement.pRuleData;

    /* Token Element in Option: EOL */
    if (EncodeToken(ctx, 1, EN_EOL) != OK)
      return FAIL;

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

  return OK;
}

void Free_MGCPCommand(TMGCPCommand *MGCPCommand)
{
  /* Free Rule: MGCPCommandLine */
  Free_MGCPCommandLine(&MGCPCommand->MGCPCommandLine);

  /* Free elements in RuleList: MGCPParameter */
  while(MGCPCommand->MGCPParameter.iNum-- > 0)
    Free_MGCPParameter((TMGCPParameter*)MGCPCommand->MGCPParameter.pNode + MGCPCommand->MGCPParameter.iNum);

  /* Free RuleList pointer: MGCPParameter */
  free(MGCPCommand->MGCPParameter.pNode);

  /* Free Option: Announcement */
  if(MGCPCommand->Announcement.flag)
  {
    Free_Announcement((TAnnouncement*)MGCPCommand->Announcement.pRuleData);
    free(MGCPCommand->Announcement.pRuleData);
  }
}

int DE_MGCPCommandLine(TCtx *ctx, TMGCPCommandLine *MGCPCommandLine)
{
  /* Rule Element: MGCPVerb */
  if (DE_MGCPVerb(ctx, &MGCPCommandLine->MGCPVerb) != OK)
    return FAIL;

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

  /* Rule Element: Transaction_id */
  if (ParseStrRule(ctx, &MGCPCommandLine->Transaction_id, 1, 1, DE_Transaction_id) != OK)
    return FAIL;

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

  /* Rule Element: EndpointName */
  if (DE_EndpointName(ctx, &MGCPCommandLine->EndpointName) != OK)
    return FAIL;

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

  /* Rule Element: MGCPversion */
  if (DE_MGCPversion(ctx, &MGCPCommandLine->MGCPversion) != OK)
    return FAIL;

  /* Token Element: EOL */
  if (ParseToken(ctx, 1, 1, DE_EOL) != OK)
    return FAIL;

  return OK;
}

int EN_MGCPCommandLine(TCtx *ctx, TMGCPCommandLine *MGCPCommandLine)
{
  /* Rule Element: MGCPVerb */
  if (EN_MGCPVerb(ctx, &MGCPCommandLine->MGCPVerb) != OK)
    return FAIL;

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

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

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

  /* Rule Element: EndpointName */
  if (EN_EndpointName(ctx, &MGCPCommandLine->EndpointName) != OK)
    return FAIL;

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

  /* Rule Element: MGCPversion */
  if (EN_MGCPversion(ctx, &MGCPCommandLine->MGCPversion) != OK)
    return FAIL;

  /* Token Element: EOL */
  if (EncodeToken(ctx, 1, EN_EOL) != OK)
    return FAIL;

  return OK;
}

void Free_MGCPCommandLine(TMGCPCommandLine *MGCPCommandLine)
{
  /* Free Rule: MGCPVerb */
  Free_MGCPVerb(&MGCPCommandLine->MGCPVerb);

  /* Free String: Transaction_id */
  free(MGCPCommandLine->Transaction_id);

  /* Free Rule: EndpointName */
  Free_EndpointName(&MGCPCommandLine->EndpointName);

  /* Free Rule: MGCPversion */
  Free_MGCPversion(&MGCPCommandLine->MGCPversion);
}

int DE_MGCPversion(TCtx *ctx, TMGCPversion *MGCPversion)
{
  /* String Element: MGCP */
  if (ParseString(ctx, 1, 1, "MGCP") != OK)
    return FAIL;

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

  /* Rule Element: Version */
  if (ParseStrRule(ctx, &MGCPversion->Version, 1, 1, DE_Version) != OK)
    return FAIL;

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

    /* Token Element in Option: WSP */
    if (ParseToken(ctx, 1, 655, DE_WSP) != OK)
    {
      CtxRestore(ctx, ProfileName);
      break;
    }

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

    MGCPversion->ProfileName.flag = 1;
    break;
  }

  return OK;
}

int EN_MGCPversion(TCtx *ctx, TMGCPversion *MGCPversion)
{
  /* String Element: MGCP */
  if (EncodeString(ctx, 1, "MGCP") != OK)
    return FAIL;

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

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

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

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

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

  return OK;
}

void Free_MGCPversion(TMGCPversion *MGCPversion)
{
  /* Free String: Version */
  free(MGCPversion->Version);

  /* Free Option: ProfileName */
  if(MGCPversion->ProfileName.flag)
  {
    free(MGCPversion->ProfileName.pRuleData);
  }
}

int DE_Version(TCtx *ctx)
{
  /* Token Element: DIGIT */
  if (ParseToken(ctx, 1, 655, DE_DIGIT) != OK)
    return FAIL;

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

  /* Token Element: DIGIT */
  if (ParseToken(ctx, 1, 655, DE_DIGIT) != OK)
    return FAIL;

  return OK;
}

int DE_MGCPVerb(TCtx *ctx, TMGCPVerb *MGCPVerb)
{
  CtxSave(MGCPVerb, ctx);

  /* EPCF */
  if (ParseString(ctx, 1, 1, "EPCF") == OK)
  {
    MGCPVerb->iType = MGCPVerb_EPCF;
    return OK;
  }

  CtxRestore(ctx, MGCPVerb);

  /* CRCX */
  if (ParseString(ctx, 1, 1, "CRCX") == OK)
  {
    MGCPVerb->iType = MGCPVerb_CRCX;
    return OK;
  }

  CtxRestore(ctx, MGCPVerb);

  /* MDCX */
  if (ParseString(ctx, 1, 1, "MDCX") == OK)
  {
    MGCPVerb->iType = MGCPVerb_MDCX;
    return OK;
  }

  CtxRestore(ctx, MGCPVerb);

  /* DLCX */
  if (ParseString(ctx, 1, 1, "DLCX") == OK)
  {
    MGCPVerb->iType = MGCPVerb_DLCX;
    return OK;
  }

  CtxRestore(ctx, MGCPVerb);

  /* RQNT */
  if (ParseString(ctx, 1, 1, "RQNT") == OK)
  {
    MGCPVerb->iType = MGCPVerb_RQNT;
    return OK;
  }

  CtxRestore(ctx, MGCPVerb);

  /* NTFY */
  if (ParseString(ctx, 1, 1, "NTFY") == OK)
  {
    MGCPVerb->iType = MGCPVerb_NTFY;
    return OK;
  }

  CtxRestore(ctx, MGCPVerb);